itkAdvancedBSplineDeformableTransformBase.h

Go to the documentation of this file.

/*======================================================================

This file is part of the elastix software.

Copyright (c) University Medical Center Utrecht. All rights reserved.
See src/CopyrightElastix.txt or http://elastix.isi.uu.nl/legal.php 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 notices for more information.

======================================================================*/
#ifndef __itkAdvancedBSplineDeformableTransformBase_h
#define __itkAdvancedBSplineDeformableTransformBase_h

#include "itkAdvancedTransform.h"
#include "itkImage.h"
#include "itkImageRegion.h"

namespace itk
{

template<
class TScalarType        = double,       // Data type for scalars
unsigned int NDimensions = 3 >
// Number of dimensions
class AdvancedBSplineDeformableTransformBase :
  public AdvancedTransform< TScalarType, NDimensions, NDimensions >
{
public:

  typedef AdvancedBSplineDeformableTransformBase Self;
  typedef AdvancedTransform<
    TScalarType, NDimensions, NDimensions >         Superclass;
  typedef SmartPointer< Self >       Pointer;
  typedef SmartPointer< const Self > ConstPointer;

  itkTypeMacro( AdvancedBSplineDeformableTransformBase, AdvancedTransform );

  itkStaticConstMacro( SpaceDimension, unsigned int, NDimensions );

  typedef typename Superclass::ParametersType         ParametersType;
  typedef typename Superclass::NumberOfParametersType NumberOfParametersType;
  typedef typename Superclass::JacobianType           JacobianType;
  typedef typename Superclass::ScalarType             ScalarType;
  typedef typename Superclass::InputPointType         InputPointType;
  typedef typename Superclass::OutputPointType        OutputPointType;
  typedef typename Superclass::InputVectorType        InputVectorType;
  typedef typename Superclass::OutputVectorType       OutputVectorType;
  typedef typename Superclass::InputVnlVectorType     InputVnlVectorType;
  typedef typename Superclass::OutputVnlVectorType    OutputVnlVectorType;
  typedef typename Superclass::InputCovariantVectorType
    InputCovariantVectorType;
  typedef typename Superclass::OutputCovariantVectorType
    OutputCovariantVectorType;
  typedef typename Superclass::TransformCategoryType TransformCategoryType;

  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;

  void SetParameters( const ParametersType & parameters );

  void SetFixedParameters( const ParametersType & parameters );

  void SetParametersByValue( const ParametersType & parameters );

  void SetIdentity( void );

  virtual const ParametersType & GetParameters( void ) const;

  virtual const ParametersType & GetFixedParameters( void ) const;

  typedef typename ParametersType::ValueType PixelType;
  typedef Image< PixelType,
    itkGetStaticConstMacro( SpaceDimension ) >           ImageType;
  typedef typename ImageType::Pointer ImagePointer;

  virtual const ImagePointer * GetCoefficientImages( void ) const
  { return this->m_CoefficientImages; }

  virtual void SetCoefficientImages( ImagePointer images[] );

  typedef ImageRegion< itkGetStaticConstMacro( SpaceDimension ) > RegionType;

  typedef typename RegionType::IndexType    IndexType;
  typedef typename RegionType::SizeType     SizeType;
  typedef typename ImageType::SpacingType   SpacingType;
  typedef typename ImageType::DirectionType DirectionType;
  typedef typename ImageType::PointType     OriginType;
  typedef IndexType                         GridOffsetType;

  virtual void SetGridRegion( const RegionType & region ) = 0;

  //itkGetMacro( GridRegion, RegionType );
  itkGetConstMacro( GridRegion, RegionType );

  virtual void SetGridSpacing( const SpacingType & spacing );

  //itkGetMacro( GridSpacing, SpacingType );
  itkGetConstMacro( GridSpacing, SpacingType );

  virtual void SetGridDirection( const DirectionType & direction );

  //itkGetMacro( GridDirection, DirectionType );
  itkGetConstMacro( GridDirection, DirectionType );

  virtual void SetGridOrigin( const OriginType & origin );

  //itkGetMacro( GridOrigin, OriginType );
  itkGetConstMacro( GridOrigin, OriginType );

  typedef Array< unsigned long > ParameterIndexArrayType;

  virtual OutputVectorType TransformVector( const InputVectorType & ) const
  {
    itkExceptionMacro( << "Method not applicable for deformable transform." );
    return OutputVectorType();
  }


  virtual OutputVnlVectorType TransformVector( const InputVnlVectorType & ) const
  {
    itkExceptionMacro( << "Method not applicable for deformable transform. " );
    return OutputVnlVectorType();
  }


  virtual OutputCovariantVectorType TransformCovariantVector(
    const InputCovariantVectorType & ) const
  {
    itkExceptionMacro( << "Method not applicable for deformable transform. " );
    return OutputCovariantVectorType();
  }


  virtual NumberOfParametersType GetNumberOfParameters( void ) const;

  virtual NumberOfParametersType GetNumberOfParametersPerDimension( void ) const;

  itkGetConstReferenceMacro( ValidRegion, RegionType );

  virtual bool IsLinear( void ) const { return false; }

  virtual TransformCategoryType GetTransformCategory( void ) const
  {
    return Self::BSpline;
  }


  virtual unsigned int GetNumberOfAffectedWeights( void ) const = 0;

  virtual NumberOfParametersType GetNumberOfNonZeroJacobianIndices( void ) const = 0;

  typedef ContinuousIndex< ScalarType, SpaceDimension > ContinuousIndexType;

protected:

  virtual void PrintSelf( std::ostream & os, Indent indent ) const;

  AdvancedBSplineDeformableTransformBase();
  virtual ~AdvancedBSplineDeformableTransformBase();

  void WrapAsImages( void );

  void TransformPointToContinuousGridIndex(
    const InputPointType & point, ContinuousIndexType & index ) const;

  void UpdatePointIndexConversions( void );

  virtual void ComputeNonZeroJacobianIndices(
    NonZeroJacobianIndicesType & nonZeroJacobianIndices,
    const RegionType & supportRegion ) const = 0;

  virtual bool InsideValidRegion( const ContinuousIndexType & index ) const;

  ImagePointer m_CoefficientImages[ NDimensions ];

  RegionType     m_GridRegion;
  SpacingType    m_GridSpacing;
  DirectionType  m_GridDirection;
  OriginType     m_GridOrigin;
  GridOffsetType m_GridOffsetTable;

  DirectionType                                       m_PointToIndexMatrix;
  SpatialJacobianType                                 m_PointToIndexMatrix2;
  DirectionType                                       m_PointToIndexMatrixTransposed;
  SpatialJacobianType                                 m_PointToIndexMatrixTransposed2;
  FixedArray< ScalarType, NDimensions >               m_PointToIndexMatrixDiagonal;
  FixedArray< ScalarType, NDimensions * NDimensions > m_PointToIndexMatrixDiagonalProducts;
  DirectionType                                       m_IndexToPoint;
  bool                                                m_PointToIndexMatrixIsDiagonal;

  RegionType m_ValidRegion;

  unsigned long       m_Offset;
  SizeType            m_SupportSize;
  ContinuousIndexType m_ValidRegionBegin;
  ContinuousIndexType m_ValidRegionEnd;

  bool m_SplineOrderOdd;

  const ParametersType * m_InputParametersPointer;

  typedef typename JacobianType::ValueType JacobianPixelType;
  typedef Image< JacobianPixelType,
    itkGetStaticConstMacro( SpaceDimension ) >  JacobianImageType;

  typename JacobianImageType::Pointer m_JacobianImage[ NDimensions ];

  mutable IndexType m_LastJacobianIndex;

  ImagePointer m_WrappedImage[ NDimensions ];

  ParametersType m_InternalParametersBuffer;

  void UpdateGridOffsetTable( void );

private:

  AdvancedBSplineDeformableTransformBase( const Self & ); // purposely not implemented
  void operator=( const Self & );                         // purposely not implemented

};

}  // namespace itk

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

#endif /* __itkAdvancedBSplineDeformableTransformBase_h */