itkLocalSimilarityMeasureGradientDescentOptimizer.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 itkLocalSimilarityMeasureGradientDescentOptimizer_h
#define itkLocalSimilarityMeasureGradientDescentOptimizer_h

#include <NifTKConfigure.h>
#include <itkSingleValuedNonLinearOptimizer.h>
#include <itkDeformableTransform.h>
#include <itkSimilarityMeasure.h>

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

  itkTypeMacro( LocalSimilarityMeasureGradientDescentOptimizer, SingleValuedNonLinearOptimizer );

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

  typedef SimilarityMeasure<TFixedImage, TMovingImage>         ImageToImageMetricType;
  typedef const ImageToImageMetricType*                        ImageToImageMetricPointer;
  typedef TFixedImage                                          FixedImageType;
  typedef typename FixedImageType::PixelType                   FixedImagePixelType;
  typedef FixedImageType*                                      FixedImagePointer;
  typedef typename FixedImageType::Pointer                     FixedImageSmartPointer;
  typedef TMovingImage                                         MovingImageType;
  typedef typename MovingImageType::PixelType                  MovingImagePixelType;  
  typedef MovingImageType*                                     MovingImagePointer;
  typedef DeformableTransform<TFixedImage, TScalarType, Dimension, TDeformationScalar>  DeformableTransformType;
  typedef typename DeformableTransformType::Pointer            DeformableTransformPointer;
  typedef double                                               MeasureType;
  typedef InterpolateImageFunction< TFixedImage, TScalarType > RegriddingInterpolatorType;
  typedef typename RegriddingInterpolatorType::Pointer         RegriddingInterpolatorPointer;
  typedef ResampleImageFilter< TFixedImage, TFixedImage >      ResampleFilterType;
  typedef typename ResampleFilterType::Pointer                 ResampleFilterPointer;
  typedef typename DeformableTransformType::JacobianDeterminantFilterType::OutputImageType JacobianImageType; 

  virtual void StartOptimization( void ) override;

  virtual void ResumeOptimization( void );

  virtual void StopOptimization( void );

  itkGetConstReferenceMacro( Maximize, bool );
  itkSetMacro( Maximize, bool );
  itkBooleanMacro( Maximize );

  itkGetConstMacro( Value, double );

  itkGetConstMacro( Stop, bool );

  itkSetMacro( MaximumNumberOfIterations, unsigned long int );
  itkGetMacro( MaximumNumberOfIterations, unsigned long int );
  
  itkGetMacro( CurrentIteration, unsigned long int );
  
  itkSetMacro ( StepSize, double );
  itkGetMacro ( StepSize, double );

  itkSetMacro ( MinimumStepSize, double );
  itkGetMacro ( MinimumStepSize, double );

  itkSetMacro ( IteratingStepSizeReductionFactor, double );
  itkGetMacro ( IteratingStepSizeReductionFactor, double );

  itkSetMacro ( RegriddingStepSizeReductionFactor, double );
  itkGetMacro ( RegriddingStepSizeReductionFactor, double );

  itkSetMacro ( JacobianBelowZeroStepSizeReductionFactor, double );
  itkGetMacro ( JacobianBelowZeroStepSizeReductionFactor, double );

  itkSetMacro ( MinimumDeformationMagnitudeThreshold, double );
  itkGetMacro ( MinimumDeformationMagnitudeThreshold, double );

  itkSetMacro ( MinimumJacobianThreshold, double );
  itkGetMacro ( MinimumJacobianThreshold, double );

  itkSetObjectMacro(RegriddingInterpolator, RegriddingInterpolatorType);
  itkGetConstObjectMacro(RegriddingInterpolator,  RegriddingInterpolatorType );

  itkSetObjectMacro(DeformableTransform, DeformableTransformType);
  itkGetConstObjectMacro(DeformableTransform,  DeformableTransformType );

  itkSetMacro ( MinimumSimilarityChangeThreshold, double );
  itkGetMacro ( MinimumSimilarityChangeThreshold, double );
  
  itkSetMacro ( CheckSimilarityMeasure, bool );
  itkGetMacro ( CheckSimilarityMeasure, bool );

  itkSetMacro ( CheckMinDeformationMagnitudeThreshold, bool );
  itkGetMacro ( CheckMinDeformationMagnitudeThreshold, bool );

  itkSetMacro ( CheckJacobianBelowZero, bool );
  itkGetMacro ( CheckJacobianBelowZero, bool );
  
  itkSetMacro ( WriteNextParameters, bool );
  itkGetMacro ( WriteNextParameters, bool );
  
  itkSetMacro ( NextParametersFileName, std::string );
  itkGetMacro ( NextParametersFileName, std::string );

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

  itkSetMacro ( WriteDeformationField, bool );
  itkGetMacro ( WriteDeformationField, bool );
  
  itkSetMacro ( DeformationFieldFileName, std::string );
  itkGetMacro ( DeformationFieldFileName, std::string );

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

  itkSetMacro ( WriteRegriddedImage, bool );
  itkGetMacro ( WriteRegriddedImage, bool );
  
  itkSetMacro ( RegriddedImageFileName, std::string );
  itkGetMacro ( RegriddedImageFileName, std::string );

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

  itkSetMacro ( RegriddedMovingImagePadValue, MovingImagePixelType );
  itkGetMacro ( RegriddedMovingImagePadValue, MovingImagePixelType );
  
  itkSetMacro(IsAbsRegriddedImage, bool); 
  itkGetMacro(IsAbsRegriddedImage, bool); 
  
  itkSetMacro(IsPropagateRegriddedMovingImage, bool); 
  itkGetMacro(IsPropagateRegriddedMovingImage, bool); 
  
  virtual const JacobianImageType* GetComposedJacobian() const 
  { 
    return this->m_ComposedJacobian; 
  }
  virtual const FixedImageType* GetRegriddedMovingImage() const 
  {
    return this->m_RegriddedMovingImage; 
  }
  virtual const FixedImageType* GetRegriddedFixedImage() const 
  {
    return this->m_RegriddedFixedImage; 
  }
  
