Doxygen/html/itkSyNImageRegistrationMethod_8h_source.html

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

 *

 *  Copyright NumFOCUS

 *

 *  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

 *

 *         https://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 itkSyNImageRegistrationMethod_h

#define itkSyNImageRegistrationMethod_h


#include "itkImageRegistrationMethodv4.h"


#include "itkImageMaskSpatialObject.h"

#include "itkDisplacementFieldTransform.h"


namespace itk

{


template <typename TFixedImage,

          typename TMovingImage,

          typename TOutputTransform = DisplacementFieldTransform<double, TFixedImage::ImageDimension>,

          typename TVirtualImage = TFixedImage,

          typename TPointSet = PointSet<unsigned int, TFixedImage::ImageDimension>>

class ITK_TEMPLATE_EXPORT SyNImageRegistrationMethod

  : public ImageRegistrationMethodv4<TFixedImage, TMovingImage, TOutputTransform, TVirtualImage, TPointSet>

{

public:

  ITK_DISALLOW_COPY_AND_MOVE(SyNImageRegistrationMethod);


  using Self = SyNImageRegistrationMethod;

  using Superclass = ImageRegistrationMethodv4<TFixedImage, TMovingImage, TOutputTransform, TVirtualImage, TPointSet>;

  using Pointer = SmartPointer<Self>;

  using ConstPointer = SmartPointer<const Self>;


  itkNewMacro(Self);


  static constexpr unsigned int ImageDimension = TFixedImage::ImageDimension;


  itkOverrideGetNameOfClassMacro(SyNImageRegistrationMethod);


  using FixedImageType = TFixedImage;

  using FixedImagePointer = typename FixedImageType::Pointer;

  using typename Superclass::FixedImagesContainerType;

  using MovingImageType = TMovingImage;

  using MovingImagePointer = typename MovingImageType::Pointer;

  using typename Superclass::MovingImagesContainerType;


  using typename Superclass::PointSetType;

  using PointSetPointer = typename PointSetType::Pointer;

  using typename Superclass::PointSetsContainerType;


  using typename Superclass::ImageMetricType;

  using ImageMetricPointer = typename ImageMetricType::Pointer;

  using MeasureType = typename ImageMetricType::MeasureType;


  using ImageMaskSpatialObjectType = ImageMaskSpatialObject<ImageDimension>;

  using typename Superclass::FixedImageMaskType;

  using FixedMaskImageType = typename ImageMaskSpatialObjectType::ImageType;

  using typename Superclass::FixedImageMasksContainerType;

  using typename Superclass::MovingImageMaskType;

  using MovingMaskImageType = typename ImageMaskSpatialObjectType::ImageType;

  using typename Superclass::MovingImageMasksContainerType;


  using VirtualImageType = typename Superclass::VirtualImageType;

  using typename Superclass::VirtualImageBaseType;

  using typename Superclass::VirtualImageBaseConstPointer;


  using typename Superclass::MultiMetricType;

  using typename Superclass::MetricType;

  using MetricPointer = typename MetricType::Pointer;

  using typename Superclass::PointSetMetricType;


  using typename Superclass::InitialTransformType;

  using OutputTransformType = TOutputTransform;

  using OutputTransformPointer = typename OutputTransformType::Pointer;

  using RealType = typename OutputTransformType::ScalarType;

  using DerivativeType = typename OutputTransformType::DerivativeType;

  using DerivativeValueType = typename DerivativeType::ValueType;

  using DisplacementFieldType = typename OutputTransformType::DisplacementFieldType;

  using DisplacementFieldPointer = typename DisplacementFieldType::Pointer;

  using DisplacementVectorType = typename DisplacementFieldType::PixelType;


  using typename Superclass::CompositeTransformType;

  using TransformBaseType = typename CompositeTransformType::TransformType;


  using typename Superclass::DecoratedOutputTransformType;

  using DecoratedOutputTransformPointer = typename DecoratedOutputTransformType::Pointer;


  using DisplacementFieldTransformType = DisplacementFieldTransform<RealType, ImageDimension>;

  using DisplacementFieldTransformPointer = typename DisplacementFieldTransformType::Pointer;


  using NumberOfIterationsArrayType = Array<SizeValueType>;


  itkSetMacro(LearningRate, RealType);

  itkGetConstMacro(LearningRate, RealType);

  itkSetMacro(NumberOfIterationsPerLevel, NumberOfIterationsArrayType);

  itkGetConstMacro(NumberOfIterationsPerLevel, NumberOfIterationsArrayType);

  itkSetMacro(ConvergenceThreshold, RealType);

  itkGetConstMacro(ConvergenceThreshold, RealType);

  itkSetMacro(ConvergenceWindowSize, unsigned int);

  itkGetConstMacro(ConvergenceWindowSize, unsigned int);

  itkSetMacro(DownsampleImagesForMetricDerivatives, bool);

  itkGetConstMacro(DownsampleImagesForMetricDerivatives, bool);

  itkSetMacro(AverageMidPointGradients, bool);

  itkGetConstMacro(AverageMidPointGradients, bool);

  itkSetMacro(GaussianSmoothingVarianceForTheUpdateField, RealType);

  itkGetConstReferenceMacro(GaussianSmoothingVarianceForTheUpdateField, RealType);

  itkSetMacro(GaussianSmoothingVarianceForTheTotalField, RealType);

  itkGetConstReferenceMacro(GaussianSmoothingVarianceForTheTotalField, RealType);

  itkGetModifiableObjectMacro(FixedToMiddleTransform, OutputTransformType);

  itkGetModifiableObjectMacro(MovingToMiddleTransform, OutputTransformType);

  itkSetObjectMacro(FixedToMiddleTransform, OutputTransformType);

  itkSetObjectMacro(MovingToMiddleTransform, OutputTransformType);

protected:

  SyNImageRegistrationMethod();

  ~SyNImageRegistrationMethod() override = default;

  void

  PrintSelf(std::ostream & os, Indent indent) const override;


  void

  GenerateData() override;


  virtual void

  StartOptimization();


  void

  InitializeRegistrationAtEachLevel(const SizeValueType) override;


  virtual DisplacementFieldPointer

  ComputeUpdateField(const FixedImagesContainerType,

                     const PointSetsContainerType,

                     const TransformBaseType *,

                     const MovingImagesContainerType,

                     const PointSetsContainerType,

                     const TransformBaseType *,

                     const FixedImageMasksContainerType,

                     const MovingImageMasksContainerType,

                     MeasureType &);

  virtual DisplacementFieldPointer

  ComputeMetricGradientField(const FixedImagesContainerType,

                             const PointSetsContainerType,

                             const TransformBaseType *,

                             const MovingImagesContainerType,

                             const PointSetsContainerType,

                             const TransformBaseType *,

                             const FixedImageMasksContainerType,

                             const MovingImageMasksContainerType,

                             MeasureType &);


  virtual DisplacementFieldPointer

  ScaleUpdateField(const DisplacementFieldType *);

  virtual DisplacementFieldPointer

  GaussianSmoothDisplacementField(const DisplacementFieldType *, const RealType);

  virtual DisplacementFieldPointer

  InvertDisplacementField(const DisplacementFieldType *, const DisplacementFieldType * = nullptr);


  RealType m_LearningRate{ 0.25 };


  OutputTransformPointer m_MovingToMiddleTransform{ nullptr };

  OutputTransformPointer m_FixedToMiddleTransform{ nullptr };


  RealType     m_ConvergenceThreshold{ static_cast<RealType>(1.0e-6) };

  unsigned int m_ConvergenceWindowSize{ 10 };


  NumberOfIterationsArrayType m_NumberOfIterationsPerLevel{};

  bool                        m_DownsampleImagesForMetricDerivatives{ true };

  bool                        m_AverageMidPointGradients{ false };


private:

  RealType m_GaussianSmoothingVarianceForTheUpdateField{ 3.0 };

  RealType m_GaussianSmoothingVarianceForTheTotalField{ 0.5 };

};

} // end namespace itk


#ifndef ITK_MANUAL_INSTANTIATION

#  include "itkSyNImageRegistrationMethod.hxx"

#endif


#endif