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 ITK_TEMPLATE_EXPORT PreconditionedGradientDescent
  : public itk::AdaptiveStochasticPreconditionedGradientDescentOptimizer
  , public OptimizerBase<TElastix>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(PreconditionedGradientDescent);
 
  using Self = PreconditionedGradientDescent;
  using Superclass1 = AdaptiveStochasticPreconditionedGradientDescentOptimizer;
  using Superclass2 = OptimizerBase<TElastix>;
  using Pointer = itk::SmartPointer<Self>;
  using ConstPointer = itk::SmartPointer<const Self>;
 
  itkNewMacro(Self);
 
  itkTypeMacro(PreconditionedGradientDescent, AdaptiveStochasticPreconditionedGradientDescentOptimizer);
 
  elxClassNameMacro("PreconditionedGradientDescent");
 
  using Superclass1::CostFunctionType;
  using Superclass1::CostFunctionPointer;
  using Superclass1::StopConditionType;
 
  using typename Superclass2::ElastixType;
  using typename Superclass2::RegistrationType;
  using ITKBaseType = typename Superclass2::ITKBaseType;
 
  using typename Superclass1::ParametersType;
 
  using typename Superclass1::PreconditionValueType;
  using typename Superclass1::PreconditionType;
  // using typename Superclass1::EigenSystemType;
 
  virtual void
  BeforeRegistration();
  virtual void
  BeforeEachResolution();
  virtual void
  AfterEachResolution();
  virtual void
  AfterEachIteration();
  virtual void
  AfterRegistration();
 
  virtual void
  StartOptimization();
 
  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();
 
protected:
  struct SettingsType
  {
    double a, A, alpha, fmax, fmin, omega;
  };
  using SettingsVectorType = typename std::vector<SettingsType>;
 
  using RandomGeneratorType = itk::Statistics::MersenneTwisterRandomVariateGenerator;
  using RandomGeneratorPointer = typename RandomGeneratorType::Pointer;
  using ProgressCommandType = ProgressCommand;
  using ProgressCommandPointer = typename ProgressCommand::Pointer;
 
  using FixedImageType = typename RegistrationType::FixedImageType;
  using MovingImageType = typename RegistrationType::MovingImageType;
  using ImageSamplerBaseType = itk::ImageSamplerBase<FixedImageType>;
  using ImageSamplerBasePointer = typename ImageSamplerBaseType::Pointer;
  using ImageRandomSamplerBaseType = itk::ImageRandomSamplerBase<FixedImageType>;
  using ImageRandomSamplerBasePointer = typename ImageRandomSamplerBaseType::Pointer;
  using ImageRandomCoordinateSamplerType = itk::ImageRandomCoordinateSampler<FixedImageType>;
  using ImageRandomCoordinateSamplerPointer = typename ImageRandomCoordinateSamplerType::Pointer;
  using ImageGridSamplerType = itk::ImageGridSampler<FixedImageType>;
  using ImageGridSamplerPointer = typename ImageGridSamplerType::Pointer;
 
  PreconditionedGradientDescent();
  virtual ~PreconditionedGradientDescent(){};
 
  SettingsVectorType m_SettingsVector;
 
  unsigned int m_NumberOfGradientMeasurements;
  unsigned int m_NumberOfSamplesForExactGradient;
  double       m_SigmoidScaleFactor;
 
  RandomGeneratorPointer m_RandomGenerator;
 
  virtual void
  SetSelfHessian();
 
  virtual void
  PrintSettingsVector(const SettingsVectorType & settings) const;
 
  virtual void
  AutomaticParameterEstimation();
 
  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:
  elxOverrideGetSelfMacro;
 
  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