protected:
  
  LocalSimilarityMeasureGradientDescentOptimizer(); 
  virtual ~LocalSimilarityMeasureGradientDescentOptimizer() {};
  void PrintSelf(std::ostream& os, Indent indent) const override;

  bool m_Maximize;
  
  double m_Value;

  bool m_Stop;

  unsigned long int m_MaximumNumberOfIterations;
  
  unsigned int m_CurrentIteration;

  unsigned int m_RegriddingNumber;
  
  double m_StepSize;
  
  double m_MinimumStepSize;
  
  double m_IteratingStepSizeReductionFactor;

  double m_RegriddingStepSizeReductionFactor;
  
  double m_JacobianBelowZeroStepSizeReductionFactor;
  
  double m_MinimumDeformationMagnitudeThreshold;
  
  double m_MinimumSimilarityChangeThreshold;
  
  double m_MinimumJacobianThreshold;
  
  bool m_CheckSimilarityMeasure; 
  
  bool m_CheckMinDeformationMagnitudeThreshold;
  
  bool m_CheckJacobianBelowZero;
  
  bool m_IsAbsRegriddedImage; 
  
  virtual void Initialize() {};
  
  virtual double CalculateNextStep(int iterationNumber, double currentSimilarity, const ParametersType& current, ParametersType& next) = 0;

  virtual void CleanUp() {};

  virtual void ReGrid(bool isResetCurrentPosition);
  
  virtual void ComposeJacobian()
  {                               
    typedef MultiplyImageFilter<JacobianImageType> MultiplyImageFilterType; 
    
    this->m_DeformableTransform->ComputeMinJacobian(); 
    typename MultiplyImageFilterType::Pointer multiplyFilter = MultiplyImageFilterType::New(); 
    multiplyFilter->SetInput1(this->m_ComposedJacobian); 
    multiplyFilter->SetInput2(this->m_DeformableTransform->GetJacobianImage()); 
    multiplyFilter->Update(); 
    this->m_ComposedJacobian = multiplyFilter->GetOutput(); 
    this->m_ComposedJacobian->DisconnectPipeline(); 
  }
  
  RegriddingInterpolatorPointer m_RegriddingInterpolator;
  
  ResampleFilterPointer m_RegriddingResampler;

  FixedImageSmartPointer m_RegriddedMovingImage;
  
  FixedImageSmartPointer m_RegriddedFixedImage;
  
  DeformableTransformPointer m_DeformableTransform;

  ParametersType m_NextParameters;
  
  ParametersType m_RegriddedParameters;

  ImageToImageMetricPointer m_ImageToImageMetric;

  FixedImagePointer m_FixedImage;
  
  MovingImagePointer m_MovingImage;
  
  bool m_WriteNextParameters;
  
  std::string m_NextParametersFileName; 
  
  std::string m_NextParametersFileExt;

  bool m_WriteDeformationField;

  std::string m_DeformationFieldFileName;
  
  std::string m_DeformationFieldFileExt;
  
  bool m_WriteRegriddedImage;
  
  std::string m_RegriddedImageFileName;

  std::string m_RegriddedImageFileExt;
  
  MovingImagePixelType m_RegriddedMovingImagePadValue;
  
  typename JacobianImageType::Pointer m_ComposedJacobian; 
  
  bool m_IsPropagateRegriddedMovingImage; 
  
private:

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

};

} // namespace itk.

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

#endif /*ITKLOCALSIMILARITYMEASUREGRADIENTDESCENTOPTIMIZER_H_*/