itkRegistrationBasedCorticalThicknessFilter.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 itkRegistrationBasedCorticalThicknessFilter_h
#define itkRegistrationBasedCorticalThicknessFilter_h

#include <itkImageToImageFilter.h>

namespace itk {

/*
 * \class RegistrationBasedCorticalThicknessFilter
 * \brief This class implements Das et al Neuroimage 45 (2009) 867-879.
 *
 * The inputs to this filter should be exactly as follows.
 * <pre>
 * input1 = white matter pv image, set using SetWhiteMatterPVMap(image)
 * input2 = white + grey pv image, set using SetWhitePlusGreyMatterPVMap(image)
 * input3 = thickness prior image, set using SetThicknessPriorMap(image)
 * input4 = the grey white border, as a binary image where 1 = boundary and 0 is background, set using SetGWI(image)
 * </pre>
 *
 * The output is the DiReCT thickness map.
 *
 * The image types should all be the same size and float. Note that this class
 * uses a stationary velocity field, so you can't set n as mentioned in the paper.
 * n is always 1.
 *
 */
template< class TInputImage, typename TScalarType>
class ITK_EXPORT RegistrationBasedCorticalThicknessFilter :
  public ImageToImageFilter<TInputImage, TInputImage>
{
public:

  typedef TScalarType                                                   VectorDataType;
  typedef RegistrationBasedCorticalThicknessFilter                      Self;
  typedef ImageToImageFilter<TInputImage, TInputImage>                  Superclass;
  typedef SmartPointer<Self>                                            Pointer;
  typedef SmartPointer<const Self>                                      ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(RegistrationBasedCorticalThicknessFilter, ImageToImageFilter);

  itkStaticConstMacro(Dimension, unsigned int, TInputImage::ImageDimension);

  typedef TInputImage                                                   ImageType;
  typedef typename ImageType::PixelType                                 PixelType;
  typedef typename ImageType::Pointer                                   ImagePointer;
  typedef typename ImageType::SizeType                                  SizeType;
  typedef typename ImageType::IndexType                                 IndexType;
  typedef typename ImageType::RegionType                                RegionType;
  typedef typename ImageType::SpacingType                               SpacingType;
  typedef typename ImageType::PointType                                 OriginType;
  typedef typename ImageType::DirectionType                             DirectionType;
  typedef TScalarType                                                   MaskPixelType;
  typedef Image< MaskPixelType, itkGetStaticConstMacro(Dimension)>      MaskImageType;
  typedef typename MaskImageType::Pointer                               MaskImagePointer;
  typedef Vector< VectorDataType, itkGetStaticConstMacro(Dimension) >   VectorPixelType;
  typedef Image< VectorPixelType, itkGetStaticConstMacro(Dimension) >   VectorImageType;
  typedef typename VectorImageType::Pointer                             VectorImagePointer;
  typedef typename VectorImageType::SizeType                            VectorImageSizeType;
  typedef typename VectorImageType::IndexType                           VectorImageIndexType;
  typedef typename VectorImageType::RegionType                          VectorImageRegionType;
  typedef typename VectorImageType::SpacingType                         VectorImageSpacingType;
  typedef typename VectorImageType::PointType                           VectorImagePointType;
  typedef typename VectorImageType::PointType                           VectorImageOriginType;
  typedef typename VectorImageType::DirectionType                       VectorImageDirectionType;
  typedef Image< VectorPixelType, itkGetStaticConstMacro(Dimension)+1>  TimeVaryingVectorImageType;
  typedef typename TimeVaryingVectorImageType::Pointer                  TimeVaryingVectorImagePointer;
  typedef typename TimeVaryingVectorImageType::PixelType                TimeVaryingVectorImagePixelType;
  typedef typename TimeVaryingVectorImageType::SizeType                 TimeVaryingVectorImageSizeType;
  typedef typename TimeVaryingVectorImageType::IndexType                TimeVaryingVectorImageIndexType;
  typedef typename TimeVaryingVectorImageType::SpacingType              TimeVaryingVectorImageSpacingType;
  typedef typename TimeVaryingVectorImageType::PointType                TimeVaryingVectorImagePointType;
  typedef typename TimeVaryingVectorImageType::DirectionType            TimeVaryingVectorImageDirectionType;
  typedef typename TimeVaryingVectorImageType::RegionType               TimeVaryingVectorImageRegionType;

  void SetWhiteMatterPVMap(ImagePointer image) { this->SetInput(0, image); }

  void SetWhitePlusGreyMatterPVMap(ImagePointer image) { this->SetInput(1, image); }

  void SetThicknessPriorMap(ImagePointer image) { this->SetInput(2, image); }

  void SetGWI(MaskImagePointer image) { this->SetInput(3, image); }

  void SetGreyMask(MaskImagePointer image) { this->SetInput(4, image); }
  
  itkSetMacro(MaxIterations, unsigned int);
  itkGetMacro(MaxIterations, unsigned int);

  itkSetMacro(M, unsigned int);
  itkGetMacro(M, unsigned int);

  itkSetMacro(Lambda, double);
  itkGetMacro(Lambda, double);

  itkSetMacro(UpdateSigma, double);
  itkGetMacro(UpdateSigma, double);

  itkSetMacro(DeformationSigma, double);
  itkGetMacro(DeformationSigma, double);

  itkSetMacro(Epsilon, double);
  itkGetMacro(Epsilon, double);

  itkSetMacro(Alpha, double);
  itkGetMacro(Alpha, double);

  itkGetMacro(FieldEnergy, double);

  itkGetMacro(CostFunction, double);

  itkGetMacro(MinJacobian, double);

  itkGetMacro(MaxJacobian, double);

  itkGetMacro(RMSChange, double);

  itkGetMacro(SSD, double);

  itkGetMacro(Cost, double);

  VectorImageType* GetInterfaceDisplacementImage() const { return m_InterfaceDisplacementImage; }
  
protected:

  RegistrationBasedCorticalThicknessFilter();
  ~RegistrationBasedCorticalThicknessFilter() {};
  void PrintSelf(std::ostream& os, Indent indent) const;

  /* The main filter method. Note, single threaded, as we are using a composite filter pattern, so its the contained filters that are threaded. */
  virtual void GenerateData();

private:

  RegistrationBasedCorticalThicknessFilter(const Self&);
  void operator=(const Self&);

  unsigned int       m_MaxIterations;
  unsigned int       m_M;
  double             m_Epsilon;
  double             m_UpdateSigma;
  double             m_DeformationSigma;
  double             m_Lambda;
  double             m_Alpha;
  double             m_FieldEnergy;
  double             m_RMSChange;
  double             m_MinJacobian;
  double             m_MaxJacobian;
  double             m_CostFunction;
  double             m_MaxThickness;
  double             m_MaxDisplacement;
  double             m_SSD;
  double             m_Cost;

  VectorImagePointer m_InterfaceDisplacementImage;
  
}; // end class

} // end namespace

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

#endif