#include <itkImageToImageMetricv4.h>

Inheritance diagram for itk::ImageToImageMetricv4< TFixedImage, TMovingImage, TVirtualImage >:

Collaboration diagram for itk::ImageToImageMetricv4< TFixedImage, TMovingImage, TVirtualImage >:

Public Types
typedef SmartPointer< const Self >	ConstPointer
typedef Superclass::CoordinateRepresentationType	CoordinateRepresentationType
typedef GradientRecursiveGaussianImageFilter < FixedImageType, FixedImageGradientImageType >	DefaultFixedImageGradientFilter
typedef GradientRecursiveGaussianImageFilter < MovingImageType, MovingImageGradientImageType >	DefaultMovingImageGradientFilter
typedef Superclass::DerivativeType	DerivativeType
typedef DerivativeType::ValueType	DerivativeValueType
typedef Superclass::DimensionType	DimensionType
typedef FixedImageType::ConstPointer	FixedImageConstPointer
typedef FixedImageGradientCalculatorType::Pointer	FixedImageGradientCalculatorPointer
typedef FixedImageGradientFilterType::Pointer	FixedImageGradientFilterPointer
typedef ImageToImageFilter < FixedImageType, FixedImageGradientImageType >	FixedImageGradientFilterType
typedef FixedImageType::IndexType	FixedImageIndexType
typedef FixedImageMaskType::ConstPointer	FixedImageMaskConstPointer
typedef FixedImageMaskType::Pointer	FixedImageMaskPointer
typedef SpatialObject < itkGetStaticConstMacro(FixedImageDimension) >	FixedImageMaskType
typedef FixedImageType::PixelType	FixedImagePixelType
typedef FixedImageType::Pointer	FixedImagePointer
typedef FixedImageType::PointType	FixedImagePointType
typedef TFixedImage	FixedImageType
typedef Superclass::FixedInputPointType	FixedInputPointType
typedef FixedInterpolatorType::Pointer	FixedInterpolatorPointer
typedef InterpolateImageFunction < FixedImageType, CoordinateRepresentationType >	FixedInterpolatorType
typedef Superclass::FixedOutputPointType	FixedOutputPointType
typedef FixedSampledPointSetType::ConstPointer	FixedSampledPointSetConstPointer
typedef FixedSampledPointSetType::Pointer	FixedSampledPointSetPointer
typedef PointSet< typename FixedImageType::PixelType, itkGetStaticConstMacro(FixedImageDimension)>	FixedSampledPointSetType
typedef Superclass::FixedTransformJacobianType	FixedTransformJacobianType
typedef Superclass::FixedTransformParametersType	FixedTransformParametersType
typedef Superclass::FixedTransformPointer	FixedTransformPointer
typedef Superclass::FixedTransformType	FixedTransformType
typedef Superclass::GradientSourceType	GradientSourceType
typedef Superclass::DimensionType	ImageDimensionType
typedef Superclass::InternalComputationValueType	InternalComputationValueType
typedef Superclass::JacobianType	JacobianType
typedef Superclass::MeasureType	MeasureType
typedef CovariantVector < MovingRealType, itkGetStaticConstMacro(MovingImageDimension) >	MovingGradientPixelType
typedef MovingImageType::ConstPointer	MovingImageConstPointer
typedef MovingImageGradientCalculatorType::Pointer	MovingImageGradientCalculatorPointer
typedef MovingImageGradientFilterType::Pointer	MovingImageGradientFilterPointer
typedef ImageToImageFilter < MovingImageType, MovingImageGradientImageType >	MovingImageGradientFilterType
typedef MovingImageGradientImageType::Pointer	MovingImageGradientImagePointer
typedef Image < MovingGradientPixelType, itkGetStaticConstMacro(MovingImageDimension) >	MovingImageGradientImageType
typedef MovingImageType::IndexType	MovingImageIndexType
typedef MovingImageMaskType::ConstPointer	MovingImageMaskConstPointer
typedef MovingImageMaskType::Pointer	MovingImageMaskPointer
typedef SpatialObject < itkGetStaticConstMacro(MovingImageDimension) >	MovingImageMaskType
typedef MovingImageType::PixelType	MovingImagePixelType
typedef MovingImageType::Pointer	MovingImagePointer
typedef MovingImageType::PointType	MovingImagePointType
typedef MovingImageType::RegionType	MovingImageRegionType
typedef TMovingImage	MovingImageType
typedef Superclass::MovingInputPointType	MovingInputPointType
typedef MovingInterpolatorType::Pointer	MovingInterpolatorPointer
typedef InterpolateImageFunction < MovingImageType, CoordinateRepresentationType >	MovingInterpolatorType
typedef Superclass::MovingOutputPointType	MovingOutputPointType
typedef NumericTraits < MovingImagePixelType > ::RealType	MovingRealType
typedef Superclass::MovingTransformJacobianType	MovingTransformJacobianType
typedef Superclass::MovingTransformParametersType	MovingTransformParametersType
typedef Superclass::MovingTransformPointer	MovingTransformPointer
typedef Superclass::MovingTransformType	MovingTransformType
typedef Superclass::NumberOfParametersType	NumberOfParametersType
typedef Superclass::ParametersType	ParametersType
typedef Superclass::ParametersValueType	ParametersValueType
typedef SmartPointer< Self >	Pointer
typedef ImageToImageMetricv4	Self
typedef ObjectToObjectMetric < TFixedImage::ImageDimension, TMovingImage::ImageDimension >	Superclass
typedef VirtualImageType::DirectionType	VirtualDirectionType
typedef CovariantVector < CoordinateRepresentationType, itkGetStaticConstMacro(VirtualImageDimension) >	VirtualImageGradientType
typedef VirtualImageType::PixelType	VirtualImagePixelType
typedef VirtualImageType::Pointer	VirtualImagePointer
typedef TVirtualImage	VirtualImageType
typedef VirtualImageType::IndexType	VirtualIndexType
typedef VirtualImageType::PointType	VirtualOriginType
typedef VirtualImageType::PointType	VirtualPointType
typedef VirtualImageType::SizeType	VirtualRadiusType
typedef VirtualImageType::RegionType	VirtualRegionType
typedef VirtualSampledPointSetType::Pointer	VirtualSampledPointSetPointer
typedef PointSet< typename VirtualImageType::PixelType, itkGetStaticConstMacro(VirtualImageDimension)>	VirtualSampledPointSetType
typedef VirtualRegionType::SizeType	VirtualSizeType
typedef VirtualImageType::SpacingType	VirtualSpacingType

