#include <itkBSplineDeformableTransform.h>

Inheritance diagram for itk::BSplineDeformableTransform< TScalarType, NDimensions, VSplineOrder >:

Collaboration diagram for itk::BSplineDeformableTransform< TScalarType, NDimensions, VSplineOrder >:

Public Types
typedef BulkTransformType::ConstPointer	BulkTransformPointer
typedef Transform< ScalarType, itkGetStaticConstMacro(SpaceDimension), itkGetStaticConstMacro(SpaceDimension)>	BulkTransformType
typedef Superclass::CoefficientImageArray	CoefficientImageArray
typedef SmartPointer< const Self >	ConstPointer
typedef Superclass::ContinuousIndexType	ContinuousIndexType
typedef Superclass::DirectionType	DirectionType
typedef Superclass::ImagePointer	ImagePointer
typedef Superclass::ImageType	ImageType
typedef Superclass::IndexType	IndexType
typedef Superclass::InputCovariantVectorType	InputCovariantVectorType
typedef Superclass::InputVectorType	InputVectorType
typedef Superclass::InputVnlVectorType	InputVnlVectorType
typedef Superclass::JacobianType	JacobianType
typedef Superclass::MeshSizeType	MeshSizeType
typedef Superclass::NumberOfParametersType	NumberOfParametersType
typedef Superclass::OriginType	OriginType
typedef Superclass::OutputCovariantVectorType	OutputCovariantVectorType
typedef Superclass::OutputVectorType	OutputVectorType
typedef Superclass::OutputVnlVectorType	OutputVnlVectorType
typedef Superclass::ParameterIndexArrayType	ParameterIndexArrayType
typedef Superclass::ParametersType	ParametersType
typedef Superclass::ParametersValueType	ParametersValueType
typedef Superclass::SpacingType	PhysicalDimensionsType
typedef Superclass::PixelType	PixelType
typedef SmartPointer< Self >	Pointer
typedef Superclass::RegionType	RegionType
typedef Superclass::ScalarType	ScalarType
typedef BSplineDeformableTransform	Self
typedef Superclass::SizeType	SizeType
typedef Superclass::SpacingType	SpacingType
typedef BSplineBaseTransform < TScalarType, NDimensions, VSplineOrder >	Superclass
typedef Superclass::WeightsFunctionType	WeightsFunctionType
typedef Superclass::WeightsType	WeightsType

typedef Point< TScalarType, itkGetStaticConstMacro(SpaceDimension)>	InputPointType
typedef Point< TScalarType, itkGetStaticConstMacro(SpaceDimension)>	OutputPointType
Public Member Functions
virtual void	ComputeJacobianWithRespectToParameters (const InputPointType &, JacobianType &) const
virtual DirectionType	GetGridDirection () const
virtual OriginType	GetGridOrigin () const
virtual RegionType	GetGridRegion () const
virtual SpacingType	GetGridSpacing () const
virtual const char *	GetNameOfClass () const
virtual NumberOfParametersType	GetNumberOfLocalParameters () const
virtual NumberOfParametersType	GetNumberOfParameters () const
NumberOfParametersType	GetNumberOfParametersPerDimension () const
virtual const RegionType &	GetValidRegion ()
	itkCloneMacro (Self)
virtual void	SetCoefficientImages (const CoefficientImageArray &images)
virtual void	SetGridDirection (const DirectionType &)
virtual void	SetGridOrigin (const OriginType &)
virtual void	SetGridRegion (const RegionType &)
virtual void	SetGridSpacing (const SpacingType &)

virtual void	SetFixedParameters (const ParametersType &parameters)

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

virtual void	SetBulkTransform (const BulkTransformType *_arg)
virtual const BulkTransformType *	GetBulkTransform ()
Static Public Attributes
static const unsigned int	SpaceDimension = NDimensions
static const unsigned int	SplineOrder = VSplineOrder
Protected Member Functions
	BSplineDeformableTransform ()
