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.txx"
#endif

#endif /* __itkShortestPathCostFunctionLiveWire_h */