itkBSplineBaseTransform.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  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 itkBSplineBaseTransform_h
#define itkBSplineBaseTransform_h
 
#include <iostream>
#include "itkTransform.h"
#include "itkImage.h"
#include "itkBSplineInterpolationWeightFunction.h"
 
namespace itk
{
template <typename TParametersValueType = double, unsigned int VDimension = 3, unsigned int VSplineOrder = 3>
class ITK_TEMPLATE_EXPORT BSplineBaseTransform : public Transform<TParametersValueType, VDimension, VDimension>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(BSplineBaseTransform);
 
  using Self = BSplineBaseTransform;
  using Superclass = Transform<TParametersValueType, VDimension, VDimension>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  itkOverrideGetNameOfClassMacro(BSplineBaseTransform);
 
  static constexpr unsigned int SpaceDimension = VDimension;
 
  static constexpr unsigned int SplineOrder = VSplineOrder;
 
  itkCloneMacro(Self);
 
  using typename Superclass::ScalarType;
 
  using typename Superclass::FixedParametersType;
  using typename Superclass::ParametersType;
 
  using typename Superclass::JacobianType;
  using typename Superclass::JacobianPositionType;
  using typename Superclass::InverseJacobianPositionType;
 
  using typename Superclass::TransformCategoryEnum;
 
  using typename Superclass::NumberOfParametersType;
 
  using InputVectorType = Vector<TParametersValueType, Self::SpaceDimension>;
  using OutputVectorType = Vector<TParametersValueType, Self::SpaceDimension>;
 
  using InputCovariantVectorType = CovariantVector<TParametersValueType, Self::SpaceDimension>;
  using OutputCovariantVectorType = CovariantVector<TParametersValueType, Self::SpaceDimension>;
 
  using InputVnlVectorType = vnl_vector_fixed<TParametersValueType, SpaceDimension>;
  using OutputVnlVectorType = vnl_vector_fixed<TParametersValueType, SpaceDimension>;
 
  using InputPointType = Point<TParametersValueType, Self::SpaceDimension>;
  using OutputPointType = Point<TParametersValueType, Self::SpaceDimension>;
 
  void
  SetParameters(const ParametersType & parameters) override;
 
  void
  SetFixedParameters(const FixedParametersType & parameters) override = 0;
  void
  SetParametersByValue(const ParametersType & parameters) override;
 
  void
  SetIdentity();
 
  const ParametersType &
  GetParameters() const override;
 
  const FixedParametersType &
  GetFixedParameters() const override;
 
  using ParametersValueType = typename ParametersType::ValueType;
  using ImageType = Image<ParametersValueType, Self::SpaceDimension>;
  using ImagePointer = typename ImageType::Pointer;
  using CoefficientImageArray = FixedArray<ImagePointer, VDimension>;
 
  virtual void
  SetCoefficientImages(const CoefficientImageArray & images) = 0;
 
  const CoefficientImageArray
  GetCoefficientImages() const
  {
    return this->m_CoefficientImages;
  }
 
  using typename Superclass::DerivativeType;
 
  void
  UpdateTransformParameters(const DerivativeType & update, TParametersValueType factor = 1.0) override;
 
  using RegionType = ImageRegion<Self::SpaceDimension>;
 
  using IndexType = typename RegionType::IndexType;
  using SizeType = typename RegionType::SizeType;
  using SpacingType = typename ImageType::SpacingType;
  using DirectionType = typename ImageType::DirectionType;
  using OriginType = typename ImageType::PointType;
 
  OutputPointType
  TransformPoint(const InputPointType & point) const override;
 
  using WeightsFunctionType = BSplineInterpolationWeightFunction<ScalarType, Self::SpaceDimension, Self::SplineOrder>;
 
  using WeightsType = typename WeightsFunctionType::WeightsType;
  using ContinuousIndexType = typename WeightsFunctionType::ContinuousIndexType;
 
  static constexpr unsigned int NumberOfWeights{ WeightsFunctionType::NumberOfWeights };
 
  using ParameterIndexArrayType = FixedArray<unsigned long, NumberOfWeights>;
 
