itkJonesThicknessFilter.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 itkJonesThicknessFilter_h
#define itkJonesThicknessFilter_h
#include <itkImageToImageFilter.h>
#include <itkVector.h>
#include "itkCheckForThreeLevelsFilter.h"
#include "itkLaplacianSolverImageFilter.h"
#include "itkScalarImageToNormalizedGradientVectorImageFilter.h"
#include "itkIntegrateStreamlinesFilter.h"

namespace itk
{

template <typename TImageType, typename TScalarType, unsigned int NDimensions>
class ITK_EXPORT JonesThicknessFilter : public ImageToImageFilter<TImageType, TImageType>
{
  public:
    typedef JonesThicknessFilter                                Self;
    typedef ImageToImageFilter<TImageType, TImageType>          Superclass;
    typedef SmartPointer<Self>                                  Pointer;
    typedef SmartPointer<const Self>                            ConstPointer;
    typedef CheckForThreeLevelsFilter<TImageType>                                     CheckFilterType;
    typedef typename CheckFilterType::Pointer                                         CheckFilterPointer;
    typedef LaplacianSolverImageFilter<TImageType, TScalarType>                       LaplaceFilterType;
    typedef typename LaplaceFilterType::Pointer                                       LaplaceFilterPointer;
    typedef ScalarImageToNormalizedGradientVectorImageFilter<TImageType, TScalarType> NormalsFilterType;
    typedef typename NormalsFilterType::Pointer                                       NormalsFilterPointer;
    typedef IntegrateStreamlinesFilter<TImageType, TScalarType, NDimensions>          IntegrateFilterType;
    typedef typename IntegrateFilterType::Pointer                                     IntegrateFilterPointer;
    typedef typename NormalsFilterType::OutputImageType                               VectorNormalImageType;
    typedef typename VectorNormalImageType::Pointer                                   VectorNormalImagePointer;
    typedef typename LaplaceFilterType::OutputImageType                               LaplacianImageType;
    
    itkNewMacro(Self);
    
    itkTypeMacro(JonesThicknessFilter, ImageToImageFilter);

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

    itkSetMacro(LowVoltage, TScalarType);
    itkGetMacro(LowVoltage, TScalarType);

    itkSetMacro(HighVoltage, TScalarType);
    itkGetMacro(HighVoltage, TScalarType);

    itkSetMacro(LaplaceEpsionRatio, TScalarType);
    itkGetMacro(LaplaceEpsionRatio, TScalarType);

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

    itkSetMacro(WhiteMatterLabel, short int);
    itkGetMacro(WhiteMatterLabel, short int);

    itkSetMacro(GreyMatterLabel, short int);
    itkGetMacro(GreyMatterLabel, short int);

    itkSetMacro(CSFMatterLabel, short int);
    itkGetMacro(CSFMatterLabel, short int);

    itkSetMacro(MinimumStepSize, TScalarType);
    itkGetMacro(MinimumStepSize, TScalarType);

    itkSetMacro(MaximumLength, TScalarType);
    itkGetMacro(MaximumLength, TScalarType);

    itkSetMacro(Sigma, TScalarType);
    itkGetMacro(Sigma, TScalarType);

    itkSetMacro(UseLabels, bool);
    itkGetMacro(UseLabels, bool);

    itkSetMacro(UseSmoothing, bool);
    itkGetMacro(UseSmoothing, bool);

    void SetVectorNormalsOverrideImage(VectorNormalImageType* v);
    VectorNormalImageType* GetVectorNormalsOverrideImage();
    VectorNormalImageType* GetVectorNormalsFilterImage();
    LaplacianImageType* GetLaplacianFilterImage();
    
  protected:
    
    JonesThicknessFilter();
    virtual ~JonesThicknessFilter() {};

    // The main filter method. Note, single threaded.
    virtual void GenerateData();
    
  private:
    JonesThicknessFilter(const Self&); // purposely not implemented
    void operator=(const Self&); // purposely not implemented

    TScalarType m_LowVoltage;
    TScalarType m_HighVoltage;
    TScalarType m_LaplaceEpsionRatio;
    unsigned long int m_LaplaceMaxIterations;
    short int m_WhiteMatterLabel;
    short int m_GreyMatterLabel;
    short int m_CSFMatterLabel;
    TScalarType m_MinimumStepSize;
    TScalarType m_MaximumLength;
    TScalarType m_Sigma;
    bool m_DontUseGaussSiedel;
    bool m_UseLabels;
    bool m_UseSmoothing;
    
    CheckFilterPointer m_CheckFilter;
    LaplaceFilterPointer m_LaplaceFilter;
    NormalsFilterPointer m_NormalsFilter;
    IntegrateFilterPointer m_IntegrateFilter;
    VectorNormalImagePointer m_NormalsOverrideImage;
    
};

} // end namespace itk
  
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkJonesThicknessFilter.txx"
#endif
  
#endif