itkDisplacementFieldTransform.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 itkDisplacementFieldTransform_h
#define itkDisplacementFieldTransform_h
 
#include "itkTransform.h"
 
#include "itkImage.h"
#include "itkVectorImage.h"
#include "itkMatrixOffsetTransformBase.h"
#include "itkImageVectorOptimizerParametersHelper.h"
#include "itkVectorInterpolateImageFunction.h"
 
namespace itk
{
 
template <typename TParametersValueType, unsigned int VDimension>
class ITK_TEMPLATE_EXPORT DisplacementFieldTransform : public Transform<TParametersValueType, VDimension, VDimension>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(DisplacementFieldTransform);
 
  using Self = DisplacementFieldTransform;
  using Superclass = Transform<TParametersValueType, VDimension, VDimension>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  itkOverrideGetNameOfClassMacro(DisplacementFieldTransform);
 
  itkNewMacro(Self);
 
  using typename Superclass::InverseTransformBasePointer;
 
  using typename Superclass::ScalarType;
 
  using typename Superclass::FixedParametersType;
  using typename Superclass::FixedParametersValueType;
  using typename Superclass::ParametersType;
  using typename Superclass::ParametersValueType;
 
  using typename Superclass::JacobianType;
  using typename Superclass::JacobianPositionType;
  using typename Superclass::InverseJacobianPositionType;
 
  using typename Superclass::TransformCategoryEnum;
 
  using typename Superclass::NumberOfParametersType;
 
  using typename Superclass::InputPointType;
  using typename Superclass::OutputPointType;
 
  using typename Superclass::InputVectorType;
  using typename Superclass::OutputVectorType;
 
  using typename Superclass::InputVectorPixelType;
  using typename Superclass::OutputVectorPixelType;
 
  using typename Superclass::InputCovariantVectorType;
  using typename Superclass::OutputCovariantVectorType;
 
  using typename Superclass::InputVnlVectorType;
  using typename Superclass::OutputVnlVectorType;
 
  using typename Superclass::InputDiffusionTensor3DType;
  using typename Superclass::OutputDiffusionTensor3DType;
 
  using InputTensorEigenVectorType = CovariantVector<ScalarType, InputDiffusionTensor3DType::Dimension>;
  using OutputTensorEigenVectorType = CovariantVector<ScalarType, OutputDiffusionTensor3DType::Dimension>;
 
  using typename Superclass::DerivativeType;
 
  static constexpr unsigned int Dimension = VDimension;
 
  using DisplacementFieldType = Image<OutputVectorType, Dimension>;
  using VectorImageDisplacementFieldType = VectorImage<TParametersValueType, Dimension>;
  using DisplacementFieldPointer = typename DisplacementFieldType::Pointer;
  using DisplacementFieldConstPointer = typename DisplacementFieldType::ConstPointer;
 
  using InterpolatorType = VectorInterpolateImageFunction<DisplacementFieldType, ScalarType>;
 
  using IndexType = typename DisplacementFieldType::IndexType;
  using RegionType = typename DisplacementFieldType::RegionType;
  using SizeType = typename DisplacementFieldType::SizeType;
  using SpacingType = typename DisplacementFieldType::SpacingType;
  using DirectionType = typename DisplacementFieldType::DirectionType;
  using PointType = typename DisplacementFieldType::PointType;
  using PixelType = typename DisplacementFieldType::PixelType;
 
  using OptimizerParametersHelperType =
    ImageVectorOptimizerParametersHelper<ScalarType, OutputVectorType::Dimension, Dimension>;
 
  virtual void
  SetDisplacementField(DisplacementFieldType * field);
  virtual void
       SetDisplacementField(VectorImageDisplacementFieldType * field);
  void SetDisplacementField(std::nullptr_t) = delete;
  itkGetModifiableObjectMacro(DisplacementField, DisplacementFieldType);
  virtual void
  SetInverseDisplacementField(DisplacementFieldType * inverseField);
  itkGetModifiableObjectMacro(InverseDisplacementField, DisplacementFieldType);
  virtual void
  SetInterpolator(InterpolatorType * interpolator);
  itkGetModifiableObjectMacro(Interpolator, InterpolatorType);
  virtual void
  SetInverseInterpolator(InterpolatorType * interpolator);
  itkGetModifiableObjectMacro(InverseInterpolator, InterpolatorType);
  itkGetConstReferenceMacro(DisplacementFieldSetTime, ModifiedTimeType);
 
  OutputPointType
  TransformPoint(const InputPointType & inputPoint) const override;
 
  using Superclass::TransformVector;
  OutputVectorType
  TransformVector(const InputVectorType &) const override
  {
    itkExceptionMacro("TransformVector(Vector) unimplemented, use "
                      "TransformVector(Vector,Point)");
  }
  OutputVectorPixelType
  TransformVector(const InputVectorPixelType &) const override
  {
    itkExceptionMacro("TransformVector(Vector) unimplemented, use "
                      "TransformVector(Vector,Point)");
  }
 