typedef CovariantVector < CoordinateRepresentationType, itkGetStaticConstMacro(FixedImageDimension) >	FixedImageGradientType
typedef CovariantVector < CoordinateRepresentationType, itkGetStaticConstMacro(MovingImageDimension) >	MovingImageGradientType

typedef NumericTraits < FixedImagePixelType > ::RealType	FixedRealType
typedef CovariantVector < FixedRealType, itkGetStaticConstMacro(FixedImageDimension) >	FixedGradientPixelType
typedef Image < FixedGradientPixelType, itkGetStaticConstMacro(FixedImageDimension) >	FixedImageGradientImageType
typedef FixedImageGradientImageType::Pointer	FixedImageGradientImagePointer

typedef ImageFunction < FixedImageType, CovariantVector< double, itkGetStaticConstMacro(FixedImageDimension)> , CoordinateRepresentationType >	FixedImageGradientCalculatorType
typedef ImageFunction < MovingImageType, CovariantVector< double, itkGetStaticConstMacro(MovingImageDimension)> , CoordinateRepresentationType >	MovingImageGradientCalculatorType
Public Member Functions
OffsetValueType	ComputeParameterOffsetFromVirtualDomainIndex (const VirtualIndexType &index, const NumberOfParametersType numberOfLocalParameters) const
void	CreateVirtualDomainImage (VirtualSpacingType &spacing, VirtualOriginType &origin, VirtualDirectionType &direction, VirtualRegionType &region)
virtual void	GetDerivative (DerivativeType &) const
virtual const FixedImageType *	GetFixedImage ()
virtual const FixedImageGradientImageType *	GetFixedImageGradientImage ()
virtual const FixedInterpolatorType *	GetFixedInterpolator ()
virtual const MovingImageType *	GetMovingImage ()
virtual const MovingImageGradientImageType *	GetMovingImageGradientImage ()
virtual const MovingInterpolatorType *	GetMovingInterpolator ()
virtual const char *	GetNameOfClass () const
SizeValueType	GetNumberOfDomainPoints () const
virtual const SizeValueType &	GetNumberOfSkippedFixedSampledPoints ()
virtual ThreadIdType	GetNumberOfThreadsUsed () const
virtual SizeValueType	GetNumberOfValidPoints () const
virtual MeasureType	GetValue () const
virtual void	GetValueAndDerivative (MeasureType &value, DerivativeType &derivative) const
virtual const VirtualImageType *	GetVirtualDomainImage ()
virtual const VirtualSampledPointSetType *	GetVirtualSampledPointSet ()
virtual void	Initialize (void) throw ( itk::ExceptionObject )
virtual void	SetFixedImage (const FixedImageType *_arg)
virtual void	SetFixedInterpolator (FixedInterpolatorType *_arg)
virtual void	SetMovingImage (const MovingImageType *_arg)
virtual void	SetMovingInterpolator (MovingInterpolatorType *_arg)
void	SetVirtualDomainImage (VirtualImageType *virtualImage)