void	PrintSelf (std::ostream &os, Indent indent) const
virtual	~BSplineDeformableTransform ()
Private Member Functions
	BSplineDeformableTransform (const Self &)
virtual bool	InsideValidRegion (ContinuousIndexType &) const
void	operator= (const Self &)
virtual void	SetCoefficientImageInformationFromFixedParameters ()
virtual void	SetFixedParametersGridDirectionFromTransformDomainInformation () const
virtual void	SetFixedParametersGridOriginFromTransformDomainInformation () const
virtual void	SetFixedParametersGridSizeFromTransformDomainInformation () const
virtual void	SetFixedParametersGridSpacingFromTransformDomainInformation () const
void	UpdateValidGridRegion ()
Private Attributes
BulkTransformPointer	m_BulkTransform
const DirectionType &	m_GridDirection
const OriginType &	m_GridOrigin
const RegionType &	m_GridRegion
const SpacingType &	m_GridSpacing
unsigned long	m_Offset
bool	m_SplineOrderOdd
RegionType	m_ValidRegion
IndexType	m_ValidRegionFirst
IndexType	m_ValidRegionLast
static Pointer	New ()
virtual ::itk::LightObject::Pointer	CreateAnother (void) const

Detailed Description

template<class TScalarType = double, unsigned int NDimensions = 3, unsigned int VSplineOrder = 3>
class itk::BSplineDeformableTransform< TScalarType, NDimensions, VSplineOrder >

Deformable transform using a BSpline representation.

This class encapsulates a deformable transform of points from one N-dimensional one space to another N-dimensional space. The deformation field is modeled using B-splines. A deformation is defined on a sparse regular grid of control points $\vec{\lambda}_j$ and is varied by defining a deformation $\vec{g}(\vec{\lambda}_j)$ of each control point. The deformation $D(\vec{x})$ at any point $\vec{x}$ is obtained by using a B-spline interpolation kernel.

The deformation field grid is defined by a user specified GridRegion, GridSpacing and GridOrigin. Each grid/control point has associated with it N deformation coefficients $\vec{\delta}_j$ , representing the N directional components of the deformation. Deformation outside the grid plus support region for the BSpline interpolation is assumed to be zero.

Additionally, the user can specified an addition bulk transform $ B $ such that the transformed point is given by:

$\vec{y} = B(\vec{x}) + D(\vec{x})$

The parameters for this transform is N x N-D grid of spline coefficients. The user specifies the parameters as one flat array: each N-D grid is represented by an array in the same way an N-D image is represented in the buffer; the N arrays are then concatentated together on form a single array.

For efficiency, this transform does not make a copy of the parameters. It only keeps a pointer to the input parameters and assumes that the memory is managed by the caller.

The following illustrates the typical usage of this class:

 * typedef BSplineDeformableTransform<double,2,3> TransformType;
 * TransformType::Pointer transform = TransformType::New();
 *
 * transform->SetGridRegion( region );
 * transform->SetGridSpacing( spacing );
 * transform->SetGridOrigin( origin );
 *
 * // NB: the region must be set first before setting the parameters
 *
 * TransformType::ParametersType parameters(
 *                                       transform->GetNumberOfParameters() );
 *
 * // Fill the parameters with values
 *
 * transform->SetParameters( parameters )
 *
 * outputPoint = transform->TransformPoint( inputPoint );
 *
 *

An alternative way to set the B-spline coefficients is via array of images. The grid region, spacing and origin information is taken directly from the first image. It is assumed that the subsequent images are the same buffered region. The following illustrates the API:

 *
 * TransformType::ImageConstPointer images[2];
 *
 * // Fill the images up with values
 *
 * transform->SetCoefficientImages( images );
 * outputPoint = transform->TransformPoint( inputPoint );
 *
 *

Warning: use either the SetParameters() or SetCoefficientImages() API. Mixing the two modes may results in unexpected results.

The class is templated coordinate representation type (float or double), the space dimension and the spline order.

Wiki Examples:

All Examples

A global registration of two images

Definition at line 109 of file itkBSplineDeformableTransform.h.