itkTimeVaryingBSplineVelocityFieldImageRegistrationMethod.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  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 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_ASSIGN(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;

  itkTypeMacro( TimeVaryingBSplineVelocityFieldImageRegistrationMethod, SimpleImageRegistrationMethod );

  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 InputPointSetType = TPointSet;
  using InputPointSetPointer = typename InputPointSetType::Pointer;
  using PointSetsContainerType = typename Superclass::PointSetsContainerType;

  using ImageMetricType = typename Superclass::ImageMetricType;
  using ImageMetricPointer = typename ImageMetricType::Pointer;
  using MeasureType = typename ImageMetricType::MeasureType;
  using MetricDerivativeType = typename ImageMetricType::DerivativeType;

  using VirtualImageType = typename Superclass::VirtualImageType;
  using VirtualImageBaseType = typename Superclass::VirtualImageBaseType;
  using VirtualImageBaseConstPointer = typename Superclass::VirtualImageBaseConstPointer;

  using MetricType = typename Superclass::MetricType;
  using MultiMetricType = typename Superclass::MultiMetricType;
  using MetricPointer = typename MetricType::Pointer;
  using PointSetMetricType = typename Superclass::PointSetMetricType;

  using ImageMaskSpatialObjectType = ImageMaskSpatialObject<ImageDimension>;
  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 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 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 CompositeTransformType = typename Superclass::CompositeTransformType;
  using TransformBaseType = typename CompositeTransformType::TransformType;

  using DecoratedOutputTransformType = 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