const VirtualSpacingType	GetVirtualDomainSpacing (void) const
const VirtualOriginType	GetVirtualDomainOrigin (void) const
const VirtualDirectionType	GetVirtualDomainDirection (void) const
const VirtualRegionType	GetVirtualDomainRegion (void) const

virtual void	SetMovingImageMask (MovingImageMaskType *_arg)
virtual void	SetMovingImageMask (const MovingImageMaskType *_arg)
virtual const MovingImageMaskType *	GetMovingImageMask ()

virtual void	SetFixedImageMask (FixedImageMaskType *_arg)
virtual void	SetFixedImageMask (const FixedImageMaskType *_arg)
virtual const FixedImageMaskType *	GetFixedImageMask ()

virtual void	SetFixedSampledPointSet (FixedSampledPointSetType *_arg)
virtual void	SetFixedSampledPointSet (const FixedSampledPointSetType *_arg)
virtual const FixedSampledPointSetType *	GetFixedSampledPointSet ()

virtual void	SetUseFixedSampledPointSet (bool _arg)
virtual const bool &	GetUseFixedSampledPointSet ()
virtual void	UseFixedSampledPointSetOn ()
virtual void	UseFixedSampledPointSetOff ()

virtual void	SetFixedImageGradientFilter (FixedImageGradientFilterType *_arg)
virtual FixedImageGradientFilterType *	GetFixedImageGradientFilter ()
virtual void	SetMovingImageGradientFilter (MovingImageGradientFilterType *_arg)
virtual MovingImageGradientFilterType *	GetMovingImageGradientFilter ()

virtual void	SetFixedImageGradientCalculator (FixedImageGradientCalculatorType *_arg)
virtual FixedImageGradientCalculatorType *	GetFixedImageGradientCalculator ()
virtual void	SetMovingImageGradientCalculator (MovingImageGradientCalculatorType *_arg)
virtual MovingImageGradientCalculatorType *	GetMovingImageGradientCalculator ()

virtual void	SetUseFixedImageGradientFilter (bool _arg)
virtual const bool &	GetUseFixedImageGradientFilter ()
virtual void	UseFixedImageGradientFilterOn ()
virtual void	UseFixedImageGradientFilterOff ()

virtual void	SetUseMovingImageGradientFilter (bool _arg)
virtual const bool &	GetUseMovingImageGradientFilter ()
virtual void	UseMovingImageGradientFilterOn ()
virtual void	UseMovingImageGradientFilterOff ()

virtual void	SetMaximumNumberOfThreads (const ThreadIdType threads)
virtual ThreadIdType	GetMaximumNumberOfThreads () const

