itkRelaxStreamlinesFilter.h

Go to the documentation of this file.

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

  NifTK: A software platform for medical image computing.

  Copyright (c) University College London (UCL). All rights reserved.

  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.

  See LICENSE.txt in the top level directory for details.

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

#ifndef itkRelaxStreamlinesFilter_h
#define itkRelaxStreamlinesFilter_h

#include <itkImage.h>
#include <itkVector.h>
#include <itkPoint.h>
#include "itkBaseCTEStreamlinesFilter.h"
#include <itkVectorInterpolateImageFunction.h>
#include <itkInterpolateImageFunction.h>


namespace itk {
template < class TImageType, typename TScalarType, unsigned int NDimensions> 
class ITK_EXPORT RelaxStreamlinesFilter :
  public BaseCTEStreamlinesFilter<TImageType, TScalarType, NDimensions>
{
public:

  typedef RelaxStreamlinesFilter                                          Self;
  typedef BaseCTEStreamlinesFilter<TImageType, TScalarType, NDimensions>  Superclass;
  typedef SmartPointer<Self>                                              Pointer;
  typedef SmartPointer<const Self>                                        ConstPointer;
  
  itkNewMacro(Self);

  itkTypeMacro(RelaxStreamlinesFilter, BaseStreamlinesFilter);

  itkStaticConstMacro(Dimension, unsigned int, NDimensions);

  typedef Vector< TScalarType, NDimensions >                     InputVectorImagePixelType;
  typedef Image< InputVectorImagePixelType, NDimensions >        InputVectorImageType;
  typedef typename InputVectorImageType::Pointer                 InputVectorImagePointer;
  typedef typename InputVectorImageType::ConstPointer            InputVectorImageConstPointer;
  typedef typename InputVectorImageType::IndexType               InputVectorImageIndexType; 
  typedef TScalarType                                            InputScalarImagePixelType;
  typedef Image< InputScalarImagePixelType, NDimensions >        InputScalarImageType;
  typedef Point<TScalarType, NDimensions>                        InputScalarImagePointType;
  typedef typename InputScalarImageType::SpacingType             InputScalarImageSpacingType;
  typedef typename InputScalarImageType::Pointer                 InputScalarImagePointer;
  typedef typename InputScalarImageType::IndexType               InputScalarImageIndexType;
  typedef typename InputScalarImageType::ConstPointer            InputScalarImageConstPointer;
  typedef typename InputScalarImageType::RegionType              InputScalarImageRegionType;
  typedef InputScalarImageType                                   OutputImageType;
  typedef typename OutputImageType::PixelType                    OutputImagePixelType;
  typedef typename OutputImageType::Pointer                      OutputImagePointer;
  typedef typename OutputImageType::ConstPointer                 OutputImageConstPointer;
  typedef typename OutputImageType::IndexType                    OutputImageIndexType;
  typedef typename OutputImageType::SpacingType                  OutputImageSpacingType;
  typedef typename OutputImageType::RegionType                   OutputImageRegionType;
  typedef typename OutputImageType::SizeType                     OutputImageSizeType;
  typedef VectorInterpolateImageFunction<InputVectorImageType
                                         ,TScalarType
                                        >                        VectorInterpolatorType;
  typedef typename VectorInterpolatorType::Pointer               VectorInterpolatorPointer;
  typedef typename VectorInterpolatorType::PointType             VectorInterpolatorPointType;
  typedef InterpolateImageFunction< InputScalarImageType
                                    ,TScalarType >               ScalarInterpolatorType;
  typedef typename ScalarInterpolatorType::Pointer               ScalarInterpolatorPointer;
  typedef typename ScalarInterpolatorType::PointType             ScalarInterpolatorPointType;
                                        
  void SetScalarImage(const InputScalarImageType *image) {this->SetNthInput(0, const_cast<InputScalarImageType *>(image)); }

  void SetVectorImage(const InputVectorImageType* image) { this->SetNthInput(1, const_cast<InputVectorImageType *>(image)); }

  void SetSegmentedImage(const InputScalarImageType *image) {this->SetNthInput(2, const_cast<InputScalarImageType *>(image)); }

  itkSetMacro(EpsilonConvergenceThreshold, double);
  itkGetMacro(EpsilonConvergenceThreshold, double);

  itkSetMacro(MaximumNumberOfIterations, unsigned long int );
  itkGetMacro(MaximumNumberOfIterations, unsigned long int );

  itkSetMacro(MaximumLength, double );
  itkGetMacro(MaximumLength, double );

  itkSetMacro(InitializeBoundaries, bool);
  itkGetMacro(InitializeBoundaries, bool);
  
  OutputImageType* GetL0Image() const { return m_L0Image.GetPointer(); }
  OutputImageType* GetL1Image() const { return m_L1Image.GetPointer(); }

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

  // The main filter method. Note, single threaded.
  virtual void GenerateData();
  
  // We set the whole of L0 and L1 image to zero,
  // and extract the set of GM voxels. We then 
  // call this method to initialize the boundaries.
  // The implementation in this class does nothing.
  // However, derived classes can initialize points in
  // the L0 and L1 image, and also change the size of
  // the listOfGreyMatterPixels vector.
  virtual void InitializeBoundaries(
    std::vector<InputScalarImageIndexType>& completeListOfGreyMatterPixels,
    InputScalarImageType* scalarImage,
    InputVectorImageType* vectorImage,
    OutputImageType* L0Image,
    OutputImageType* L1Image,
    std::vector<InputScalarImageIndexType>& L0greyList,
    std::vector<InputScalarImageIndexType>& L1greyList
    );

  virtual void SolvePDE(
      bool isInnerBoundary,
      std::vector<InputScalarImageIndexType>& listOfGreyPixels,
      InputScalarImageType* scalarImage,
      InputVectorImageType* vectorImage,
      OutputImageType* outputImage
      );
  
  double m_EpsilonConvergenceThreshold;
  
  unsigned long int m_MaximumNumberOfIterations;
  
  double m_MaximumLength;

  bool m_InitializeBoundaries;
  
private:
  
  RelaxStreamlinesFilter(const Self&); 
  void operator=(const Self&); 

  OutputImagePointer m_L0Image;
  OutputImagePointer m_L1Image;

};

} // end namespace

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkRelaxStreamlinesFilter.txx"
#endif

#endif