Doxygen52/html/itkBSplineSyNImageRegistrationMethod_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

 *

 *         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 itkBSplineSyNImageRegistrationMethod_h

#define itkBSplineSyNImageRegistrationMethod_h


#include "itkSyNImageRegistrationMethod.h"


#include "itkBSplineSmoothingOnUpdateDisplacementFieldTransform.h"


namespace itk

{


template <typename TFixedImage,

          typename TMovingImage,

          typename TOutputTransform =

            BSplineSmoothingOnUpdateDisplacementFieldTransform<double, TFixedImage::ImageDimension>,

          typename TVirtualImage = TFixedImage,

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

class ITK_TEMPLATE_EXPORT BSplineSyNImageRegistrationMethod

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

{

public:

  ITK_DISALLOW_COPY_AND_MOVE(BSplineSyNImageRegistrationMethod);


  using Self = BSplineSyNImageRegistrationMethod;

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

  using Pointer = SmartPointer<Self>;

  using ConstPointer = SmartPointer<const Self>;


  itkNewMacro(Self);


  static constexpr unsigned int ImageDimension = TFixedImage::ImageDimension;


  itkTypeMacro(BSplineSyNImageRegistrationMethod, SyNImageRegistrationMethod);


  using FixedImageType = TFixedImage;

  using FixedImagePointer = typename FixedImageType::Pointer;

  using FixedImagesContainerType = typename Superclass::FixedImagesContainerType;

  using MovingImageType = TMovingImage;

  using MovingImagePointer = typename MovingImageType::Pointer;

  using MovingImagesContainerType = typename Superclass::MovingImagesContainerType;


  using PointSetType = typename Superclass::PointSetType;

  using PointSetsContainerType = typename Superclass::PointSetsContainerType;


  using ImageMetricType = typename Superclass::ImageMetricType;

  using ImageMetricPointer = typename ImageMetricType::Pointer;

  using MeasureType = typename ImageMetricType::MeasureType;


  using ImageMaskSpatialObjectType = typename Superclass::ImageMaskSpatialObjectType;

  using MaskImageType = typename ImageMaskSpatialObjectType::ImageType;

  using FixedImageMaskType = typename Superclass::FixedImageMaskType;

  using FixedMaskImageType = typename ImageMaskSpatialObjectType::ImageType;

  using FixedImageMasksContainerType = typename Superclass::FixedImageMasksContainerType;

  using MovingImageMaskType = typename Superclass::MovingImageMaskType;

  using MovingMaskImageType = typename ImageMaskSpatialObjectType::ImageType;

  using MovingImageMasksContainerType = typename Superclass::MovingImageMasksContainerType;


  using VirtualImageType = typename Superclass::VirtualImageType;

  using VirtualImageBaseType = typename Superclass::VirtualImageBaseType;

  using VirtualImageBaseConstPointer = typename Superclass::VirtualImageBaseConstPointer;


  using MultiMetricType = typename Superclass::MultiMetricType;

  using MetricType = typename Superclass::MetricType;

  using MetricPointer = typename MetricType::Pointer;

  using PointSetMetricType = typename Superclass::PointSetMetricType;


  using NumberOfIterationsArrayType = typename Superclass::NumberOfIterationsArrayType;


  using InitialTransformType = 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 BSplineFilterType = DisplacementFieldToBSplineImageFilter<DisplacementFieldType>;

  using ArrayType = typename BSplineFilterType::ArrayType;

  using WeightedMaskImageType = typename BSplineFilterType::RealImageType;

  using BSplinePointSetType = typename BSplineFilterType::InputPointSetType;


  using CompositeTransformType = typename Superclass::CompositeTransformType;

  using DisplacementFieldTransformType = typename Superclass::DisplacementFieldTransformType;

  using DisplacementFieldTransformPointer = typename Superclass::DisplacementFieldTransformPointer;

  using TransformBaseType = typename CompositeTransformType::TransformType;


  using DecoratedOutputTransformType = typename Superclass::DecoratedOutputTransformType;

  using DecoratedOutputTransformPointer = typename DecoratedOutputTransformType::Pointer;


protected:

  BSplineSyNImageRegistrationMethod() = default;

  ~BSplineSyNImageRegistrationMethod() override = default;


  void

  StartOptimization() override;


  void

  InitializeRegistrationAtEachLevel(const SizeValueType) override;


  DisplacementFieldPointer

  ComputeUpdateField(const FixedImagesContainerType,

                     const PointSetsContainerType,

                     const TransformBaseType *,

                     const MovingImagesContainerType,

                     const PointSetsContainerType,

                     const TransformBaseType *,

                     const FixedImageMasksContainerType,

                     const MovingImageMasksContainerType,

                     MeasureType &) override;

  virtual DisplacementFieldPointer

  BSplineSmoothDisplacementField(const DisplacementFieldType *,

                                 const ArrayType &,

                                 const WeightedMaskImageType *,

                                 const BSplinePointSetType *);

};

} // end namespace itk


#ifndef ITK_MANUAL_INSTANTIATION

#  include "itkBSplineSyNImageRegistrationMethod.hxx"

#endif


#endif