itkTransform.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 itkTransform_h
#define itkTransform_h

#include "itkTransformBase.h"
#include "itkVector.h"
#include "itkSymmetricSecondRankTensor.h"
#include "itkDiffusionTensor3D.h"
#include "itkVariableLengthVector.h"
#include "vnl/vnl_vector_fixed.h"
#include "itkMatrix.h"

namespace itk
{
template<typename TParametersValueType,
          unsigned int NInputDimensions = 3,
          unsigned int NOutputDimensions = 3>
class ITK_TEMPLATE_EXPORT Transform : public TransformBaseTemplate<TParametersValueType>
{
public:
  typedef Transform                                   Self;
  typedef TransformBaseTemplate<TParametersValueType> Superclass;
  typedef SmartPointer<Self>                          Pointer;
  typedef SmartPointer<const Self>                    ConstPointer;

  itkTypeMacro(Transform, TransformBaseTemplate);

  itkStaticConstMacro(InputSpaceDimension, unsigned int, NInputDimensions);
  itkStaticConstMacro(OutputSpaceDimension, unsigned int, NOutputDimensions);

  itkCloneMacro(Self);

  unsigned int GetInputSpaceDimension(void) const ITK_OVERRIDE
  {
    return NInputDimensions;
  }

  unsigned int GetOutputSpaceDimension(void) const ITK_OVERRIDE
  {
    return NOutputDimensions;
  }

  typedef  typename Superclass::FixedParametersType      FixedParametersType;
  typedef  typename Superclass::FixedParametersValueType FixedParametersValueType;
  typedef  typename Superclass::ParametersType           ParametersType;
  typedef  typename Superclass::ParametersValueType      ParametersValueType;
  typedef  Array<ParametersValueType>                    DerivativeType;

  typedef  ParametersValueType ScalarType;

  typedef  Array2D<ParametersValueType> JacobianType;

  typedef Vector<TParametersValueType, NInputDimensions>  InputVectorType;
  typedef Vector<TParametersValueType, NOutputDimensions> OutputVectorType;

  typedef VariableLengthVector<TParametersValueType> InputVectorPixelType;
  typedef VariableLengthVector<TParametersValueType> OutputVectorPixelType;

  /* Standard symmetric second rank tenosr type for this class */
  typedef SymmetricSecondRankTensor<TParametersValueType,NInputDimensions>
    InputSymmetricSecondRankTensorType;
  typedef SymmetricSecondRankTensor<TParametersValueType,NOutputDimensions>
    OutputSymmetricSecondRankTensorType;

  /* Standard tensor type for this class */
  typedef DiffusionTensor3D<TParametersValueType> InputDiffusionTensor3DType;
  typedef DiffusionTensor3D<TParametersValueType> OutputDiffusionTensor3DType;

  typedef CovariantVector<TParametersValueType, NInputDimensions>
  InputCovariantVectorType;
  typedef CovariantVector<TParametersValueType, NOutputDimensions>
  OutputCovariantVectorType;

  typedef vnl_vector_fixed<TParametersValueType, NInputDimensions>  InputVnlVectorType;
  typedef vnl_vector_fixed<TParametersValueType, NOutputDimensions> OutputVnlVectorType;

  typedef Point<TParametersValueType, NInputDimensions>  InputPointType;
  typedef Point<TParametersValueType, NOutputDimensions> OutputPointType;

  typedef Transform<TParametersValueType,
                     NOutputDimensions, NInputDimensions> InverseTransformBaseType;

  typedef typename InverseTransformBaseType::Pointer InverseTransformBasePointer;

  typedef Matrix<TParametersValueType,
                 itkGetStaticConstMacro(OutputSpaceDimension),
                 itkGetStaticConstMacro(InputSpaceDimension)>     MatrixType;

  typedef Matrix<double,
                 itkGetStaticConstMacro(OutputSpaceDimension),
                 itkGetStaticConstMacro(OutputSpaceDimension)>
  OutputDirectionMatrix;
  typedef Matrix<double,
                 itkGetStaticConstMacro(InputSpaceDimension),
                 itkGetStaticConstMacro(InputSpaceDimension)>
  InputDirectionMatrix;
  typedef Matrix<double,
                 itkGetStaticConstMacro(OutputSpaceDimension),
                 itkGetStaticConstMacro(InputSpaceDimension)>
  DirectionChangeMatrix;

  typedef typename Superclass::NumberOfParametersType    NumberOfParametersType;

