elxAdaptiveStochasticGradientDescent.h

Go to the documentation of this file.

/*======================================================================

  This file is part of the elastix software.

  Copyright (c) University Medical Center Utrecht. All rights reserved.
  See src/CopyrightElastix.txt or http://elastix.isi.uu.nl/legal.php for
  details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE. See the above copyright notices for more information.

======================================================================*/

#ifndef __elxAdaptiveStochasticGradientDescent_h
#define __elxAdaptiveStochasticGradientDescent_h

#include "itkAdaptiveStochasticGradientDescentOptimizer.h"
#include "itkImageGridSampler.h"
#include "itkImageRandomCoordinateSampler.h"
#include "elxIncludes.h"
#include "elxProgressCommand.h"
#include "itkAdvancedTransform.h"
#include "itkMersenneTwisterRandomVariateGenerator.h"

namespace elastix
{
  using namespace itk;


template <class TElastix>
class AdaptiveStochasticGradientDescent :
  public itk::AdaptiveStochasticGradientDescentOptimizer,
  public OptimizerBase<TElastix>
{
public:

  typedef AdaptiveStochasticGradientDescent           Self;
  typedef AdaptiveStochasticGradientDescentOptimizer  Superclass1;
  typedef OptimizerBase<TElastix>                     Superclass2;
  typedef SmartPointer<Self>                          Pointer;
  typedef SmartPointer<const Self>                    ConstPointer;

  itkNewMacro( Self );

  itkTypeMacro( AdaptiveStochasticGradientDescent,
    AdaptiveStochasticGradientDescentOptimizer );

  elxClassNameMacro( "AdaptiveStochasticGradientDescent" );

  typedef Superclass1::CostFunctionType               CostFunctionType;
  typedef Superclass1::CostFunctionPointer            CostFunctionPointer;
  typedef Superclass1::StopConditionType              StopConditionType;

  typedef typename Superclass2::ElastixType           ElastixType;
  typedef typename Superclass2::ElastixPointer        ElastixPointer;
  typedef typename Superclass2::ConfigurationType     ConfigurationType;
  typedef typename Superclass2::ConfigurationPointer  ConfigurationPointer;
  typedef typename Superclass2::RegistrationType      RegistrationType;
  typedef typename Superclass2::RegistrationPointer   RegistrationPointer;
  typedef typename Superclass2::ITKBaseType           ITKBaseType;

  typedef typename Superclass1::ParametersType        ParametersType;

  virtual void BeforeRegistration( void );
  virtual void BeforeEachResolution( void );
  virtual void AfterEachResolution( void );
  virtual void AfterEachIteration( void );
  virtual void AfterRegistration( void );

  virtual void StartOptimization( void );

  virtual void ResumeOptimization( void );

  virtual void MetricErrorResponse( ExceptionObject & err );

  itkSetMacro( AutomaticParameterEstimation, bool );
  itkGetConstMacro( AutomaticParameterEstimation, bool );

  itkSetMacro( MaximumStepLength, double );
  itkGetConstMacro( MaximumStepLength, double );

  itkSetMacro( MaximumNumberOfSamplingAttempts, unsigned long );

  itkGetConstReferenceMacro( MaximumNumberOfSamplingAttempts, unsigned long );

protected:

  typedef typename RegistrationType::FixedImageType   FixedImageType;
  typedef typename RegistrationType::MovingImageType  MovingImageType;
  typedef typename FixedImageType::RegionType         FixedImageRegionType;
  typedef typename FixedImageType::IndexType          FixedImageIndexType;
  typedef typename FixedImageType::PointType          FixedImagePointType;
  typedef typename RegistrationType::ITKBaseType      itkRegistrationType;
  typedef typename itkRegistrationType::TransformType TransformType;
  typedef typename TransformType::JacobianType        JacobianType;
  typedef typename JacobianType::ValueType            JacobianValueType;
  struct SettingsType { double a, A, alpha, fmax, fmin, omega; };
  typedef typename std::vector<SettingsType>          SettingsVectorType;

  typedef itk::ImageSamplerBase<FixedImageType>       ImageSamplerBaseType;
  typedef typename ImageSamplerBaseType::Pointer      ImageSamplerBasePointer;
  typedef itk::ImageRandomSamplerBase<FixedImageType> ImageRandomSamplerBaseType;
  typedef typename
    ImageRandomSamplerBaseType::Pointer               ImageRandomSamplerBasePointer;
  typedef
    itk::ImageRandomCoordinateSampler<FixedImageType> ImageRandomCoordinateSamplerType;
  typedef typename
    ImageRandomCoordinateSamplerType::Pointer         ImageRandomCoordinateSamplerPointer;
  typedef ImageGridSampler< FixedImageType >          ImageGridSamplerType;
  typedef typename ImageGridSamplerType::Pointer      ImageGridSamplerPointer;
  typedef typename
    ImageGridSamplerType::ImageSampleContainerType    ImageSampleContainerType;
  typedef typename ImageSampleContainerType::Pointer  ImageSampleContainerPointer;

  typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType;
  typedef ProgressCommand                             ProgressCommandType;
  typedef typename ProgressCommand::Pointer           ProgressCommandPointer;

  typedef JacobianType                                TransformJacobianType;
  itkStaticConstMacro( FixedImageDimension, unsigned int, FixedImageType::ImageDimension );
  itkStaticConstMacro( MovingImageDimension, unsigned int, MovingImageType::ImageDimension );
  typedef typename TransformType::ScalarType          CoordinateRepresentationType;
  typedef AdvancedTransform<
    CoordinateRepresentationType,
    itkGetStaticConstMacro(FixedImageDimension),
    itkGetStaticConstMacro(MovingImageDimension) >    AdvancedTransformType;
  typedef typename
    AdvancedTransformType::NonZeroJacobianIndicesType NonZeroJacobianIndicesType;

  AdaptiveStochasticGradientDescent();
  virtual ~AdaptiveStochasticGradientDescent() {};

  SettingsVectorType m_SettingsVector;

  unsigned int m_NumberOfGradientMeasurements;
  unsigned int m_NumberOfJacobianMeasurements;
  unsigned int m_NumberOfSamplesForExactGradient;

  typename AdvancedTransformType::Pointer           m_AdvancedTransform;

  typename RandomGeneratorType::Pointer             m_RandomGenerator;

  virtual void CheckForAdvancedTransform( void );

  virtual void PrintSettingsVector( const SettingsVectorType & settings ) const;

  virtual void AutomaticParameterEstimation( void );

  virtual void SampleGradients( const ParametersType & mu0,
    double perturbationSigma, double & gg, double & ee );

  virtual void SampleFixedImageForJacobianTerms(
    ImageSampleContainerPointer & sampleContainer );

  virtual void ComputeJacobianTerms( double & TrC, double & TrCC,
    double & maxJJ, double & maxJCJ );

  virtual void GetScaledDerivativeWithExceptionHandling(
    const ParametersType & parameters, DerivativeType & derivative );

  virtual void AddRandomPerturbation( ParametersType & parameters, double sigma );

private:

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

  bool m_AutomaticParameterEstimation;
  double m_MaximumStepLength;

  unsigned long m_MaximumNumberOfSamplingAttempts;
  unsigned long m_CurrentNumberOfSamplingAttempts;
  unsigned long m_PreviousErrorAtIteration;
  bool          m_AutomaticParameterEstimationDone;

  unsigned long m_MaxBandCovSize;
  unsigned long m_NumberOfBandStructureSamples;

}; // end class AdaptiveStochasticGradientDescent


} // end namespace elastix

#ifndef ITK_MANUAL_INSTANTIATION
#include "elxAdaptiveStochasticGradientDescent.hxx"
#endif

#endif // end #ifndef __elxAdaptiveStochasticGradientDescent_h