virtual void	SetUseFloatingPointCorrection (bool _arg)
virtual const bool &	GetUseFloatingPointCorrection ()
virtual void	UseFloatingPointCorrectionOn ()
virtual void	UseFloatingPointCorrectionOff ()

virtual void	SetFloatingPointCorrectionResolution (DerivativeValueType _arg)
virtual DerivativeValueType	GetFloatingPointCorrectionResolution () const
Static Public Attributes
static const DimensionType	FixedImageDimension = Superclass::FixedDimension
static const DimensionType	MovingImageDimension = Superclass::MovingDimension
static const DimensionType	VirtualImageDimension = Superclass::VirtualDimension
Protected Types
typedef LinearInterpolateImageFunction < FixedImageGradientImageType, CoordinateRepresentationType >	FixedImageGradientInterpolatorType
typedef LinearInterpolateImageFunction < MovingImageGradientImageType, CoordinateRepresentationType >	MovingImageGradientInterpolatorType
Protected Member Functions
virtual void	ComputeFixedImageGradientAtIndex (const VirtualIndexType &index, FixedImageGradientType &gradient) const
virtual void	ComputeFixedImageGradientAtPoint (const FixedImagePointType &mappedPoint, FixedImageGradientType &gradient) const
virtual void	ComputeFixedImageGradientFilterImage ()
virtual void	ComputeMovingImageGradientAtIndex (const VirtualIndexType &index, MovingImageGradientType &gradient) const
virtual void	ComputeMovingImageGradientAtPoint (const MovingImagePointType &mappedPoint, MovingImageGradientType &gradient) const
virtual void	ComputeMovingImageGradientFilterImage () const
virtual void	GetValueAndDerivativeExecute () const
	ImageToImageMetricv4 ()
virtual void	InitializeForIteration () const
void	PrintSelf (std::ostream &os, Indent indent) const
bool	TransformAndEvaluateFixedPoint (const VirtualIndexType &index, const VirtualPointType &point, const bool computeImageGradient, FixedImagePointType &mappedFixedPoint, FixedImagePixelType &mappedFixedPixelValue, FixedImageGradientType &mappedFixedImageGradient) const
bool	TransformAndEvaluateMovingPoint (const VirtualIndexType &index, const VirtualPointType &point, const bool computeImageGradient, MovingImagePointType &mappedMovingPoint, MovingImagePixelType &mappedMovingPixelValue, MovingImageGradientType &mappedMovingImageGradient) const
virtual void	VerifyDisplacementFieldSizeAndPhysicalSpace ()
bool	VerifyNumberOfValidPoints (MeasureType &value, DerivativeType &derivative) const
virtual	~ImageToImageMetricv4 ()

virtual void	InitializeDefaultFixedImageGradientFilter (void)
virtual void	InitializeDefaultMovingImageGradientFilter (void)
Protected Attributes
DefaultFixedImageGradientFilter::Pointer	m_DefaultFixedImageGradientFilter
DefaultMovingImageGradientFilter::Pointer	m_DefaultMovingImageGradientFilter
ImageToImageMetricv4GetValueAndDerivativeThreader < ThreadedImageRegionPartitioner < VirtualImageDimension > , Self >::Pointer	m_DenseGetValueAndDerivativeThreader
DerivativeType *	m_DerivativeResult
FixedImageConstPointer	m_FixedImage
FixedImageGradientCalculatorPointer	m_FixedImageGradientCalculator
FixedImageGradientFilterPointer	m_FixedImageGradientFilter
FixedImageGradientImagePointer	m_FixedImageGradientImage
FixedImageGradientInterpolatorType::Pointer	m_FixedImageGradientInterpolator
FixedImageMaskConstPointer	m_FixedImageMask
FixedInterpolatorPointer	m_FixedInterpolator
FixedSampledPointSetConstPointer	m_FixedSampledPointSet
MovingImageConstPointer	m_MovingImage
MovingImageGradientCalculatorPointer	m_MovingImageGradientCalculator
MovingImageGradientFilterPointer	m_MovingImageGradientFilter
MovingImageGradientImagePointer	m_MovingImageGradientImage
MovingImageGradientInterpolatorType::Pointer	m_MovingImageGradientInterpolator
MovingImageMaskConstPointer	m_MovingImageMask
MovingInterpolatorPointer	m_MovingInterpolator
SizeValueType	m_NumberOfValidPoints
ImageToImageMetricv4GetValueAndDerivativeThreader < ThreadedIndexedContainerPartitioner, Self >::Pointer	m_SparseGetValueAndDerivativeThreader
bool	m_UseFixedImageGradientFilter
bool	m_UseFixedSampledPointSet
bool	m_UseMovingImageGradientFilter
bool	m_UserHasProvidedVirtualDomainImage
VirtualImagePointer	m_VirtualDomainImage
VirtualSampledPointSetPointer	m_VirtualSampledPointSet
Private Member Functions
	ImageToImageMetricv4 (const Self &)
