vtkITKTransformInverse.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    $RCSfile: vtkITKTransformInverse.h,v $
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or https://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/

 
#ifndef __vtkITKTransformInverse_h
#define __vtkITKTransformInverse_h
 
namespace itk
{
 
  //----------------------------------------------------------------------------
  template <typename TScalar = double, unsigned int NDimensions = 3, unsigned int VSplineOrder = 3>
  class InverseBSplineTransform :
    public BSplineTransform<TScalar, NDimensions, VSplineOrder>
  {
  public:
    typedef InverseBSplineTransform                            Self;
    typedef BSplineTransform<TScalar,NDimensions,VSplineOrder> Superclass;
    typedef SmartPointer<Self>                                 Pointer;
    typedef SmartPointer<const Self>                           ConstPointer;

    itkTypeMacro( InverseBSplineTransform, BSplineTransform );

    itkNewMacro( Self );

    using Superclass::TransformPoint;
    typename Superclass::OutputPointType TransformPoint(
        const typename Superclass::InputPointType&) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseBSplineTransform" );
    }
    typename Superclass::OutputPointType TransformPoint( {…}
    void ComputeJacobianWithRespectToParameters(
        const typename Superclass::InputPointType &,
        typename Superclass::JacobianType &) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseBSplineTransform" );
    }
    void ComputeJacobianWithRespectToParameters( {…}
    // Deprecated in ITKv5. It should be removed when ITK_LEGACY_REMOVE is set to ON.
    void ComputeJacobianWithRespectToPosition(
        const typename Superclass::InputPointType  &,
        typename Superclass::JacobianType &) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseBSplineTransform" );
    }
    void ComputeJacobianWithRespectToPosition( {…}
    void ComputeJacobianWithRespectToPosition(
        const typename Superclass::InputPointType  &,
        typename Superclass::JacobianPositionType &) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseBSplineTransform" );
    }
    void ComputeJacobianWithRespectToPosition( {…}
    // Deprecated in ITKv5. It should be removed when ITK_LEGACY_REMOVE is set to ON.
    void ComputeInverseJacobianWithRespectToPosition(
        const typename Superclass::InputPointType &,
        typename Superclass::JacobianType &) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseBSplineTransform" );
    }
    void ComputeInverseJacobianWithRespectToPosition( {…}
    void ComputeInverseJacobianWithRespectToPosition(
        const typename Superclass::InputPointType &,
        typename Superclass::InverseJacobianPositionType &) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseBSplineTransform" );
    }
    void ComputeInverseJacobianWithRespectToPosition( {…}
    void ComputeJacobianFromBSplineWeightsWithRespectToPosition(
        const typename Superclass::InputPointType &,
        typename Superclass::WeightsType &,
        typename Superclass::ParameterIndexArrayType &) const
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseBSplineTransform" );
    }
    void ComputeJacobianFromBSplineWeightsWithRespectToPosition( {…}
  };
  class InverseBSplineTransform : {…};
 
  //----------------------------------------------------------------------------
  template <typename TScalar = double, unsigned int NDimensions = 3, unsigned int VSplineOrder = 3>
  class InverseBSplineDeformableTransform :
    public BSplineDeformableTransform<TScalar, NDimensions, VSplineOrder>
  {
  public:
    typedef InverseBSplineDeformableTransform                            Self;
    typedef BSplineDeformableTransform<TScalar,NDimensions,VSplineOrder> Superclass;
    typedef SmartPointer<Self>                                 Pointer;
    typedef SmartPointer<const Self>                           ConstPointer;

    itkTypeMacro( InverseBSplineDeformableTransform, BSplineDeformableTransform );

    itkNewMacro( Self );

    using Superclass::TransformPoint;
    typename Superclass::OutputPointType TransformPoint(
        const typename Superclass::InputPointType&) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseBSplineTransform" );
    }
    typename Superclass::OutputPointType TransformPoint( {…}
    void ComputeJacobianWithRespectToParameters(
        const typename Superclass::InputPointType &,
        typename Superclass::JacobianType &) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseBSplineTransform" );
    }
    void ComputeJacobianWithRespectToParameters( {…}
    // Deprecated in ITKv5. It should be removed when ITK_LEGACY_REMOVE is set to ON.
    void ComputeJacobianWithRespectToPosition(
        const typename Superclass::InputPointType  &,
        typename Superclass::JacobianType &) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseBSplineTransform" );
    }
    void ComputeJacobianWithRespectToPosition( {…}
    void ComputeJacobianWithRespectToPosition(
        const typename Superclass::InputPointType  &,
        typename Superclass::JacobianPositionType &) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseBSplineTransform" );
    }
    void ComputeJacobianWithRespectToPosition( {…}
    void ComputeInverseJacobianWithRespectToPosition(
        const typename Superclass::InputPointType  &,
        typename Superclass::JacobianType &) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseBSplineTransform" );
    }
    void ComputeInverseJacobianWithRespectToPosition( {…}
    void ComputeInverseJacobianWithRespectToPosition(
        const typename Superclass::InputPointType  &,
        typename Superclass::InverseJacobianPositionType &) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseBSplineTransform" );
    }
    void ComputeInverseJacobianWithRespectToPosition( {…}
 
  };
  class InverseBSplineDeformableTransform : {…};
 