  OutputVnlVectorType
  TransformVector(const InputVnlVectorType &) const override
  {
    itkExceptionMacro("TransformVector(Vector) unimplemented, use "
                      "TransformVector(Vector,Point)");
  }
 
  using Superclass::TransformDiffusionTensor3D;
  OutputDiffusionTensor3DType
  TransformDiffusionTensor(const InputDiffusionTensor3DType &) const
  {
    itkExceptionMacro("TransformDiffusionTensor(Tensor) unimplemented, use "
                      "TransformDiffusionTensor(Tensor,Point)");
  }
  OutputVectorPixelType
  TransformDiffusionTensor(const InputVectorPixelType &) const
  {
    itkExceptionMacro("TransformDiffusionTensor(Tensor) unimplemented, use "
                      "TransformDiffusionTensor(Tensor,Point)");
  }
 
  using Superclass::TransformCovariantVector;
  OutputCovariantVectorType
  TransformCovariantVector(const InputCovariantVectorType &) const override
  {
    itkExceptionMacro("TransformCovariantVector(CovariantVector) "
                      "unimplemented, use TransformCovariantVector(CovariantVector,Point)");
  }
  OutputVectorPixelType
  TransformCovariantVector(const InputVectorPixelType &) const override
  {
    itkExceptionMacro("TransformCovariantVector(CovariantVector) "
                      "unimplemented, use TransformCovariantVector(CovariantVector,Point)");
  }
 
  void
  SetParameters(const ParametersType & params) override
  {
    if (&(this->m_Parameters) != &params)
    {
      if (params.Size() != this->m_Parameters.Size())
      {
        itkExceptionMacro("Input parameters size (" << params.Size() << ") does not match internal size ("
                                                    << this->m_Parameters.Size() << ").");
      }
      // Copy into existing object
      this->m_Parameters = params;
      this->Modified();
    }
  }
  void
  SetFixedParameters(const FixedParametersType &) override;
 
  void
  ComputeJacobianWithRespectToParameters(const InputPointType &, JacobianType & j) const override
  {
    j = this->m_IdentityJacobian;
  }
  virtual void
  ComputeJacobianWithRespectToParameters(const IndexType &, JacobianType & j) const
  {
    j = this->m_IdentityJacobian;
  }
 
  void
  ComputeJacobianWithRespectToPosition(const InputPointType & point, JacobianPositionType & jacobian) const override;
  using Superclass::ComputeJacobianWithRespectToPosition;
 
  void
  ComputeInverseJacobianWithRespectToPosition(const InputPointType &        point,
                                              InverseJacobianPositionType & jacobian) const override;
  using Superclass::ComputeInverseJacobianWithRespectToPosition;
 
  virtual void
  ComputeJacobianWithRespectToPosition(const IndexType & index, JacobianPositionType & jacobian) const;
 
  virtual void
  GetInverseJacobianOfForwardFieldWithRespectToPosition(const InputPointType & point,
                                                        JacobianPositionType & jacobian,
                                                        bool                   useSVD = false) const;
 
  virtual void
  GetInverseJacobianOfForwardFieldWithRespectToPosition(const IndexType &      index,
                                                        JacobianPositionType & jacobian,
                                                        bool                   useSVD = false) const;
 
  void
  UpdateTransformParameters(const DerivativeType & update, ScalarType factor = 1.0) override;
 
  bool
  GetInverse(Self * inverse) const;
 
  InverseTransformBasePointer
  GetInverseTransform() const override;
 
  virtual void
  SetIdentity();
 
  TransformCategoryEnum
  GetTransformCategory() const override
  {
    return Self::TransformCategoryEnum::DisplacementField;
  }
 
  NumberOfParametersType
  GetNumberOfLocalParameters() const override
  {
    return Dimension;
  }
 
  itkSetMacro(CoordinateTolerance, double);
  itkGetConstMacro(CoordinateTolerance, double);
  itkSetMacro(DirectionTolerance, double);
  itkGetConstMacro(DirectionTolerance, double);
protected:
  DisplacementFieldTransform();
  ~DisplacementFieldTransform() override = default;
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  typename DisplacementFieldType::Pointer m_DisplacementField{};
  typename DisplacementFieldType::Pointer m_InverseDisplacementField{};
 
  typename InterpolatorType::Pointer m_Interpolator{};
  typename InterpolatorType::Pointer m_InverseInterpolator{};
 
  ModifiedTimeType m_DisplacementFieldSetTime{ 0 };
 
  JacobianType m_IdentityJacobian{};
 
private:
  virtual void
  ComputeJacobianWithRespectToPositionInternal(const IndexType &      index,
                                               JacobianPositionType & jacobian,
                                               bool                   doInverseJacobian) const;
 
  virtual void
  VerifyFixedParametersInformation();
 
  virtual void
  SetFixedParametersFromDisplacementField() const;
 
  double m_CoordinateTolerance{};
  double m_DirectionTolerance{};
};
 
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkDisplacementFieldTransform.hxx"
#endif
 
#endif // itkDisplacementFieldTransform_h