void	MapFixedSampledPointSetToVirtual (void)
void	operator= (const Self &)
Private Attributes
DerivativeValueType	m_FloatingPointCorrectionResolution
bool	m_HaveMadeGetValueWarning
SizeValueType	m_NumberOfSkippedFixedSampledPoints
bool	m_UseFloatingPointCorrection
std::vector< VirtualPointType >	m_VirtualImageCornerPoints
Friends
class	ImageToImageMetricv4GetValueAndDerivativeThreader< ThreadedImageRegionPartitioner< VirtualImageDimension >, Self >
class	ImageToImageMetricv4GetValueAndDerivativeThreader< ThreadedIndexedContainerPartitioner, Self >
class	ImageToImageMetricv4GetValueAndDerivativeThreaderBase< ThreadedImageRegionPartitioner< VirtualImageDimension >, Self >
class	ImageToImageMetricv4GetValueAndDerivativeThreaderBase< ThreadedIndexedContainerPartitioner, Self >
typedef PixelTraits < FixedImagePixelType > ::ValueType	FixedImagePixelValueType
typedef PixelTraits < MovingImagePixelType > ::ValueType	MovingImagePixelValueType
	typedef (itk::Concept::IsFloatingPoint< FixedImagePixelValueType >) OnlyDefinedForFloatingPointTypes0
	typedef (itk::Concept::IsFloatingPoint< MovingImagePixelValueType >) OnlyDefinedForFloatingPointTypes1

Detailed Description

template<class TFixedImage, class TMovingImage, class TVirtualImage = TFixedImage>
class itk::ImageToImageMetricv4< TFixedImage, TMovingImage, TVirtualImage >

Computes similarity between regions of two images, using two user-supplied transforms, a 'fixed' transform and a 'moving' transform.

Warning:: Integer-type images are not yet supported. See concept-checking in class declaration for details.

Note:: Currently GetValue is implemented in this base simply by calling GetValueAndDerivative and discarding the derivative. This is inefficient but sufficient to match API requirements. Derived classes may override and implement differently.

Templated over the fixed and moving image types, as well as an optional VirtualImage type to define the virtual domain. The VirtualImage type defaults to TFixedImage.

This class uses a virtual reference space. This space defines the resolution at which the registration is performed, as well as the physical coordinate system. This is useful for unbiased registration. The region over which registration is performed is taken from the virtual image buffered region. The user can define a virtual domain by calling either CreateVirtualDomainImage or SetVirtualDomainImage. See these methods for details. If the user does not set the virtual image explicitly, then it is created during the call to Initialize by allocating a new image of type TVirtualImage and copying the information from the fixed image using CopyInformation.

Note:: When the virtual image is created by this class, memory is conserved by not allocating space for data within the image. Therefore, derived classes must not access pixel data within the virtual image, it can only be used for iterating over points and performing transformation to and from index and physical coordinates.; If TFixedImage is type VectorImage, then TVirtualImage must be set separately to a non-VectorImage type, e.g. Image<unsigned char, dim>.

Both transforms are initialized to an IdentityTransform, and can be set by the user using SetFixedTranform and SetMovingTransform.

