itkShortestPathCostFunctionLiveWire.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 itkShortestPathCostFunctionLiveWire_h
#define itkShortestPathCostFunctionLiveWire_h
 
#include <itkShortestPathCostFunction.h>
 
#include <itkImageRegionConstIterator.h>
 
namespace itk
{
  template <class TInputImageType>
  class ITK_EXPORT ShortestPathCostFunctionLiveWire : public ShortestPathCostFunction<TInputImageType>
  {
  public:
    typedef ShortestPathCostFunctionLiveWire Self;
    typedef ShortestPathCostFunction<TInputImageType> Superclass;
    typedef SmartPointer<Self> Pointer;
    typedef SmartPointer<const Self> ConstPointer;
    typedef itk::ImageRegionConstIterator<TInputImageType> ConstIteratorType;
 
    itkFactorylessNewMacro(Self);
    itkCloneMacro(Self);
 
      itkTypeMacro(ShortestPathCostFunctionLiveWire, ShortestPathCostFunction);
 
    typedef itk::Image<unsigned char, 2> UnsignedCharImageType;
    typedef itk::Image<float, 2> FloatImageType;
 
    typedef float ComponentType;
    typedef itk::CovariantVector<ComponentType, 2> OutputPixelType;
    typedef itk::Image<OutputPixelType, 2> VectorOutputImageType;
 
    typedef typename TInputImageType::IndexType IndexType;
    typedef TInputImageType ImageType;
    typedef itk::ImageRegion<2> RegionType;
 
    double GetCost(IndexType p1, IndexType p2) override;
 
    double GetMinCost() override;
 
    void Initialize() override;
 
    virtual void AddRepulsivePoint(const IndexType &index);
 
    virtual void RemoveRepulsivePoint(const IndexType &index);
 
    virtual void ClearRepulsivePoints();
 
    itkSetMacro(RequestedRegion, RegionType);
    itkGetMacro(RequestedRegion, RegionType);
 
    void SetImage(const TInputImageType *_arg) override;
 
    void SetDynamicCostMap(std::map<int, int> &costMap)
    {
      this->m_CostMap = costMap;
      this->m_UseCostMap = true;
      this->m_MaxMapCosts = -1;
      this->Modified();
    }
 
    void SetUseCostMap(bool useCostMap) { this->m_UseCostMap = useCostMap; }
 
    void SetCostMapMaximum(double max) { this->m_MaxMapCosts = max; }
 
    enum Constants
    {
      MAPSCALEFACTOR = 10 
    };
 
    static double Gaussian(double x, double xOfGaussian, double yOfGaussian);
 
    const UnsignedCharImageType *GetMaskImage() { return this->m_MaskImage.GetPointer(); };
 
    const FloatImageType *GetGradientMagnitudeImage() { return this->m_GradientMagnitudeImage.GetPointer(); };
 
    const FloatImageType *GetEdgeImage() { return this->m_EdgeImage.GetPointer(); };
 
    const VectorOutputImageType *GetGradientImage() { return this->m_GradientImage.GetPointer(); };
  protected:
    ShortestPathCostFunctionLiveWire();
 
    ~ShortestPathCostFunctionLiveWire() override{};
 
    FloatImageType::Pointer m_GradientMagnitudeImage;
    FloatImageType::Pointer m_EdgeImage;
    UnsignedCharImageType::Pointer m_MaskImage;
    VectorOutputImageType::Pointer m_GradientImage;
 
    double m_MinCosts;
 
    bool m_UseRepulsivePoints;
 
    typename Superclass::PixelType val;
 
    typename Superclass::PixelType startValue;
    typename Superclass::PixelType endValue;
 
    double m_GradientMax;
 
    RegionType m_RequestedRegion;
 
    bool m_Initialized;
 
    std::map<int, int> m_CostMap;
 
    bool m_UseCostMap;
 
    double m_MaxMapCosts;
 
  private:
    double SigmoidFunction(double I, double max, double min, double alpha, double beta);
  };
 
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#include <itkShortestPathCostFunctionLiveWire.tpp>
#endif
 
#endif /* itkShortestPathCostFunctionLiveWire_h */