itkLagrangianInitializedRelaxStreamlinesFilter.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 itkLagrangianInitializedRelaxStreamlinesFilter_h
#define itkLagrangianInitializedRelaxStreamlinesFilter_h

#include "itkRelaxStreamlinesFilter.h"
#include <itkContinuousIndex.h>

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

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

  itkTypeMacro(LagrangianInitializedRelaxStreamlinesFilter, RelaxStreamlinesFilter);

  typedef typename Superclass::InputVectorImagePixelType      InputVectorImagePixelType;
  typedef typename Superclass::InputVectorImageType           InputVectorImageType;
  typedef typename Superclass::InputVectorImagePointer        InputVectorImagePointer;
  typedef typename Superclass::InputVectorImageConstPointer   InputVectorImageConstPointer;
  typedef typename Superclass::InputVectorImageIndexType      InputVectorImageIndexType; 
  typedef typename Superclass::InputScalarImagePixelType      InputScalarImagePixelType;
  typedef typename Superclass::InputScalarImageType           InputScalarImageType;
  typedef typename Superclass::InputScalarImageSpacingType    InputScalarImageSpacingType;
  typedef typename Superclass::InputScalarImagePointType      InputScalarImagePointType;
  typedef typename Superclass::InputScalarImagePointer        InputScalarImagePointer;
  typedef typename Superclass::InputScalarImageIndexType      InputScalarImageIndexType;
  typedef typename Superclass::InputScalarImageConstPointer   InputScalarImageConstPointer;
  typedef typename Superclass::InputScalarImageRegionType     InputScalarImageRegionType;
  typedef typename Superclass::OutputImageType                OutputImageType;
  typedef typename Superclass::OutputImagePixelType           OutputImagePixelType;
  typedef typename Superclass::OutputImagePointer             OutputImagePointer;
  typedef typename Superclass::OutputImageConstPointer        OutputImageConstPointer;
  typedef typename Superclass::OutputImageIndexType           OutputImageIndexType;
  typedef typename Superclass::OutputImageSpacingType         OutputImageSpacingType;
  typedef typename Superclass::OutputImageRegionType          OutputImageRegionType;
  typedef typename Superclass::OutputImageSizeType            OutputImageSizeType;
  typedef typename Superclass::VectorInterpolatorType         VectorInterpolatorType;
  typedef typename Superclass::VectorInterpolatorPointer      VectorInterpolatorPointer;
  typedef typename Superclass::VectorInterpolatorPointType    VectorInterpolatorPointType;
  typedef typename Superclass::ScalarInterpolatorType         ScalarInterpolatorType;
  typedef typename Superclass::ScalarInterpolatorPointer      ScalarInterpolatorPointer;
  typedef typename Superclass::ScalarInterpolatorPointType    ScalarInterpolatorPointType;
  typedef ContinuousIndex<TScalarType, NDimensions>           ContinuousIndexType;
  
  void SetSegmentedImage(const InputScalarImageType *image) {this->SetNthInput(2, const_cast<InputScalarImageType *>(image)); }

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

  itkSetObjectMacro(GreyMatterPVInterpolator, ScalarInterpolatorType);
  itkGetObjectMacro(GreyMatterPVInterpolator, ScalarInterpolatorType);
  
  itkSetMacro(StepSizeThreshold, double);
  itkGetMacro(StepSizeThreshold, double);

  itkSetMacro(GreyMatterPercentage, double);
  itkGetMacro(GreyMatterPercentage, double);

  itkGetMacro(MaximumSearchDistance, double);
  void SetMaximumSearchDistance(double d)
    {
      m_MaximumSearchDistance = d;
      m_DefaultMaximumSearchDistance = false;
    }

  itkSetMacro(DefaultMaximumSearchDistance, bool);
  itkGetMacro(DefaultMaximumSearchDistance, bool);
  
protected:
  LagrangianInitializedRelaxStreamlinesFilter();
  ~LagrangianInitializedRelaxStreamlinesFilter() {};
  void PrintSelf(std::ostream& os, Indent indent) const;

  virtual void InitializeBoundaries(
    std::vector<InputScalarImageIndexType>& completeListOfGreyMatterPixels,
    InputScalarImageType* scalarImage,
    InputVectorImageType* vectorImage,
    OutputImageType* L0Image,
    OutputImageType* L1Image,
    std::vector<InputScalarImageIndexType>& L0greyList,
    std::vector<InputScalarImageIndexType>& L1greyList
    );

  OutputImagePixelType LagrangianInitialisation(
    ContinuousIndexType& index, 
    double& direction,
    double& defaultStepSize, 
    double& minStepSize,
    InputVectorImageType* vectorImage,
    InputScalarImageType* greyMatterPVMap);

  void UpdateGMPVMap(
      std::vector<InputScalarImageIndexType>& listOfGreyMatterPixels,
      InputScalarImageType* segmentedImage,
      InputVectorImageType* vectorImage,
      InputScalarImageType* gmPVMapImage, 
      InputScalarImageType* editedPVMap);
  
  double GetMaxStepSize(InputScalarImageType* image);
  
private:
  
  LagrangianInitializedRelaxStreamlinesFilter(const Self&); 
  void operator=(const Self&); 

  double m_StepSizeThreshold;
  
  double m_GreyMatterPercentage;
  
  double m_MaximumSearchDistance;
  
  bool m_DefaultMaximumSearchDistance;
  
  ScalarInterpolatorPointer m_GreyMatterPVInterpolator;
  
  VectorInterpolatorPointer m_NormalsInterpolator;
};

} // end namespace

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

#endif