itkSpeedFunctionToPathFilter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkSpeedFunctionToPathFilter.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 itkSpeedFunctionToPathFilter_h
#define itkSpeedFunctionToPathFilter_h

#include "itkArrivalFunctionToPathFilter.h"
#include "itkSpeedFunctionPathInformation.h"

namespace itk
{

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

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

  itkTypeMacro(SpeedFunctionToPathFilter,ArrivalFunctionToPathFilter);

  itkNewMacro(Self);

  static constexpr unsigned int InputImageDimension = TInputImage::ImageDimension;

  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;

  using ContinuousIndexType = typename Superclass::ContinuousIndexType;
  using IndexType = typename Superclass::IndexType;
  using PointType = typename Superclass::PointType;
  using CostFunctionType = typename Superclass::CostFunctionType;
  using OptimizerType = typename Superclass::OptimizerType;

  using PathInformationType = SpeedFunctionPathInformation<PointType>;
  using PointsContainerType = typename PathInformationType::PointsContainerType;

  void SetPathEndPoint( const PointType& ) override
  {
    itkWarningMacro("SetPathEndPoint() is not valid for this filter. Use AddPathInfo() instead.");
  }

  void AddPathEndPoint( const PointType& ) override
  {
    itkWarningMacro("AddPathEndPoint() is not valid for this filter. Use AddPathInfo() instead.");
  }

  void ClearPathEndPoints() override
  {
    itkWarningMacro("ClearPathEndPoints() is not valid for this filter. Use ClearPathInfo() instead.");
  }

  void AddPathInformation(PathInformationType * info )
  {
    m_Information.push_back( info );
  }

  void ClearPathInformation()
  {
    m_Information.clear( );
  }

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

  itkGetConstMacro( CurrentArrivalFunction, InputImagePointer );

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

  void GenerateData( void ) override;

  unsigned int GetNumberOfPathsToExtract( ) const override;

  InputImageType * ComputeArrivalFunction( ) override;

  const PointsContainerType & GetNextEndPoint( ) override;

  std::vector< typename PathInformationType::Pointer > m_Information;
  InputImagePointer                                    m_CurrentArrivalFunction;
};

} // end namespace itk

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

#endif