Doxygen/html/itkTimeVaryingBSplineVelocityFieldImageRegistrationMethod_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 itkTimeVaryingBSplineVelocityFieldImageRegistrationMethod_h

#define itkTimeVaryingBSplineVelocityFieldImageRegistrationMethod_h


#include "itkImageRegistrationMethodv4.h"


#include "itkBSplineScatteredDataPointSetToImageFilter.h"

#include "itkImageMaskSpatialObject.h"

#include "itkTimeVaryingBSplineVelocityFieldTransform.h"


namespace itk

{


template <typename TFixedImage,

          typename TMovingImage,

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

          typename TVirtualImage = TFixedImage,

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

class ITK_TEMPLATE_EXPORT TimeVaryingBSplineVelocityFieldImageRegistrationMethod

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

{

public:

  ITK_DISALLOW_COPY_AND_MOVE(TimeVaryingBSplineVelocityFieldImageRegistrationMethod);


  using Self = TimeVaryingBSplineVelocityFieldImageRegistrationMethod;

  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(TimeVaryingBSplineVelocityFieldImageRegistrationMethod);


  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 InputPointSetType = TPointSet;

  using InputPointSetPointer = typename InputPointSetType::Pointer;

  using typename Superclass::PointSetsContainerType;


  using typename Superclass::ImageMetricType;

  using ImageMetricPointer = typename ImageMetricType::Pointer;

  using MeasureType = typename ImageMetricType::MeasureType;

  using MetricDerivativeType = typename ImageMetricType::DerivativeType;


  using VirtualImageType = typename Superclass::VirtualImageType;

  using typename Superclass::VirtualImageBaseType;

  using typename Superclass::VirtualImageBaseConstPointer;


  using typename Superclass::MetricType;

  using typename Superclass::MultiMetricType;

  using MetricPointer = typename MetricType::Pointer;

  using typename Superclass::PointSetMetricType;


  using ImageMaskSpatialObjectType = ImageMaskSpatialObject<ImageDimension>;

  using MaskImageType = typename ImageMaskSpatialObjectType::ImageType;

  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 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 DisplacementFieldPointType = typename DisplacementFieldType::PointType;


  using ContinuousIndexType = ContinuousIndex<typename DisplacementFieldPointType::CoordRepType, ImageDimension>;


  using TimeVaryingVelocityFieldControlPointLatticeType =

    typename OutputTransformType::TimeVaryingVelocityFieldControlPointLatticeType;

  using TimeVaryingVelocityFieldControlPointLatticePointer =

    typename OutputTransformType::TimeVaryingVelocityFieldControlPointLatticePointer;

  using TimeVaryingVelocityFieldType = typename OutputTransformType::TimeVaryingVelocityFieldControlPointLatticeType;

  using TimeVaryingVelocityFieldPointer =

    typename OutputTransformType::TimeVaryingVelocityFieldControlPointLatticePointer;

  using DisplacementVectorType = typename TimeVaryingVelocityFieldControlPointLatticeType::PixelType;


  using typename Superclass::CompositeTransformType;

  using TransformBaseType = typename CompositeTransformType::TransformType;


  using typename Superclass::DecoratedOutputTransformType;

  using DecoratedOutputTransformPointer = typename DecoratedOutputTransformType::Pointer;


  using NumberOfIterationsArrayType = Array<SizeValueType>;


  using DisplacementFieldTransformType = DisplacementFieldTransform<RealType, ImageDimension>;

  using DisplacementFieldTransformPointer = typename DisplacementFieldTransformType::Pointer;


  using VelocityFieldPointSetType = PointSet<DisplacementVectorType, ImageDimension + 1>;

  using VelocityFieldPointSetPointer = typename VelocityFieldPointSetType::Pointer;

  using BSplineFilterType =

    BSplineScatteredDataPointSetToImageFilter<VelocityFieldPointSetType, TimeVaryingVelocityFieldType>;

  using WeightsContainerType = typename BSplineFilterType::WeightsContainerType;

  using WeightsElementType = typename WeightsContainerType::Element;

  using WeightedMaskImageType = Image<WeightsElementType, ImageDimension>;

  using TimeVaryingWeightedMaskImageType = Image<WeightsElementType, ImageDimension + 1>;


  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(NumberOfTimePointSamples, SizeValueType);

  itkGetConstMacro(NumberOfTimePointSamples, SizeValueType);

protected:

  TimeVaryingBSplineVelocityFieldImageRegistrationMethod();

  ~TimeVaryingBSplineVelocityFieldImageRegistrationMethod() override = default;

  void

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


  void

  GenerateData() override;


  virtual void

  StartOptimization();


  void

  GetMetricDerivativePointSetForAllTimePoints(VelocityFieldPointSetType *, WeightsContainerType *);


  void

  AttachMetricGradientPointSetAtSpecificTimePoint(const RealType,

                                                  VelocityFieldPointSetType *,

                                                  WeightsContainerType *,

                                                  const FixedImagesContainerType,

                                                  const PointSetsContainerType,

                                                  const TransformBaseType *,

                                                  const MovingImagesContainerType,

                                                  const PointSetsContainerType,

                                                  const TransformBaseType *,

                                                  const FixedImageMasksContainerType);


private:

  DisplacementFieldTransformPointer m_IdentityDisplacementFieldTransform{};


  RealType m_LearningRate{};


  RealType     m_ConvergenceThreshold{};

  unsigned int m_ConvergenceWindowSize{ 10 };


  NumberOfIterationsArrayType m_NumberOfIterationsPerLevel{};


  SizeValueType m_NumberOfTimePointSamples{ 4 };


  WeightsElementType m_BoundaryWeight{};

};

} // end namespace itk


#ifndef ITK_MANUAL_INSTANTIATION

#  include "itkTimeVaryingBSplineVelocityFieldImageRegistrationMethod.hxx"

#endif


#endif