itkArrivalFunctionToPathFilter.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkArrivalFunctionToPathFilter.h,v $
  Language:  C++
  Date:      $Date$
  Version:   $Revision$

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef itkArrivalFunctionToPathFilter_h
#define itkArrivalFunctionToPathFilter_h

#include "itkImage.h"
#include "itkCommand.h"
#include "itkImageToPathFilter.h"
#include "itkSingleImageCostFunction.h"
#include "itkRegularStepGradientDescentOptimizer.h"
#include "itkSingleValuedNonLinearOptimizer.h"
#include "itkPolyLineParametricPath.h"

namespace itk
{
template <class TFilter>
class ArrivalFunctionToPathCommand : public itk::Command
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(ArrivalFunctionToPathCommand);

  using Self = ArrivalFunctionToPathCommand;
  using Superclass = itk::Command;
  using Pointer = itk::SmartPointer<Self>;

  itkNewMacro( Self );

  using FilterType = TFilter;

  itkSetObjectMacro( Filter, FilterType );
  itkGetConstObjectMacro( Filter, FilterType );

  void Execute(itk::Object *caller, const itk::EventObject & event) override
    {
    Execute( (const itk::Object *)caller, event);
    }

  void Execute(const itk::Object * object, const itk::EventObject & event) override
    {
    if( ! itk::IterationEvent().CheckEvent( &event ) )
      {
      return;
      }
    // Pass event to Filter
    if ( m_Filter.IsNotNull() )
      {
      m_Filter->Execute( object, event );
      }
    }

protected:
  ArrivalFunctionToPathCommand(){}
  ~ArrivalFunctionToPathCommand() override{}

private:
  typename FilterType::Pointer m_Filter;
};


template <class TInputImage,
          class TOutputPath = PolyLineParametricPath<TInputImage::ImageDimension> >
class ITK_EXPORT ArrivalFunctionToPathFilter :
    public ImageToPathFilter<TInputImage,TOutputPath>
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(ArrivalFunctionToPathFilter);

  using Self = ArrivalFunctionToPathFilter;
  using Superclass = ImageToPathFilter<TInputImage,TOutputPath>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;

  itkTypeMacro(ArrivalFunctionToPathFilter,ImageToPathFilter);

  itkNewMacro(Self);

  using InputImageType = TInputImage;
  using InputImagePointer = typename InputImageType::Pointer;
  using InputImageConstPointer = typename InputImageType::ConstPointer;
  using InputImageRegionType = typename InputImageType::RegionType;
  using InputImagePixelType = typename InputImageType::PixelType;

  using OutputPathType = TOutputPath;
  using OutputPathPointer = typename OutputPathType::Pointer;
  using OutputPathConstPointer = typename OutputPathType::ConstPointer;

  static constexpr unsigned int InputImageDimension = InputImageType::ImageDimension;

  using IndexType = Index< InputImageDimension >;
  using ContinuousIndexType = ContinuousIndex< double, InputImageDimension >;
  using PointType = Point< double, InputImageDimension >;
  using CommandType = ArrivalFunctionToPathCommand< Self >;
  using CostFunctionType = SingleImageCostFunction< InputImageType >;
  using OptimizerType = SingleValuedNonLinearOptimizer;
  using DefaultOptimizerType = RegularStepGradientDescentOptimizer;

  using PointsContainerType = std::vector < PointType>;

  itkSetObjectMacro( Optimizer, OptimizerType );
  itkGetConstObjectMacro( Optimizer, OptimizerType );

  itkSetObjectMacro( CostFunction, CostFunctionType );
  itkGetConstObjectMacro( CostFunction, CostFunctionType );

  virtual void SetPathEndPoint( const PointType & point );

  virtual void AddPathEndPoint( const PointType & point );

  virtual void ClearPathEndPoints();

  itkSetMacro(TerminationValue, typename OptimizerType::MeasureType);
  itkGetMacro(TerminationValue, typename OptimizerType::MeasureType);

  virtual void Execute( const itk::Object * object, const itk::EventObject & event );

protected:
  ArrivalFunctionToPathFilter();
  ~ArrivalFunctionToPathFilter() override;
  void PrintSelf(std::ostream& os, Indent indent) const override;

  void GenerateInputRequestedRegion() override;

  void GenerateData(void) override;

  virtual unsigned int GetNumberOfPathsToExtract( ) const;

  virtual InputImageType * ComputeArrivalFunction( );

  virtual const PointsContainerType & GetNextEndPoint( );

  typename CostFunctionType::Pointer m_CostFunction;
  typename OptimizerType::Pointer m_Optimizer;
  typename OptimizerType::MeasureType m_TerminationValue;
  std::vector<PointsContainerType> m_PointList;
  unsigned int m_CurrentOutput;
};

} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkArrivalFunctionToPathFilter.hxx"
#endif

#endif