itkFFDGradientDescentOptimizer.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 itkFFDGradientDescentOptimizer_h
#define itkFFDGradientDescentOptimizer_h

#include <NifTKConfigure.h>
#include <niftkITKWin32ExportHeader.h>
#include "itkLocalSimilarityMeasureGradientDescentOptimizer.h"
#include <itkImageToImageMetricWithConstraint.h>
#include <itkUCLBSplineTransform.h>
#include <itkRegistrationForceFilter.h>
#include <itkBSplineSmoothVectorFieldFilter.h>
#include <itkInterpolateVectorFieldFilter.h>
#include <itkScaleVectorFieldFilter.h>
#include <itkScalarImageToNormalizedGradientVectorImageFilter.h>

namespace itk
{
  
template <class TFixedImage, class TMovingImage, class TScalarType, class TDeformationScalar>
class ITK_EXPORT FFDGradientDescentOptimizer :
    public LocalSimilarityMeasureGradientDescentOptimizer<TFixedImage, TMovingImage, TScalarType, TDeformationScalar>
{
public:
  
  typedef FFDGradientDescentOptimizer                                                     Self;
  typedef LocalSimilarityMeasureGradientDescentOptimizer<TFixedImage, TMovingImage, 
                                                         TScalarType, TDeformationScalar> Superclass;
  typedef SmartPointer<Self>                                                              Pointer;
  typedef SmartPointer<const Self>                                                        ConstPointer;

  itkTypeMacro( FFDGradientDescentOptimizer, LocalSimilarityMeasureGradientDescentOptimizer );

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

  typedef DeformableTransform<TFixedImage, TScalarType, 
                              Dimension, TDeformationScalar>               DeformableTransformType;
  typedef typename DeformableTransformType::Pointer                        DeformableTransformPointer;
  typedef UCLBSplineTransform<TFixedImage, TScalarType, 
                           Dimension, TDeformationScalar>                  UCLBSplineTransformType;
  typedef UCLBSplineTransformType*                                            UCLBSplineTransformPointer;
  
  typedef TScalarType                                                      MeasureType;
  typedef ImageToImageMetricWithConstraint<TFixedImage, TMovingImage>      SimilarityMeasureType;
  typedef typename SimilarityMeasureType::ConstPointer                     SimilarityMeasurePointer;
  typedef typename SimilarityMeasureType::TransformParametersType          ParametersType;
  typedef typename SimilarityMeasureType::DerivativeType                   DerivativeType;

  typedef typename UCLBSplineTransformType::GridImageType                     GridImageType;
  typedef GridImageType*                                                   GridImagePointer;
  
  typedef Vector< TDeformationScalar, itkGetStaticConstMacro(Dimension) >  VectorPixelType;
  typedef Image< VectorPixelType, itkGetStaticConstMacro(Dimension) >      VectorImageType;

  typedef RegistrationForceFilter<TFixedImage, TMovingImage, 
                                               TDeformationScalar>         ForceFilterType;
  typedef typename ForceFilterType::Pointer                                ForceFilterPointer;
  typedef typename ForceFilterType::OutputImageType                        ForceOutputImageType;
  
  typedef BSplineSmoothVectorFieldFilter<TDeformationScalar, Dimension>    SmoothFilterType;
  typedef typename SmoothFilterType::Pointer                               SmoothFilterPointer;
  
  typedef InterpolateVectorFieldFilter<TDeformationScalar, Dimension>      InterpolateFilterType;
  typedef typename InterpolateFilterType::Pointer                          InterpolateFilterPointer;  

  typedef ScaleVectorFieldFilter<TDeformationScalar, Dimension>            ScaleFieldType;
  typedef typename ScaleFieldType::Pointer                                 ScaleFieldPointer;
  typedef ScalarImageToNormalizedGradientVectorImageFilter<TFixedImage, TDeformationScalar> GradientFilterType;
  typedef typename GradientFilterType::Pointer                             GradientFilterPointer;
  
  typedef typename InterpolateFilterType::OutputImageType             OutputImageType;
  typedef typename OutputImageType::PixelType                         OutputImagePixelType;
  typedef typename OutputImageType::Pointer                           OutputImagePointer;
  typedef ImageRegionIterator<OutputImageType>                        OutputImageIteratorType;
  typedef typename OutputImageType::SizeType                          OutputImageSizeType;
  typedef typename OutputImageType::SpacingType                       OutputImageSpacingType;
  
  itkSetObjectMacro( ForceFilter, ForceFilterType );
  itkGetConstObjectMacro( ForceFilter, ForceFilterType );

  itkSetObjectMacro( SmoothFilter, SmoothFilterType );
  itkGetConstObjectMacro( SmoothFilter, SmoothFilterType );
  
  itkSetObjectMacro( InterpolatorFilter, InterpolateFilterType );
  itkGetConstObjectMacro( InterpolatorFilter, InterpolateFilterType );

  itkSetMacro(MinimumGradientVectorMagnitudeThreshold, TScalarType);
  itkGetMacro(MinimumGradientVectorMagnitudeThreshold, TScalarType);
  
  itkSetMacro(ScaleForceVectorsByGradientImage, bool);
  itkGetMacro(ScaleForceVectorsByGradientImage, bool);
  
  itkSetMacro(ScaleByComponents, bool);
  itkGetMacro(ScaleByComponents, bool);
  
  itkSetMacro(SmoothGradientVectorsBeforeInterpolatingToControlPointLevel, bool);
  itkGetMacro(SmoothGradientVectorsBeforeInterpolatingToControlPointLevel, bool);
  
  itkSetMacro(WriteForceImage, bool);
  itkGetMacro(WriteForceImage, bool);
  
  itkSetMacro(ForceImageFileName, std::string);
  itkGetMacro(ForceImageFileName, std::string);

  itkSetMacro(ForceImageFileExt, std::string);
  itkGetMacro(ForceImageFileExt, std::string);

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

  virtual double CalculateNextStep(int iterationNumber, double currentSimilarity, const ParametersType& current, ParametersType& next);

  virtual void GetGradient(int iterationNumber, const ParametersType& current, ParametersType& next);

  virtual bool LineAscent(int iterationNumber, int numberOfGridVoxels, const ParametersType& current, ParametersType& next);
  
  virtual void OptimizeNextStep(int iterationNumber, int numberOfGridVoxels, const ParametersType& current, ParametersType& next) {};
  
  ForceFilterPointer m_ForceFilter;
  
  SmoothFilterPointer m_SmoothFilter;
  
  InterpolateFilterPointer m_InterpolatorFilter;

  ScaleFieldPointer m_ScaleVectorFieldFilter;
  
  GradientFilterPointer m_GradientImageFilter;

  unsigned int m_CalculateNextStepCounter;

private:

  FFDGradientDescentOptimizer(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

  TScalarType m_MinimumGradientVectorMagnitudeThreshold;
  
  bool m_ScaleForceVectorsByGradientImage;
  
  bool m_ScaleByComponents;
  
  bool m_SmoothGradientVectorsBeforeInterpolatingToControlPointLevel;
  
  bool m_WriteForceImage;
  
  std::string m_ForceImageFileName;
  
  std::string m_ForceImageFileExt;

};

} // namespace itk.

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

#endif /*ITKFFDGRADIENTDESCENTOPTIMIZER_H_*/