  virtual void
  TransformPoint(const InputPointType &    inputPoint,
                 OutputPointType &         outputPoint,
                 WeightsType &             weights,
                 ParameterIndexArrayType & indices,
                 bool &                    inside) const = 0;
 
#if !defined(ITK_LEGACY_REMOVE)
 
  itkLegacyMacro(unsigned long GetNumberOfWeights() const)
  {
    return m_WeightsFunction->GetNumberOfWeights();
  }
#endif
 
  using Superclass::TransformVector;
  OutputVectorType
  TransformVector(const InputVectorType &) const override
  {
    itkExceptionMacro("Method not applicable for deformable transform.");
  }
  OutputVnlVectorType
  TransformVector(const InputVnlVectorType &) const override
  {
    itkExceptionMacro("Method not applicable for deformable transform. ");
  }
 
  using Superclass::TransformCovariantVector;
  OutputCovariantVectorType
  TransformCovariantVector(const InputCovariantVectorType &) const override
  {
    itkExceptionMacro("Method not applicable for deformable transform. ");
  }
  void
  ComputeJacobianFromBSplineWeightsWithRespectToPosition(const InputPointType &,
                                                         WeightsType &,
                                                         ParameterIndexArrayType &) const;
 
  void
  ComputeJacobianWithRespectToParameters(const InputPointType &, JacobianType &) const override = 0;
 
  void
  ComputeJacobianWithRespectToPosition(const InputPointType &, JacobianPositionType &) const override
  {
    itkExceptionMacro("ComputeJacobianWithRespectToPosition not yet implemented "
                      "for "
                      << this->GetNameOfClass());
  }
  using Superclass::ComputeJacobianWithRespectToPosition;
 
  NumberOfParametersType
  GetNumberOfParameters() const override = 0;
 
  virtual NumberOfParametersType
  GetNumberOfParametersPerDimension() const = 0;
 
  TransformCategoryEnum
  GetTransformCategory() const override
  {
    return Self::TransformCategoryEnum::BSpline;
  }
 
  unsigned int
  GetNumberOfAffectedWeights() const;
 
  using PhysicalDimensionsType = typename ImageType::SpacingType;
  using PixelType = typename ImageType::PixelType;
 
  using MeshSizeType = SizeType;
 
  NumberOfParametersType
  GetNumberOfLocalParameters() const override
  {
    return this->GetNumberOfParameters();
  }
 
protected:
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  BSplineBaseTransform() = default;
  ~BSplineBaseTransform() override = default;
 
  itkSetObjectMacro(WeightsFunction, WeightsFunctionType);
  itkGetModifiableObjectMacro(WeightsFunction, WeightsFunctionType);
  void
  WrapAsImages();
 
protected:
  void
  SetFixedParametersFromTransformDomainInformation() const;
 
  virtual void
  SetFixedParametersGridSizeFromTransformDomainInformation() const = 0;
 
  virtual void
  SetFixedParametersGridOriginFromTransformDomainInformation() const = 0;
 
  virtual void
  SetFixedParametersGridSpacingFromTransformDomainInformation() const = 0;
 
  virtual void
  SetFixedParametersGridDirectionFromTransformDomainInformation() const = 0;
 
  virtual void
  SetCoefficientImageInformationFromFixedParameters() = 0;
 
  virtual bool
  InsideValidRegion(ContinuousIndexType &) const = 0;
 
  // NOTE:  There is a natural duality between the
  //       two representations of of the coefficients
  //       whereby the m_InternalParametersBuffer is
  //       needed to fit into the optimization framework
  //       and the m_CoefficientImages is needed for
  //       the Jacobian computations.  This implementation
  //       is an attempt to remove as much redundancy as possible
  //       and share as much information between the two
  //       instances as possible.
  //
  CoefficientImageArray m_CoefficientImages{ Self::ArrayOfImagePointerGeneratorHelper() };
 
  ParametersType m_InternalParametersBuffer{};
 
  typename WeightsFunctionType::Pointer m_WeightsFunction{ WeightsFunctionType::New() };
 
private:
  static CoefficientImageArray
  ArrayOfImagePointerGeneratorHelper();
}; // class BSplineBaseTransform
} // namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkBSplineBaseTransform.hxx"
#endif
 
#endif /* itkBSplineBaseTransform_h */