itkAdvancedCombinationTransform.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright UMC Utrecht and contributors
 *
 *  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 __itkAdvancedCombinationTransform_h
#define __itkAdvancedCombinationTransform_h
 
#include "itkAdvancedTransform.h"
#include "itkMacro.h"
 
namespace itk
{
 
template< typename TScalarType, unsigned int NDimensions = 3 >
class AdvancedCombinationTransform :
  public AdvancedTransform< TScalarType, NDimensions, NDimensions >
{
public:
 
  typedef AdvancedCombinationTransform Self;
  typedef AdvancedTransform< TScalarType,
    NDimensions, NDimensions >                Superclass;
  typedef SmartPointer< Self >       Pointer;
  typedef SmartPointer< const Self > ConstPointer;
 
  itkNewMacro( Self );
 
  itkTypeMacro( AdvancedCombinationTransform, AdvancedTransform );
 
  itkStaticConstMacro( SpaceDimension, unsigned int, NDimensions );
 
  typedef typename Superclass::ScalarType                    ScalarType;
  typedef typename Superclass::ParametersType                ParametersType;
  typedef typename Superclass::FixedParametersType           FixedParametersType;
  typedef typename Superclass::ParametersValueType           ParametersValueType;
  typedef typename Superclass::NumberOfParametersType        NumberOfParametersType;
  typedef typename Superclass::DerivativeType                DerivativeType;
  typedef typename Superclass::JacobianType                  JacobianType;
  typedef typename Superclass::InputVectorType               InputVectorType;
  typedef typename Superclass::OutputVectorType              OutputVectorType;
  typedef typename Superclass::InputCovariantVectorType      InputCovariantVectorType;
  typedef typename Superclass::OutputCovariantVectorType     OutputCovariantVectorType;
  typedef typename Superclass::InputVnlVectorType            InputVnlVectorType;
  typedef typename Superclass::OutputVnlVectorType           OutputVnlVectorType;
  typedef typename Superclass::InputPointType                InputPointType;
  typedef typename Superclass::OutputPointType               OutputPointType;
  typedef typename Superclass::NonZeroJacobianIndicesType    NonZeroJacobianIndicesType;
  typedef typename Superclass::SpatialJacobianType           SpatialJacobianType;
  typedef typename Superclass::JacobianOfSpatialJacobianType JacobianOfSpatialJacobianType;
  typedef typename Superclass::SpatialHessianType            SpatialHessianType;
  typedef typename Superclass::JacobianOfSpatialHessianType  JacobianOfSpatialHessianType;
  typedef typename Superclass::InternalMatrixType            InternalMatrixType;
  typedef typename Superclass::InverseTransformBaseType      InverseTransformBaseType;
  typedef typename Superclass::InverseTransformBasePointer   InverseTransformBasePointer;
  typedef typename Superclass::TransformCategoryEnum         TransformCategoryEnum;
  typedef typename Superclass::MovingImageGradientType       MovingImageGradientType;
  typedef typename Superclass::MovingImageGradientValueType  MovingImageGradientValueType;
 
  typedef typename Superclass::TransformType   TransformType;
  typedef typename TransformType::Pointer      TransformTypePointer;
  typedef typename TransformType::ConstPointer TransformTypeConstPointer;
 
  typedef Superclass                                  InitialTransformType;
  typedef typename InitialTransformType::Pointer      InitialTransformPointer;
  typedef typename InitialTransformType::ConstPointer InitialTransformConstPointer;
  typedef typename InitialTransformType::InverseTransformBaseType
    InitialTransformInverseTransformBaseType;
  typedef typename InitialTransformType::InverseTransformBasePointer
    InitialTransformInverseTransformBasePointer;
 
  typedef Superclass                                  CurrentTransformType;
  typedef typename CurrentTransformType::Pointer      CurrentTransformPointer;
  typedef typename CurrentTransformType::ConstPointer CurrentTransformConstPointer;
  typedef typename CurrentTransformType::InverseTransformBaseType
    CurrentTransformInverseTransformBaseType;
  typedef typename CurrentTransformType::InverseTransformBasePointer
    CurrentTransformInverseTransformBasePointer;
 
  virtual void SetInitialTransform( InitialTransformType * _arg );
 
  itkGetModifiableObjectMacro( InitialTransform, InitialTransformType );
 
  virtual void SetCurrentTransform( CurrentTransformType * _arg );
 
  itkGetModifiableObjectMacro( CurrentTransform, CurrentTransformType );
 
  virtual SizeValueType GetNumberOfTransforms( void ) const;
 
  virtual const TransformTypePointer GetNthTransform( SizeValueType n ) const;
 
  virtual void SetUseComposition( bool _arg );
 
  itkGetConstMacro( UseComposition, bool );
 
  virtual void SetUseAddition( bool _arg );
 
  itkGetConstMacro( UseAddition, bool );
 
  OutputPointType TransformPoint( const InputPointType  & point ) const override;
 
  OutputVectorType TransformVector( const InputVectorType & ) const override
  {
    itkExceptionMacro(
        << "TransformVector(const InputVectorType &) is not implemented "
        << "for AdvancedCombinationTransform" );
  }
 
 
  OutputVnlVectorType TransformVector( const InputVnlVectorType & ) const override
  {
    itkExceptionMacro(
        << "TransformVector(const InputVnlVectorType &) is not implemented "
        << "for AdvancedCombinationTransform" );
  }
 
 
  OutputCovariantVectorType TransformCovariantVector( const InputCovariantVectorType & ) const override
  {
    itkExceptionMacro(
        << "TransformCovariantVector(const InputCovariantVectorType &) is not implemented "
        << "for AdvancedCombinationTransform" );
  }
 
 
  NumberOfParametersType GetNumberOfParameters( void ) const override;
 
  NumberOfParametersType GetNumberOfNonZeroJacobianIndices( void ) const override;
 
  const ParametersType & GetParameters( void ) const override;
 
  const FixedParametersType & GetFixedParameters( void ) const override;
 
  void SetParameters( const ParametersType & param ) override;
 
  void SetParametersByValue( const ParametersType & param ) override;
 
  void SetFixedParameters( const FixedParametersType & fixedParam ) override;
 
  virtual bool GetInverse( Self * inverse ) const;
 
  bool IsLinear( void ) const override;
 
  TransformCategoryEnum GetTransformCategory() const override;
 
  bool GetHasNonZeroSpatialHessian( void ) const override;
 
  virtual bool HasNonZeroJacobianOfSpatialHessian( void ) const;
 
  void GetJacobian(
    const InputPointType & ipp,
    JacobianType & j,
    NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const override;
 
  void EvaluateJacobianWithImageGradientProduct(
    const InputPointType & ipp,
    const MovingImageGradientType & movingImageGradient,
    DerivativeType & imageJacobian,
    NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const override;
 
  void GetSpatialJacobian(
    const InputPointType & ipp,
    SpatialJacobianType & sj ) const override;
 
  void GetSpatialHessian(
    const InputPointType & ipp,
    SpatialHessianType & sh ) const override;
 
  void GetJacobianOfSpatialJacobian(
    const InputPointType & ipp,
    JacobianOfSpatialJacobianType & jsj,
    NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const override;
 
  void GetJacobianOfSpatialJacobian(
    const InputPointType & ipp,
    SpatialJacobianType & sj,
    JacobianOfSpatialJacobianType & jsj,
    NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const override;
 
  void GetJacobianOfSpatialHessian(
    const InputPointType & ipp,
    JacobianOfSpatialHessianType & jsh,
    NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const override;
 
  void GetJacobianOfSpatialHessian(
    const InputPointType & ipp,
    SpatialHessianType & sh,
    JacobianOfSpatialHessianType & jsh,
    NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const override;
 
  typedef OutputPointType (Self::* TransformPointFunctionPointer)( const InputPointType & ) const;
  typedef void (Self::*            GetSparseJacobianFunctionPointer)(
    const InputPointType &,
    JacobianType &,
    NonZeroJacobianIndicesType & ) const;
  typedef void (Self::* EvaluateJacobianWithImageGradientProductFunctionPointer)(
    const InputPointType &,
    const MovingImageGradientType &,
    DerivativeType &,
    NonZeroJacobianIndicesType & ) const;
  typedef void (Self::* GetSpatialJacobianFunctionPointer)(
    const InputPointType &,
    SpatialJacobianType & ) const;
  typedef void (Self::* GetSpatialHessianFunctionPointer)(
    const InputPointType &,
    SpatialHessianType & ) const;
  typedef void (Self::* GetJacobianOfSpatialJacobianFunctionPointer)(
    const InputPointType &,
    JacobianOfSpatialJacobianType &,
    NonZeroJacobianIndicesType & ) const;
  typedef void (Self::* GetJacobianOfSpatialJacobianFunctionPointer2)(
    const InputPointType &,
    SpatialJacobianType &,
    JacobianOfSpatialJacobianType &,
    NonZeroJacobianIndicesType & ) const;
  typedef void (Self::* GetJacobianOfSpatialHessianFunctionPointer)(
    const InputPointType &,
    JacobianOfSpatialHessianType &,
    NonZeroJacobianIndicesType & ) const;
  typedef void (Self::* GetJacobianOfSpatialHessianFunctionPointer2)(
    const InputPointType &,
    SpatialHessianType &,
    JacobianOfSpatialHessianType &,
    NonZeroJacobianIndicesType & ) const;
 
protected:
 
  AdvancedCombinationTransform();
 
  ~AdvancedCombinationTransform() override{}
 
  InitialTransformPointer m_InitialTransform;
  CurrentTransformPointer m_CurrentTransform;
 
  virtual void UpdateCombinationMethod( void );
 
  virtual void NoCurrentTransformSet( void ) const;
 
  TransformPointFunctionPointer m_SelectedTransformPointFunction;
 
  //GetJacobianFunctionPointer m_SelectedGetJacobianFunction;
 
  GetSparseJacobianFunctionPointer                        m_SelectedGetSparseJacobianFunction;
  EvaluateJacobianWithImageGradientProductFunctionPointer m_SelectedEvaluateJacobianWithImageGradientProductFunction;
  GetSpatialJacobianFunctionPointer                       m_SelectedGetSpatialJacobianFunction;
  GetSpatialHessianFunctionPointer                        m_SelectedGetSpatialHessianFunction;
  GetJacobianOfSpatialJacobianFunctionPointer             m_SelectedGetJacobianOfSpatialJacobianFunction;
  GetJacobianOfSpatialJacobianFunctionPointer2            m_SelectedGetJacobianOfSpatialJacobianFunction2;
  GetJacobianOfSpatialHessianFunctionPointer              m_SelectedGetJacobianOfSpatialHessianFunction;
  GetJacobianOfSpatialHessianFunctionPointer2             m_SelectedGetJacobianOfSpatialHessianFunction2;
 
  inline OutputPointType TransformPointUseAddition(
    const InputPointType & point ) const;
 
  inline OutputPointType TransformPointUseComposition(
    const InputPointType & point ) const;
 
  inline OutputPointType TransformPointNoInitialTransform(
    const InputPointType & point ) const;
 
  inline OutputPointType TransformPointNoCurrentTransform(
    const InputPointType & point ) const;
 
  inline void GetJacobianUseAddition(
    const InputPointType &,
    JacobianType &,
    NonZeroJacobianIndicesType & ) const;
 
  inline void GetJacobianUseComposition(
    const InputPointType &,
    JacobianType &,
    NonZeroJacobianIndicesType & ) const;
 
  inline void GetJacobianNoInitialTransform(
    const InputPointType &,
    JacobianType &,
    NonZeroJacobianIndicesType & ) const;
 
  inline void GetJacobianNoCurrentTransform(
    const InputPointType &,
    JacobianType &,
    NonZeroJacobianIndicesType & ) const;
 
  inline void EvaluateJacobianWithImageGradientProductUseAddition(
    const InputPointType &,
    const MovingImageGradientType &,
    DerivativeType &,
    NonZeroJacobianIndicesType & ) const;
 
  inline void EvaluateJacobianWithImageGradientProductUseComposition(
    const InputPointType &,
    const MovingImageGradientType &,
    DerivativeType &,
    NonZeroJacobianIndicesType & ) const;
 
  inline void EvaluateJacobianWithImageGradientProductNoInitialTransform(
    const InputPointType &,
    const MovingImageGradientType &,
    DerivativeType &,
    NonZeroJacobianIndicesType & ) const;
 
  inline void EvaluateJacobianWithImageGradientProductNoCurrentTransform(
    const InputPointType &,
    const MovingImageGradientType &,
    DerivativeType &,
    NonZeroJacobianIndicesType & ) const;
 
  inline void GetSpatialJacobianUseAddition(
    const InputPointType & ipp,
    SpatialJacobianType & sj ) const;
 
  inline void GetSpatialJacobianUseComposition(
    const InputPointType & ipp,
    SpatialJacobianType & sj ) const;
 
  inline void GetSpatialJacobianNoInitialTransform(
    const InputPointType & ipp,
    SpatialJacobianType & sj ) const;
 
  inline void GetSpatialJacobianNoCurrentTransform(
    const InputPointType & ipp,
    SpatialJacobianType & sj ) const;
 
  inline void GetSpatialHessianUseAddition(
    const InputPointType & ipp,
    SpatialHessianType & sh ) const;
 
  inline void GetSpatialHessianUseComposition(
    const InputPointType & ipp,
    SpatialHessianType & sh ) const;
 
  inline void GetSpatialHessianNoInitialTransform(
    const InputPointType & ipp,
    SpatialHessianType & sh ) const;
 
  inline void GetSpatialHessianNoCurrentTransform(
    const InputPointType & ipp,
    SpatialHessianType & sh ) const;
 
  inline void GetJacobianOfSpatialJacobianUseAddition(
    const InputPointType & ipp,
    JacobianOfSpatialJacobianType & jsj,
    NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const;
 
  inline void GetJacobianOfSpatialJacobianUseAddition(
    const InputPointType & ipp,
    SpatialJacobianType & sj,
    JacobianOfSpatialJacobianType & jsj,
    NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const;
 
  inline void GetJacobianOfSpatialJacobianUseComposition(
    const InputPointType & ipp,
    JacobianOfSpatialJacobianType & jsj,
    NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const;
 
  inline void GetJacobianOfSpatialJacobianUseComposition(
    const InputPointType & ipp,
    SpatialJacobianType & sj,
    JacobianOfSpatialJacobianType & jsj,
    NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const;
 
  inline void GetJacobianOfSpatialJacobianNoInitialTransform(
    const InputPointType & ipp,
    JacobianOfSpatialJacobianType & jsj,
    NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const;
 
  inline void GetJacobianOfSpatialJacobianNoInitialTransform(
    const InputPointType & ipp,
    SpatialJacobianType & sj,
    JacobianOfSpatialJacobianType & jsj,
    NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const;
 
  inline void GetJacobianOfSpatialJacobianNoCurrentTransform(
    const InputPointType & ipp,
    JacobianOfSpatialJacobianType & jsj,
    NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const;
 
  inline void GetJacobianOfSpatialJacobianNoCurrentTransform(
    const InputPointType & ipp,
    SpatialJacobianType & sj,
    JacobianOfSpatialJacobianType & jsj,
    NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const;
 
  inline void GetJacobianOfSpatialHessianUseAddition(
    const InputPointType & ipp,
    JacobianOfSpatialHessianType & jsh,
    NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const;
 
  inline void GetJacobianOfSpatialHessianUseAddition(
    const InputPointType & ipp,
    SpatialHessianType & sh,
    JacobianOfSpatialHessianType & jsh,
    NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const;
 
  inline void GetJacobianOfSpatialHessianUseComposition(
    const InputPointType & ipp,
    JacobianOfSpatialHessianType & jsh,
    NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const;
 
  virtual inline void GetJacobianOfSpatialHessianUseComposition(
    const InputPointType & ipp,
    SpatialHessianType & sh,
    JacobianOfSpatialHessianType & jsh,
    NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const;
 
  inline void GetJacobianOfSpatialHessianNoInitialTransform(
    const InputPointType & ipp,
    JacobianOfSpatialHessianType & jsh,
    NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const;
 
  inline void GetJacobianOfSpatialHessianNoInitialTransform(
    const InputPointType & ipp,
    SpatialHessianType & sh,
    JacobianOfSpatialHessianType & jsh,
    NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const;
 
  inline void GetJacobianOfSpatialHessianNoCurrentTransform(
    const InputPointType & ipp,
    JacobianOfSpatialHessianType & jsh,
    NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const;
 
  inline void GetJacobianOfSpatialHessianNoCurrentTransform(
    const InputPointType & ipp,
    SpatialHessianType & sh,
    JacobianOfSpatialHessianType & jsh,
    NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const;
 
  bool m_UseAddition;
  bool m_UseComposition;
 
private:
 
  AdvancedCombinationTransform( const Self & ); // purposely not implemented
  void operator=( const Self & );               // purposely not implemented
 
};
 
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkAdvancedCombinationTransform.hxx"
#endif
 
#endif // end #ifndef __itkAdvancedCombinationTransform_h