itkShortestPathImageFilter.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
#ifndef itkShortestPathImageFilter_h
#define itkShortestPathImageFilter_h
 
#include <itkImageToImageFilter.h>
#include <itkShortestPathCostFunction.h>
#include <itkShortestPathNode.h>
#include <itkImageRegionIteratorWithIndex.h>
 
#include <itkMacro.h>
 
namespace itk
{
  template <class TInputImageType, class TOutputImageType>
  class ShortestPathImageFilter : public ImageToImageFilter<TInputImageType, TOutputImageType>
  {
  public:
    // Standard Typedefs
    typedef ShortestPathImageFilter Self;
    typedef ImageToImageFilter<TInputImageType, TOutputImageType> Superclass;
    typedef SmartPointer<Self> Pointer;
    typedef SmartPointer<const Self> ConstPointer;
 
    // Typedefs for metric
    typedef ShortestPathCostFunction<TInputImageType> CostFunctionType;
    typedef typename CostFunctionType::Pointer CostFunctionTypePointer;
 
    // More typedefs for convenience
    typedef TInputImageType InputImageType;
    typedef typename TInputImageType::Pointer InputImagePointer;
    typedef typename TInputImageType::PixelType InputImagePixelType;
    typedef typename TInputImageType::SizeType InputImageSizeType;
    typedef typename TInputImageType::IndexType IndexType;
    typedef typename itk::ImageRegionIteratorWithIndex<InputImageType> InputImageIteratorType;
 
    typedef TOutputImageType OutputImageType;
    typedef typename TOutputImageType::Pointer OutputImagePointer;
    typedef typename TOutputImageType::PixelType OutputImagePixelType;
    typedef typename TOutputImageType::IndexType OutputImageIndexType;
    typedef ImageRegionIteratorWithIndex<OutputImageType> OutputImageIteratorType;
    typedef itk::ShapedNeighborhoodIterator<TInputImageType> itkShapedNeighborhoodIteratorType;
 
    // New Macro for smartpointer instantiation
    itkFactorylessNewMacro(Self);
    itkCloneMacro(Self);
 
    // Run-time type information
    itkTypeMacro(ShortestPathImageFilter, ImageToImageFilter);
 
    void PrintSelf(std::ostream &os, Indent indent) const override;
 
    struct CompareNodeStar
    {
      bool operator()(ShortestPathNode *a, ShortestPathNode *b) { return (a->distAndEst > b->distAndEst); }
    };
 
    void SetStartIndex(const IndexType &StartIndex);
 
    void AddEndIndex(const IndexType &index);
 
    void SetEndIndex(const IndexType &EndIndex);
 
    itkSetMacro(FullNeighborsMode, bool);
    itkGetMacro(FullNeighborsMode, bool);
 
    itkSetMacro(Graph_fullNeighbors, bool);
 
    itkSetMacro(MakeOutputImage, bool);
    itkGetMacro(MakeOutputImage, bool);
 
    itkSetMacro(StoreVectorOrder, bool);
    itkGetMacro(StoreVectorOrder, bool);
 
    itkSetMacro(CalcAllDistances, bool);
    itkGetMacro(CalcAllDistances, bool);
 
    itkSetMacro(ActivateTimeOut, bool);
    itkGetMacro(ActivateTimeOut, bool);
 
    std::vector<IndexType> GetVectorPath();
 
    std::vector<std::vector<IndexType>> GetMultipleVectorPaths();
 
    OutputImagePointer GetVectorOrderImage();
 
    OutputImagePointer GetDistanceImage();
 
    void MakeShortestPathVector();
 
    void CleanUp();
 
    itkSetObjectMacro(CostFunction, CostFunctionType);
    itkGetObjectMacro(CostFunction, CostFunctionType);
 
    void SetUseCostFunction(bool doUseCostFunction) { m_useCostFunction = doUseCostFunction; };
 
    bool GetUseCostFunction() { return m_useCostFunction; };
 
  protected:
    std::vector<IndexType>
      m_endPoints; // if you fill this vector, the algo will not rest until all endPoints have been reached
    std::vector<IndexType> m_endPointsClosed;
 
    ShortestPathNode *m_Nodes; // main list that contains all nodes
    NodeNumType m_Graph_NumberOfNodes;
    NodeNumType m_Graph_StartNode;
    NodeNumType m_Graph_EndNode;
    bool m_Graph_fullNeighbors;
    bool m_useCostFunction;
    std::vector<ShortestPathNode *> m_Graph_DiscoveredNodeList;
    ShortestPathImageFilter(Self &); // intentionally not implemented
    void operator=(const Self &);    // intentionally not implemented
    const static int BACKGROUND = 0;
    const static int FOREGROUND = 255;
    bool m_FullNeighborsMode;
 
    bool m_MakeOutputImage;
    bool m_StoreVectorOrder; // Store an Vector of Order, so you can call getVectorOrderImage after update
    bool m_CalcAllDistances; // Calculate all Distances, so you can call getDistanceImage after update (warning algo
                             // will take a long time)
 
    bool multipleEndPoints;
 
    bool m_ActivateTimeOut; // if true, then i search max. 30 secs. then abort
 
    bool m_Initialized;
 
    CostFunctionTypePointer m_CostFunction;
    IndexType m_StartIndex, m_EndIndex;
    std::vector<IndexType> m_VectorPath;
    std::vector<std::vector<IndexType>> m_MultipleVectorPaths;
 
    std::vector<NodeNumType> m_VectorOrder;
 
    ShortestPathImageFilter();
 
    ~ShortestPathImageFilter() override;
 
    // \brief Create all the outputs
    void MakeOutputs();
 
    // \brief Generate Data
    void GenerateData() override;
 
    // \brief gets the estimate costs from pixel a to target.
    double getEstimatedCostsToTarget(const IndexType &a);
 
    typename InputImageType::Pointer m_magnitudeImage;
 
    // \brief Convert a indexnumber of a node in m_Nodes to image coordinates
    typename TInputImageType::IndexType NodeToCoord(NodeNumType);
 
    // \brief Convert image coordinate to a indexnumber of a node in m_Nodes
    unsigned int CoordToNode(IndexType);
 
    // \brief Returns the neighbors of a node
    std::vector<ShortestPathNode *> GetNeighbors(NodeNumType nodeNum, bool FullNeighbors);
 
    // \brief Check if coords are in bounds of image
    bool CoordIsInBounds(IndexType);
 
    // \brief Initializes the graph
    void InitGraph();
 
    // \brief Start ShortestPathSearch
    void StartShortestPathSearch();
  };
 
} // end of namespace itk
 
#include <itkShortestPathImageFilter.tpp>
 
#endif