  virtual OutputPointType TransformPoint(const InputPointType  &) const = 0;

  virtual OutputVectorType  TransformVector(const InputVectorType &) const
  {
    itkExceptionMacro( "TransformVector(const InputVectorType &)"
                       "is unimplemented for " << this->GetNameOfClass() );
  }

  virtual OutputVectorType    TransformVector(
    const InputVectorType & vector,
    const InputPointType & point ) const;

  virtual OutputVnlVectorType TransformVector(const InputVnlVectorType &) const
  {
    itkExceptionMacro( "TransformVector( const InputVnlVectorType & ) is "
                       "unimplemented for " << this->GetNameOfClass() );
  }

  virtual OutputVnlVectorType TransformVector(
    const InputVnlVectorType & vector,
    const InputPointType & point ) const;

  virtual OutputVectorPixelType TransformVector(
    const InputVectorPixelType & itkNotUsed(vector) ) const
  {
    itkExceptionMacro( "TransformVector( const InputVectorPixelType & ) is "
                       "unimplemented for " << this->GetNameOfClass() );
  }

  virtual OutputVectorPixelType TransformVector(
    const InputVectorPixelType & vector,
    const InputPointType & point ) const;

  virtual OutputCovariantVectorType TransformCovariantVector(const InputCovariantVectorType &) const
  {
    itkExceptionMacro( "TransformCovariantVector( const InputCovariantVectorType & ) is "
                       "unimplemented for " << this->GetNameOfClass() );
  }

  virtual OutputCovariantVectorType TransformCovariantVector(
    const InputCovariantVectorType & vector,
    const InputPointType & point ) const;


  virtual OutputVectorPixelType TransformCovariantVector(
    const InputVectorPixelType & itkNotUsed(vector) ) const
  {
    itkExceptionMacro( "TransformCovariantVector(const InputVectorPixelType &)"
                       "is unimplemented for " << this->GetNameOfClass() );
  }

  virtual OutputVectorPixelType TransformCovariantVector(
    const InputVectorPixelType & vector,
    const InputPointType & point ) const;

  virtual OutputDiffusionTensor3DType TransformDiffusionTensor3D(
    const InputDiffusionTensor3DType & itkNotUsed(tensor) )
  const
  {
    itkExceptionMacro(
      "TransformDiffusionTensor3D( const InputDiffusionTensor3DType & ) is "
      "unimplemented for " << this->GetNameOfClass() );
  }

  virtual OutputDiffusionTensor3DType TransformDiffusionTensor3D(
    const InputDiffusionTensor3DType & tensor,
    const InputPointType & point ) const;

  virtual OutputVectorPixelType TransformDiffusionTensor3D(
    const InputVectorPixelType & itkNotUsed(tensor) ) const
  {
    itkExceptionMacro(
      "TransformDiffusionTensor( const InputVectorPixelType & ) is "
      "unimplemented for " << this->GetNameOfClass() );
  }

  virtual OutputVectorPixelType TransformDiffusionTensor3D(
    const InputVectorPixelType & tensor,
    const InputPointType & point ) const;

  virtual OutputSymmetricSecondRankTensorType TransformSymmetricSecondRankTensor(
    const InputSymmetricSecondRankTensorType & tensor,
    const InputPointType & point ) const;

  virtual OutputSymmetricSecondRankTensorType TransformSymmetricSecondRankTensor(
    const InputSymmetricSecondRankTensorType & itkNotUsed(tensor) ) const
  {
    itkExceptionMacro(
      "TransformSymmetricSecondRankTensor( const InputSymmetricSecondRankTensorType & ) is "
      "unimplemented for " << this->GetNameOfClass() );
  }

  virtual OutputVectorPixelType TransformSymmetricSecondRankTensor(
    const InputVectorPixelType & itkNotUsed(tensor) ) const
  {
    itkExceptionMacro(
      "TransformSymmetricSecondRankTensor( const InputVectorPixelType & ) is "
      "unimplemented for " << this->GetNameOfClass() );
  }

  virtual OutputVectorPixelType TransformSymmetricSecondRankTensor(
    const InputVectorPixelType & tensor,
    const InputPointType & point ) const;

  virtual void SetParameters(const ParametersType &) ITK_OVERRIDE = 0;

  virtual void SetParametersByValue(const ParametersType & p) ITK_OVERRIDE
  {
    this->SetParameters(p);
  }