  //----------------------------------------------------------------------------
  template <class TScalar, unsigned int NDimensions>
  class InverseDisplacementFieldTransform :
    public DisplacementFieldTransform<TScalar, NDimensions>
  {
  public:
    typedef InverseDisplacementFieldTransform            Self;
    typedef DisplacementFieldTransform<TScalar, NDimensions> Superclass;
    typedef SmartPointer<Self>                           Pointer;
    typedef SmartPointer<const Self>                     ConstPointer;

    itkTypeMacro( InverseDisplacementFieldTransform, DisplacementFieldTransform );

    itkNewMacro( Self );

    typename Superclass::OutputPointType TransformPoint(
        const typename Superclass::InputPointType&) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseDisplacementFieldTransform" );
    }
    typename Superclass::OutputPointType TransformPoint( {…}
    void ComputeJacobianWithRespectToParameters(
        const typename Superclass::InputPointType &,
        typename Superclass::JacobianType &) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseDisplacementFieldTransform" );
    }
    void ComputeJacobianWithRespectToParameters( {…}
    void ComputeJacobianWithRespectToParameters(
        const typename Superclass::IndexType &,
        typename Superclass::JacobianType &) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseDisplacementFieldTransform" );
    }
    void ComputeJacobianWithRespectToParameters( {…}
    // Deprecated in ITKv5. It should be removed when ITK_LEGACY_REMOVE is set to ON.
    void ComputeJacobianWithRespectToPosition(
        const typename Superclass::InputPointType  &,
        typename Superclass::JacobianType &) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseDisplacementFieldTransform" );
    }
    void ComputeJacobianWithRespectToPosition( {…}
    void ComputeJacobianWithRespectToPosition(
        const typename Superclass::InputPointType  &,
        typename Superclass::JacobianPositionType &) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseDisplacementFieldTransform" );
    }
    void ComputeJacobianWithRespectToPosition( {…}
    void ComputeJacobianWithRespectToPosition(
        const typename Superclass::IndexType  &,
        typename Superclass::JacobianPositionType &) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseDisplacementFieldTransform" );
    }
    void ComputeJacobianWithRespectToPosition( {…}
    void ComputeInverseJacobianWithRespectToPosition(
        const typename Superclass::InputPointType  &,
        typename Superclass::JacobianType &) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseDisplacementFieldTransform" );
    }
    void ComputeInverseJacobianWithRespectToPosition( {…}
    void ComputeInverseJacobianWithRespectToPosition(
        const typename Superclass::InputPointType  &,
        typename Superclass::InverseJacobianPositionType &) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseDisplacementFieldTransform" );
    }
    void ComputeInverseJacobianWithRespectToPosition( {…}
    void GetInverseJacobianOfForwardFieldWithRespectToPosition(
        const typename Superclass::InputPointType &,
        typename Superclass::JacobianPositionType &,
        bool useSVD = false ) const override
    {
      (void)useSVD; // unused
      itkExceptionMacro( "Only storage methods are implemented for InverseDisplacementFieldTransform" );
    }
    void GetInverseJacobianOfForwardFieldWithRespectToPosition( {…}
    void GetInverseJacobianOfForwardFieldWithRespectToPosition(
        const typename Superclass::IndexType &,
        typename Superclass::JacobianPositionType &,
        bool useSVD = false ) const override
    {
      (void)useSVD; // unused
      itkExceptionMacro( "Only storage methods are implemented for InverseDisplacementFieldTransform" );
    }
    void GetInverseJacobianOfForwardFieldWithRespectToPosition( {…}
  };
  class InverseDisplacementFieldTransform : {…};
 
  //----------------------------------------------------------------------------
  template <class TScalar, unsigned int NDimensions>
  class InverseThinPlateSplineKernelTransform :
    public ThinPlateSplineKernelTransform<TScalar, NDimensions>
  {
  public:
    typedef InverseThinPlateSplineKernelTransform            Self;
    typedef ThinPlateSplineKernelTransform<TScalar, NDimensions> Superclass;
    typedef SmartPointer<Self>                           Pointer;
    typedef SmartPointer<const Self>                     ConstPointer;

    itkTypeMacro( InverseThinPlateSplineKernelTransform, ThinPlateSplineKernelTransform );

    itkNewMacro( Self );

    typename Superclass::OutputPointType TransformPoint(
        const typename Superclass::InputPointType&) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseThinPlateSplineKernelTransform" );
    }
    typename Superclass::OutputPointType TransformPoint( {…}
    void ComputeDeformationContribution(const typename Superclass::InputPointType &,
                                              typename Superclass::OutputPointType &) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseThinPlateSplineKernelTransform" );
    }
    void ComputeDeformationContribution(const typename Superclass::InputPointType &, {…}
    void ComputeJacobianWithRespectToParameters(
        const typename Superclass::InputPointType &,
        typename Superclass::JacobianType &) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseThinPlateSplineKernelTransform" );
    }
    void ComputeJacobianWithRespectToParameters( {…}
    // Deprecated in ITKv5. It should be removed when ITK_LEGACY_REMOVE is set to ON.
    void ComputeJacobianWithRespectToPosition(
        const typename Superclass::InputPointType  &,
        typename Superclass::JacobianType &) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseThinPlateSplineKernelTransform" );
    }
    void ComputeJacobianWithRespectToPosition( {…}
    void ComputeJacobianWithRespectToPosition(
        const typename Superclass::InputPointType  &,
        typename Superclass::JacobianPositionType &) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseThinPlateSplineKernelTransform" );
    }
    void ComputeJacobianWithRespectToPosition( {…}
    // Deprecated in ITKv5. It should be removed when ITK_LEGACY_REMOVE is set to ON.
    void ComputeInverseJacobianWithRespectToPosition(
        const typename Superclass::InputPointType  &,
        typename Superclass::JacobianType &) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseThinPlateSplineKernelTransform" );
    }
    void ComputeInverseJacobianWithRespectToPosition( {…}
    void ComputeInverseJacobianWithRespectToPosition(
        const typename Superclass::InputPointType  &,
        typename Superclass::InverseJacobianPositionType &) const override
    {
      itkExceptionMacro( "Only storage methods are implemented for InverseThinPlateSplineKernelTransform" );
    }
    void ComputeInverseJacobianWithRespectToPosition( {…}
  };
  class InverseThinPlateSplineKernelTransform : {…};
 
} // end of ITK namespace
 
typedef itk::InverseBSplineDeformableTransform< float, VTKDimension, BSPLINE_TRANSFORM_ORDER > InverseBSplineTransformFloatITKv3Type;
typedef itk::InverseBSplineDeformableTransform< double, VTKDimension, BSPLINE_TRANSFORM_ORDER > InverseBSplineTransformDoubleITKv3Type;
typedef itk::InverseBSplineTransform< float, VTKDimension, BSPLINE_TRANSFORM_ORDER > InverseBSplineTransformFloatITKv4Type;
typedef itk::InverseBSplineTransform< double, VTKDimension, BSPLINE_TRANSFORM_ORDER > InverseBSplineTransformDoubleITKv4Type;
 
typedef itk::InverseDisplacementFieldTransform< float, 3 > InverseDisplacementFieldTransformFloatType;
typedef itk::InverseDisplacementFieldTransform< double, 3 > InverseDisplacementFieldTransformDoubleType;
 
typedef itk::InverseThinPlateSplineKernelTransform< float, 3 > InverseThinPlateSplineTransformFloatType;
typedef itk::InverseThinPlateSplineKernelTransform< double, 3 > InverseThinPlateSplineTransformDoubleType;
 
#endif