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:
  typedef  ArrivalFunctionToPathCommand Self;
  typedef  itk::Command                 Superclass;
  typedef  itk::SmartPointer<Self>      Pointer;

  itkNewMacro( Self );

  typedef TFilter FilterType;

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

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

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

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

private:
  ArrivalFunctionToPathCommand( const Self& );
  void operator = ( const Self& );

  typename FilterType::Pointer m_Filter;
};


template <class TInputImage,
          class TOutputPath = PolyLineParametricPath<TInputImage::ImageDimension> >
class ITK_EXPORT ArrivalFunctionToPathFilter :
    public ImageToPathFilter<TInputImage,TOutputPath>
{
public:
  typedef ArrivalFunctionToPathFilter                Self;
  typedef ImageToPathFilter<TInputImage,TOutputPath> Superclass;
  typedef SmartPointer<Self>                         Pointer;
  typedef SmartPointer<const Self>                   ConstPointer;

  itkTypeMacro(ArrivalFunctionToPathFilter,ImageToPathFilter);

  itkNewMacro(Self);

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

  typedef TOutputPath                             OutputPathType;
  typedef typename OutputPathType::Pointer        OutputPathPointer;
  typedef typename OutputPathType::ConstPointer   OutputPathConstPointer;

  itkStaticConstMacro(InputImageDimension, unsigned int,
                      InputImageType::ImageDimension);

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

  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();
  virtual void PrintSelf(std::ostream& os, Indent indent) const;

  void GenerateInputRequestedRegion();

  void GenerateData(void);

  virtual unsigned int GetNumberOfPathsToExtract( ) const;

  virtual InputImageType * ComputeArrivalFunction( );

  virtual const PointType & GetNextEndPoint( );

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

private:
  ArrivalFunctionToPathFilter(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented
};

} // end namespace itk

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

#endif