itkBSplineDeformableTransform.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkBSplineDeformableTransform.h,v $
  Language:  C++
  Date:      $Date: 2005/09/20 23:43:14 $
  Version:   $Revision: 1.28 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/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 notices for more information.

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

#ifndef __itkBSplineDeformableTransform_h
#define __itkBSplineDeformableTransform_h

#include <iostream>
#include "itkTransform.h"
#include "itkImage.h"
#include "itkImageRegion.h"
#include "itkBSplineInterpolationWeightFunction.h"

namespace itk
{

template <
    class TScalarType = double,          // Data type for scalars (float or double)
    unsigned int NDimensions = 3,        // Number of dimensions
    unsigned int VSplineOrder = 3 >      // Spline order
class ITK_EXPORT BSplineDeformableTransform : 
          public Transform< TScalarType, NDimensions, NDimensions >
{
public:
  typedef BSplineDeformableTransform Self;
  typedef Transform< TScalarType, NDimensions, NDimensions > Superclass;
  typedef SmartPointer<Self>        Pointer;
  typedef SmartPointer<const Self>  ConstPointer;
      
  itkNewMacro( Self );

  itkTypeMacro( BSplineDeformableTransform, Transform );

  itkStaticConstMacro(SpaceDimension, unsigned int, NDimensions);

  itkStaticConstMacro(SplineOrder, unsigned int, VSplineOrder);

  typedef typename Superclass::ScalarType ScalarType;

  typedef typename Superclass::ParametersType ParametersType;

  typedef typename Superclass::JacobianType JacobianType;

  typedef Vector<TScalarType,
                 itkGetStaticConstMacro(SpaceDimension)> InputVectorType;
  typedef Vector<TScalarType,
                 itkGetStaticConstMacro(SpaceDimension)> OutputVectorType;

  typedef CovariantVector<TScalarType,
                          itkGetStaticConstMacro(SpaceDimension)> InputCovariantVectorType;
  typedef CovariantVector<TScalarType,
                          itkGetStaticConstMacro(SpaceDimension)> OutputCovariantVectorType;
  
  typedef vnl_vector_fixed<TScalarType,
                           itkGetStaticConstMacro(SpaceDimension)> InputVnlVectorType;
  typedef vnl_vector_fixed<TScalarType,
                           itkGetStaticConstMacro(SpaceDimension)> OutputVnlVectorType;
  
  typedef Point<TScalarType,
                itkGetStaticConstMacro(SpaceDimension)> InputPointType;
  typedef Point<TScalarType,
                itkGetStaticConstMacro(SpaceDimension)> OutputPointType;
  
  void SetParameters(const ParametersType & parameters);
  
  void SetFixedParameters(const ParametersType & parameters);

  void SetParametersByValue(const ParametersType & parameters);

  void SetIdentity();

  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 ImagePointer * GetCoefficientImage()
    { return m_CoefficientImage; }

  virtual void SetCoefficientImage( 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::PointType OriginType;

  virtual void SetGridRegion( const RegionType& region );
  itkGetMacro( GridRegion, RegionType );
  itkGetConstMacro( GridRegion, RegionType );

  virtual void SetGridSpacing( const SpacingType& spacing );
  itkGetMacro( GridSpacing, SpacingType );
  itkGetConstMacro( GridSpacing, SpacingType );

  virtual void SetGridOrigin( const OriginType& origin );
  itkGetMacro( GridOrigin, OriginType );
  itkGetConstMacro( GridOrigin, OriginType );

  typedef Transform<ScalarType,itkGetStaticConstMacro(SpaceDimension),
                    itkGetStaticConstMacro(SpaceDimension)> BulkTransformType;
  typedef typename BulkTransformType::ConstPointer  BulkTransformPointer;

  itkSetConstObjectMacro( BulkTransform, BulkTransformType );
  itkGetConstObjectMacro( BulkTransform, BulkTransformType );

  OutputPointType  TransformPoint(const InputPointType  &point ) const;

  typedef BSplineInterpolationWeightFunction<ScalarType,
                                             itkGetStaticConstMacro(SpaceDimension),
                                             itkGetStaticConstMacro(SplineOrder)> WeightsFunctionType;
  typedef typename WeightsFunctionType::WeightsType WeightsType;
  typedef typename WeightsFunctionType::ContinuousIndexType ContinuousIndexType;

  typedef Array<unsigned long> ParameterIndexArrayType;

  virtual void TransformPoint( const InputPointType & inputPoint,
                       OutputPointType & outputPoint,
                       WeightsType & weights,
                       ParameterIndexArrayType & indices, 
                       bool & inside ) const;

  unsigned long GetNumberOfWeights() const
    { return m_WeightsFunction->GetNumberOfWeights(); }

  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 transfrom. ");
      return OutputCovariantVectorType(); 
    } 
    
  virtual const JacobianType& GetJacobian(const InputPointType  &point ) const;

  virtual unsigned int GetNumberOfParameters(void) const;

  unsigned int GetNumberOfParametersPerDimension(void) const;

  itkGetConstReferenceMacro( ValidRegion, RegionType );

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


  BSplineDeformableTransform();
  virtual ~BSplineDeformableTransform();

  itkSetObjectMacro( WeightsFunction, WeightsFunctionType );
  itkGetObjectMacro( WeightsFunction, WeightsFunctionType );

  void WrapAsImages();

private:
  BSplineDeformableTransform(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

  BulkTransformPointer  m_BulkTransform;

  RegionType    m_GridRegion;
  SpacingType   m_GridSpacing;
  OriginType    m_GridOrigin;
  
  RegionType    m_ValidRegion;

  unsigned long m_Offset;
  bool          m_SplineOrderOdd;
  SizeType      m_SupportSize;
  IndexType     m_ValidRegionLast;
  
  ImagePointer   m_WrappedImage[NDimensions];

  ImagePointer   m_CoefficientImage[NDimensions];

  typedef typename JacobianType::ValueType JacobianPixelType;
  typedef Image<JacobianPixelType,
                itkGetStaticConstMacro(SpaceDimension)> JacobianImageType;
 
  typename JacobianImageType::Pointer m_JacobianImage[NDimensions];

  mutable IndexType m_LastJacobianIndex;

  const ParametersType *  m_InputParametersPointer;

  ParametersType          m_InternalParametersBuffer;

  typename WeightsFunctionType::Pointer  m_WeightsFunction;

  bool InsideValidRegion( const ContinuousIndexType& index ) const;


}; //class BSplineDeformableTransform


}  // namespace itk


#ifndef ITK_MANUAL_INSTANTIATION
#include "itkBSplineDeformableTransform.txx"
#endif

#endif /* __itkBSplineDeformableTransform_h */

---