itkAdvancedBSplineDeformableTransformBase.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 __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::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::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::TransformCategoryEnum TransformCategoryEnum;
 
  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::MovingImageGradientType      MovingImageGradientType;
  typedef typename Superclass::MovingImageGradientValueType MovingImageGradientValueType;
 
  void SetParameters( const ParametersType & parameters ) override;
 
  void SetFixedParameters( const FixedParametersType & parameters ) override;
 
  void SetParametersByValue( const ParametersType & parameters ) override;
 
  void SetIdentity( void );
 
  const ParametersType & GetParameters( void ) const override;
 
  const FixedParametersType & GetFixedParameters( void ) const override;
 
  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;
 
  OutputVectorType TransformVector( const InputVectorType & ) const override
  {
    itkExceptionMacro( << "Method not applicable for deformable transform." );
  }
 
 
  OutputVnlVectorType TransformVector( const InputVnlVectorType & ) const override
  {
    itkExceptionMacro( << "Method not applicable for deformable transform. " );
  }
 
 
  OutputCovariantVectorType TransformCovariantVector(
    const InputCovariantVectorType & ) const override
  {
    itkExceptionMacro( << "Method not applicable for deformable transform. " );
  }
 
 
  NumberOfParametersType GetNumberOfParameters( void ) const override;
 
  virtual NumberOfParametersType GetNumberOfParametersPerDimension( void ) const;
 
  itkGetConstReferenceMacro( ValidRegion, RegionType );
 
  bool IsLinear( void ) const override { return false; }
 
  TransformCategoryEnum GetTransformCategory( void ) const override
  {
    return TransformCategoryEnum::BSpline;
  }
 
 
  virtual unsigned int GetNumberOfAffectedWeights( void ) const = 0;
 
  NumberOfParametersType GetNumberOfNonZeroJacobianIndices( void ) const override = 0;
 
  typedef ContinuousIndex< ScalarType, SpaceDimension > ContinuousIndexType;
 
protected:
 
  void PrintSelf( std::ostream & os, Indent indent ) const override;
 
  AdvancedBSplineDeformableTransformBase();
  ~AdvancedBSplineDeformableTransformBase() override;
 
  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 */