elxPreconditionedGradientDescent.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright UMC Utrecht and contributors
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef __elxPreconditionedGradientDescent_h
#define __elxPreconditionedGradientDescent_h
 
#include "elxIncludes.h" // include first to avoid MSVS warning
#include "itkAdaptiveStochasticPreconditionedGradientDescentOptimizer.h"
 
#include "itkImageGridSampler.h"
#include "itkImageRandomCoordinateSampler.h"
#include "elxProgressCommand.h"
#include "itkMersenneTwisterRandomVariateGenerator.h"
 
namespace elastix
{
template <class TElastix>
class PreconditionedGradientDescent :
  public itk::AdaptiveStochasticPreconditionedGradientDescentOptimizer,
  public OptimizerBase<TElastix>
{
public:
 
  typedef PreconditionedGradientDescent                             Self;
  typedef AdaptiveStochasticPreconditionedGradientDescentOptimizer  Superclass1;
  typedef OptimizerBase< TElastix >                                 Superclass2;
  typedef itk::SmartPointer< Self >                                 Pointer;
  typedef itk::SmartPointer< const Self >                           ConstPointer;
 
  itkNewMacro( Self );
 
  itkTypeMacro( PreconditionedGradientDescent,
    AdaptiveStochasticPreconditionedGradientDescentOptimizer );
 
  elxClassNameMacro( "PreconditionedGradientDescent" );
 
  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;
 
  typedef typename Superclass1::PreconditionValueType     PreconditionValueType;
  typedef typename Superclass1::PreconditionType          PreconditionType;
  //typedef typename Superclass1::EigenSystemType           EigenSystemType;
 
  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 MetricErrorResponse( itk::ExceptionObject & err );
 
  virtual void SetCurrentPositionPublic( const ParametersType & param )
  {
    this->Superclass1::SetCurrentPosition( param );
  }
 
  itkSetMacro( AutomaticParameterEstimation, bool );
  itkGetConstMacro( AutomaticParameterEstimation, bool );
 
  itkSetMacro( MaximumNumberOfSamplingAttempts, unsigned long );
 
  itkGetConstReferenceMacro( MaximumNumberOfSamplingAttempts, unsigned long );
 
  virtual void ResumeOptimization( void );
 
protected:
 
  struct SettingsType { double a, A, alpha, fmax, fmin, omega; };
  typedef typename std::vector<SettingsType>          SettingsVectorType;
 
  typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType;
  typedef typename RandomGeneratorType::Pointer                  RandomGeneratorPointer;
  typedef ProgressCommand                                        ProgressCommandType;
  typedef typename ProgressCommand::Pointer                      ProgressCommandPointer;
 
  typedef typename RegistrationType::FixedImageType   FixedImageType;
  typedef typename RegistrationType::MovingImageType  MovingImageType;
  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 itk::ImageGridSampler< FixedImageType >     ImageGridSamplerType;
  typedef typename ImageGridSamplerType::Pointer      ImageGridSamplerPointer;
 
  PreconditionedGradientDescent();
  virtual ~PreconditionedGradientDescent() {};
 
  SettingsVectorType m_SettingsVector;
 
  unsigned int m_NumberOfGradientMeasurements;
  unsigned int m_NumberOfSamplesForExactGradient;
  double m_SigmoidScaleFactor;
 
  RandomGeneratorPointer m_RandomGenerator;
 
  virtual void SetSelfHessian( void );
 
  virtual void PrintSettingsVector( const SettingsVectorType & settings ) const;
 
  virtual void AutomaticParameterEstimation( void );
 
  virtual void SampleGradients( const ParametersType & mu0,
    double & sigma1, double & sigma2 );
 
  virtual void GetScaledDerivativeWithExceptionHandling(
    const ParametersType & parameters, DerivativeType & derivative );
 
  virtual void AddRandomPerturbation(
    const ParametersType & initialParameters,
    ParametersType & perturbedParameters, double sigma );
 
private:
 
  PreconditionedGradientDescent( const Self& ); // purposely not implemented
  void operator=( const Self& );          // purposely not implemented
 
  unsigned long m_MaximumNumberOfSamplingAttempts;
  unsigned long m_CurrentNumberOfSamplingAttempts;
  unsigned long m_PreviousErrorAtIteration;
 
  bool          m_PreconditionMatrixSet;
 
  bool          m_AutomaticParameterEstimation;
  bool          m_AutomaticParameterEstimationDone;
 
}; // end class PreconditionedGradientDescent
 
 
} // end namespace elastix
 
#ifndef ITK_MANUAL_INSTANTIATION
#include "elxPreconditionedGradientDescent.hxx"
#endif
 
#endif // end #ifndef __elxPreconditionedGradientDescent_h