At a minimum, the user must: 1) Set images using SetFixedImage and SetMovingImage. 2) Call Initialize.

Image gradient calculations

Image gradients can be calculated in one of two ways: 1) Using a gradient image filter, by setting Use[Fixed|Moving]ImageGradientFilter to true. By default this is set as an itkGradientRecursiveGaussianImageFilter, a smoothed gradient filter. A filter uses more memory, because it calculates all gradients at once and stores them in an image. The advantage of pre-calculation is for the fixed image gradients, since they only need be calculated once, and for metrics that need to access image gradients more than once for a particular point. The fixed image gradients are only calculated once when this option is set, during Initialize. 2) Otherwise, an image gradient calculator based on ImageFunction is used. By default the CentralDifferenceImageFunction is used. This calculation is not smoothed and gives different results than GradientRecursiveGaussianImageFilter. The advantage is that less memory is used. However for the fixed image, it means needlessly computing the image gradients at each iteration of a registration instead of just computing once at the beginning. The user can supply a different function by calling SetFixedImageGradientCalculator and/or SetMovingImageGradientCalculator.

Both image gradient calculation methods are threaded. Generally it is not recommended to use different image gradient methods for the fixed and moving images because the methods return different results.

Image Masks

Image masks are supported using SetMovingImageMask or SetFixedImageMask. If the image mask is sparse, see the comments for use of sparse point sets.

Sparse Sampling

Sparse sampling is performed by supplying an arbitrary point list over which to evaluate the metric. It's presumed that the user will be working in terms of the fixed image domain, and thus the point list is expected to be in the fixed domain. Internally, the points are transformed into the virtual domain as needed.

Note:: The attributes/data of each point in the set are not used, but rather the point's geometric coordinates. Point sets are set via SetFixedSampledPointSet, and the point set is enabled for use by calling SetUseFixedSampledPointSet.; If the point set is sparse, the option SetUse[Fixed|Moving]ImageGradientFilter typically should be disabled to avoid excessive computation. However, the gradient values of the fixed image are not cached when using a point set (there are plans for this in the future), so depending on the number of iterations (when used during optimization) and the level of sparsity, it may be more efficient to use a gradient image filter for it because it will only be calculated once.

Threading

This class is threaded. Threading is handled by friend classes ImageToImageMetricv4GetValueAndDerivativeThreaderBase and ImageToImageMetricv4GetValueAndDerivativeThreader. Dense and sparse evaluation are handled by template specialization of the ImageToImageMetricv4GetValueAndDerivativeThreader::ThreadedExecution method, in order to iterate over either all points in the virtual space in the case of dense evaluation, or a list of points in the sparse case.

Methods and members of ImageToImageMetricv4 are accessed by the threading class using its m_Associate member, which points to the containing instance of ImageToImageMetricv4.

Pre- and post-processing for threaded operation is handled in ImageToImageMetricv4GetValueAndDerivativeThreaderBase::BeforeThreadedExecution, and ImageToImageMetricv4GetValueAndDerivativeThreaderBase::AfterThreadedExecution, respectively.

Derived classes:

The GetValue method may be overridden to provide better-optimized or otherwise different behavior as needed.

Derived classes must derive a threader class from ImageToImageMetricv4GetValueAndDerivativeThreader, from which a DenseGetValueAndDerivativeThreader and SparseGetValueAndDerivativeThreader must be defined. Then,

    this->m_DenseGetValueAndDerivativeThreader   = DenseDerivedClassGetValueAndDerivativeThreader::New();
    this->m_SparseGetValueAndDerivativeThreader  = SparseDerivedClassGetValueAndDerivativeThreader::New();

must be called in the constructor.

The ProcessPoint method of the derived threader must be overriden to provide the metric-specific evaluation.

To access methods and members within the derived metric class from the derived threader class, the user must cast m_Associate to the type of the derived metric class.

See ImageToImageMetricv4Test for a clear example of what a derived class must implement and do.

Definition at line 176 of file itkImageToImageMetricv4.h.