  virtual void CopyInParameters(const ParametersValueType * const begin,
                                const ParametersValueType * const end) ITK_OVERRIDE;

  virtual void CopyInFixedParameters(const FixedParametersValueType * const begin,
                                     const FixedParametersValueType * const end) ITK_OVERRIDE;

  virtual const ParametersType & GetParameters(void) const ITK_OVERRIDE
  {
    return m_Parameters;
  }

  virtual void SetFixedParameters(const FixedParametersType &) ITK_OVERRIDE = 0;

  virtual const FixedParametersType & GetFixedParameters(void) const ITK_OVERRIDE
  {
    return m_FixedParameters;
  }

  virtual void UpdateTransformParameters( const DerivativeType & update,
                                          ParametersValueType factor = 1.0 );

  virtual NumberOfParametersType GetNumberOfLocalParameters(void) const
  {
    return this->GetNumberOfParameters();
  }

  virtual NumberOfParametersType GetNumberOfParameters(void) const ITK_OVERRIDE
  {
    return this->m_Parameters.Size();
  }

  virtual NumberOfParametersType GetNumberOfFixedParameters() const
    {
    return this->m_FixedParameters.Size();
    }

  bool GetInverse( Self *itkNotUsed(inverseTransform) ) const
  {
    return false;
  }

  virtual InverseTransformBasePointer GetInverseTransform() const
  {
    return ITK_NULLPTR;
  }

  virtual std::string GetTransformTypeAsString() const ITK_OVERRIDE;

  typedef typename Superclass::TransformCategoryType    TransformCategoryType;

  virtual TransformCategoryType GetTransformCategory() const ITK_OVERRIDE
  {
    return Superclass::UnknownTransformCategory;
  }

  virtual bool IsLinear() const
  {
    return ( this->GetTransformCategory() == Superclass::Linear );
  }


#ifdef ITKV3_COMPATIBILITY

  virtual const JacobianType & GetJacobian(const InputPointType  & x) const
  {
    this->ComputeJacobianWithRespectToParameters(x, m_SharedLocalJacobian);
    return m_SharedLocalJacobian;
  }

#endif

  virtual void ComputeJacobianWithRespectToParameters(const InputPointType  & itkNotUsed(p), JacobianType & itkNotUsed(jacobian) ) const = 0;

  virtual void ComputeJacobianWithRespectToParametersCachedTemporaries(const InputPointType  & p, JacobianType & jacobian, JacobianType & itkNotUsed(jacobianWithRespectToPosition) ) const
  {
    //NOTE: default implementation is not optimized, and just falls back to original methods.
    this->ComputeJacobianWithRespectToParameters(p, jacobian);
  }


  virtual void ComputeJacobianWithRespectToPosition(const InputPointType & itkNotUsed(x), JacobianType & itkNotUsed(jacobian) ) const
  {
    itkExceptionMacro(
      "ComputeJacobianWithRespectToPosition( InputPointType, JacobianType"
      " is unimplemented for " << this->GetNameOfClass() );
  }


  virtual void ComputeInverseJacobianWithRespectToPosition(const InputPointType & x, JacobianType & jacobian ) const;

protected:
  virtual typename LightObject::Pointer InternalClone() const ITK_OVERRIDE;

  Transform();
  Transform(NumberOfParametersType NumberOfParameters);
  virtual ~Transform() ITK_OVERRIDE { }

  mutable ParametersType      m_Parameters;
  mutable FixedParametersType m_FixedParameters;

  OutputDiffusionTensor3DType PreservationOfPrincipalDirectionDiffusionTensor3DReorientation(
    const InputDiffusionTensor3DType, const JacobianType ) const;

#ifdef ITKV3_COMPATIBILITY
  // This is only needed to provide the old interface that returns a reference to the Jacobian.
  // It is NOT thread-safe and should be avoided whenever possible.
  mutable JacobianType m_SharedLocalJacobian;
#endif

  mutable DirectionChangeMatrix m_DirectionChange;


private:
  ITK_DISALLOW_COPY_AND_ASSIGN(Transform);

  template <typename TType>
  static std::string GetTransformTypeAsString(TType *)
  {
    std::string rval("other");

    return rval;
  }

  static std::string GetTransformTypeAsString(float *)
  {
    std::string rval("float");

    return rval;
  }

  static std::string GetTransformTypeAsString(double *)
  {
    std::string rval("double");

    return rval;
  }

};
} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkTransform.hxx"
#endif

#endif