itk::CreateEulerAffineTransformMatrix< IntensityType > Class Template Reference

Class to apply the affine transformation matrix to a 3D image. More...

Inheritance diagram for itk::CreateEulerAffineTransformMatrix< IntensityType >:

Collaboration diagram for itk::CreateEulerAffineTransformMatrix< IntensityType >:

Public Types
typedef CreateEulerAffineTransformMatrix	Self
typedef SmartPointer< Self >	Pointer
typedef SmartPointer< const Self >	ConstPointer
typedef CreateEulerAffineTransformMatrixBaseClass < Image< IntensityType, 3 > , Image< IntensityType, 3 > >	Superclass
typedef Image< IntensityType, 3 >	InputImageType
typedef InputImageType::Pointer	InputImagePointer
typedef InputImageType::ConstPointer	InputImageConstPointer
typedef InputImageType::RegionType	InputImageRegionType
typedef InputImageType::SizeType	InputImageSizeType
typedef InputImageType::SpacingType	InputImageSpacingType
typedef InputImageType::PointType	InputImagePointType
typedef InputImageType::PixelType	InputImagePixelType
typedef InputImageType::IndexType	InputImageIndexType
typedef Image< IntensityType, 3 >	OutputImageType
typedef OutputImageType::Pointer	OutputImagePointer
typedef OutputImageType::ConstPointer	OutputImageConstPointer
typedef OutputImageType::RegionType	OutputImageRegionType
typedef OutputImageType::SizeType	OutputImageSizeType
typedef OutputImageType::SpacingType	OutputImageSpacingType
typedef OutputImageType::PointType	OutputImagePointType
typedef OutputImageType::PixelType	OutputImagePixelType
typedef OutputImageType::IndexType	OutputImageIndexType
typedef EulerAffineTransform < double, 3, 3 >	EulerAffineTransformType
typedef vnl_sparse_matrix< double >	SparseMatrixType
typedef vnl_matrix< double >	FullMatrixType
typedef vnl_vector< double >	VectorType
typedef itk::hash_map< int, VectorType >	VectorMapType
typedef itk::hash_map< int, VectorType >::iterator	VectorMapIterator
typedef itk::hash_map< int, VectorType >::const_iterator	VectorMapConstIterator
Public Types inherited from itk::CreateEulerAffineTransformMatrixBaseClass< Image< IntensityType, 3 >, Image< IntensityType, 3 > >
typedef CreateEulerAffineTransformMatrixBaseClass	Self
typedef ImageToImageFilter < Image< IntensityType, 3 > , Image< IntensityType, 3 > >	Superclass
typedef SmartPointer< Self >	Pointer
typedef SmartPointer< const Self >	ConstPointer
typedef Image< IntensityType, 3 >	InputImageType
typedef InputImageType::Pointer	InputImagePointer
typedef InputImageType::RegionType	InputImageRegionType
typedef InputImageType::PixelType	InputImagePixelType
typedef Image< IntensityType, 3 >	OutputImageType
typedef OutputImageType::Pointer	OutputImagePointer
typedef OutputImageType::RegionType	OutputImageRegionType
typedef OutputImageType::PixelType	OutputImagePixelType
typedef EulerAffineTransform < double, 3, 3 >	EulerAffineTransformType

Public Member Functions
virtual const char *	GetClassName () const
	itkStaticConstMacro (InputImageDimension, unsigned int, 3)
	itkStaticConstMacro (OutputImageDimension, unsigned int, 3)
virtual void	SetAffineTransform (EulerAffineTransformType *_arg)
virtual EulerAffineTransformType *	GetAffineTransform ()
virtual void	GenerateOutputInformation (void)
virtual void	GenerateInputRequestedRegion (void)
virtual void	EnlargeOutputRequestedRegion (DataObject *output)
void	SetTransformedImageSize (OutputImageSizeType &outImageSize)
void	SetTransformedImageSpacing (OutputImageSpacingType &outImageSpacing)
void	SetTransformedImageOrigin (OutputImagePointType &outImageOrigin)
void	SetSingleThreadedExecution (void)
Public Member Functions inherited from itk::CreateEulerAffineTransformMatrixBaseClass< Image< IntensityType, 3 >, Image< IntensityType, 3 > >
	itkStaticConstMacro (InputImageDimension, unsigned int, Image< IntensityType, 3 >::ImageDimension)
	itkStaticConstMacro (OutputImageDimension, unsigned int, Image< IntensityType, 3 >::ImageDimension)

Static Public Member Functions
static Pointer	New ()
Static Public Member Functions inherited from itk::CreateEulerAffineTransformMatrixBaseClass< Image< IntensityType, 3 >, Image< IntensityType, 3 > >
static Pointer	New ()

Protected Member Functions
	CreateEulerAffineTransformMatrix ()
virtual	~CreateEulerAffineTransformMatrix (void)
void	PrintSelf (std::ostream &os, Indent indent) const
virtual void	BeforeThreadedGenerateData (void)
virtual void	AfterThreadedGenerateData (void)
void	GenerateData ()
void	ThreadedGenerateData (const OutputImageRegionType &outputRegionForThread, ThreadIdType threadId)
Protected Member Functions inherited from itk::CreateEulerAffineTransformMatrixBaseClass< Image< IntensityType, 3 >, Image< IntensityType, 3 > >
	CreateEulerAffineTransformMatrixBaseClass ()
virtual	~CreateEulerAffineTransformMatrixBaseClass ()
void	PrintSelf (std::ostream &os, Indent indent) const

Protected Attributes
OutputImageSizeType	m_OutputImageSize
OutputImageSpacingType	m_OutputImageSpacing
OutputImagePointType	m_OutputImageOrigin
bool	m_FlagMultiThreadedExecution
FullMatrixType	m_affineCoreMatrix
FullMatrixType	m_affineCoreMatrixInverse
VectorType	m_inputCoordinateVector
VectorType	m_outputCoordinateVector
EulerAffineTransformType::Pointer	m_AffineTransform
SparseMatrixType	m_sparseAffineTransformMatrix
SparseMatrixType	m_sparseTransposeAffineTransformMatrix
Protected Attributes inherited from itk::CreateEulerAffineTransformMatrixBaseClass< Image< IntensityType, 3 >, Image< IntensityType, 3 > >
EulerAffineTransformType::Pointer	m_AffineTransform

Detailed Description

template<class IntensityType = float>
class itk::CreateEulerAffineTransformMatrix< IntensityType >

Class to apply the affine transformation matrix to a 3D image.

Member Typedef Documentation

template<class IntensityType = float>

typedef SmartPointer<const Self> itk::CreateEulerAffineTransformMatrix< IntensityType >::ConstPointer

template<class IntensityType = float>

typedef EulerAffineTransform<double, 3, 3> itk::CreateEulerAffineTransformMatrix< IntensityType >::EulerAffineTransformType

template<class IntensityType = float>

typedef vnl_matrix<double> itk::CreateEulerAffineTransformMatrix< IntensityType >::FullMatrixType

template<class IntensityType = float>

typedef InputImageType::ConstPointer itk::CreateEulerAffineTransformMatrix< IntensityType >::InputImageConstPointer

template<class IntensityType = float>

typedef InputImageType::IndexType itk::CreateEulerAffineTransformMatrix< IntensityType >::InputImageIndexType

template<class IntensityType = float>

typedef InputImageType::PixelType itk::CreateEulerAffineTransformMatrix< IntensityType >::InputImagePixelType

template<class IntensityType = float>

typedef InputImageType::Pointer itk::CreateEulerAffineTransformMatrix< IntensityType >::InputImagePointer

template<class IntensityType = float>

typedef InputImageType::PointType itk::CreateEulerAffineTransformMatrix< IntensityType >::InputImagePointType

template<class IntensityType = float>

typedef InputImageType::RegionType itk::CreateEulerAffineTransformMatrix< IntensityType >::InputImageRegionType

template<class IntensityType = float>

typedef InputImageType::SizeType itk::CreateEulerAffineTransformMatrix< IntensityType >::InputImageSizeType

template<class IntensityType = float>

typedef InputImageType::SpacingType itk::CreateEulerAffineTransformMatrix< IntensityType >::InputImageSpacingType

template<class IntensityType = float>

typedef Image<IntensityType, 3> itk::CreateEulerAffineTransformMatrix< IntensityType >::InputImageType

Some convenient typedefs.

template<class IntensityType = float>

typedef OutputImageType::ConstPointer itk::CreateEulerAffineTransformMatrix< IntensityType >::OutputImageConstPointer

template<class IntensityType = float>

typedef OutputImageType::IndexType itk::CreateEulerAffineTransformMatrix< IntensityType >::OutputImageIndexType

template<class IntensityType = float>

typedef OutputImageType::PixelType itk::CreateEulerAffineTransformMatrix< IntensityType >::OutputImagePixelType

template<class IntensityType = float>

typedef OutputImageType::Pointer itk::CreateEulerAffineTransformMatrix< IntensityType >::OutputImagePointer

template<class IntensityType = float>

typedef OutputImageType::PointType itk::CreateEulerAffineTransformMatrix< IntensityType >::OutputImagePointType

template<class IntensityType = float>

typedef OutputImageType::RegionType itk::CreateEulerAffineTransformMatrix< IntensityType >::OutputImageRegionType

template<class IntensityType = float>

typedef OutputImageType::SizeType itk::CreateEulerAffineTransformMatrix< IntensityType >::OutputImageSizeType

template<class IntensityType = float>

typedef OutputImageType::SpacingType itk::CreateEulerAffineTransformMatrix< IntensityType >::OutputImageSpacingType

template<class IntensityType = float>

typedef Image<IntensityType, 3> itk::CreateEulerAffineTransformMatrix< IntensityType >::OutputImageType

template<class IntensityType = float>

typedef SmartPointer<Self> itk::CreateEulerAffineTransformMatrix< IntensityType >::Pointer

template<class IntensityType = float>

typedef CreateEulerAffineTransformMatrix itk::CreateEulerAffineTransformMatrix< IntensityType >::Self

Standard class typedefs.

template<class IntensityType = float>

typedef vnl_sparse_matrix<double> itk::CreateEulerAffineTransformMatrix< IntensityType >::SparseMatrixType

Create a sparse matrix to store the affine transformation matrix coefficients

template<class IntensityType = float>

typedef CreateEulerAffineTransformMatrixBaseClass<Image< IntensityType, 3>, Image< IntensityType, 3> > itk::CreateEulerAffineTransformMatrix< IntensityType >::Superclass

template<class IntensityType = float>

typedef itk::hash_map<int, VectorType>::const_iterator itk::CreateEulerAffineTransformMatrix< IntensityType >::VectorMapConstIterator

template<class IntensityType = float>

typedef itk::hash_map<int, VectorType>::iterator itk::CreateEulerAffineTransformMatrix< IntensityType >::VectorMapIterator

template<class IntensityType = float>

typedef itk::hash_map<int, VectorType> itk::CreateEulerAffineTransformMatrix< IntensityType >::VectorMapType

Type of the map used to store the affine transformation matrix per thread

template<class IntensityType = float>

typedef vnl_vector<double> itk::CreateEulerAffineTransformMatrix< IntensityType >::VectorType

Constructor & Destructor Documentation

template<class IntensityType = float>

itk::CreateEulerAffineTransformMatrix< IntensityType >::CreateEulerAffineTransformMatrix ( )

protected

template<class IntensityType = float>

virtual itk::CreateEulerAffineTransformMatrix< IntensityType >::~CreateEulerAffineTransformMatrix ( void  )

inlineprotectedvirtual

Member Function Documentation

template<class IntensityType = float>

virtual void itk::CreateEulerAffineTransformMatrix< IntensityType >::AfterThreadedGenerateData ( void  )

protectedvirtual

If an imaging filter needs to perform processing after all processing threads have completed, the filter can can provide an implementation for AfterThreadedGenerateData(). The execution flow in the default GenerateData() method will be: 1) Allocate the output buffer 2) Call BeforeThreadedGenerateData() 3) Spawn threads, calling ThreadedGenerateData() in each thread. 4) Call AfterThreadedGenerateData() Note that this flow of control is only available if a filter provides a ThreadedGenerateData() method and NOT a GenerateData() method.

template<class IntensityType = float>

virtual void itk::CreateEulerAffineTransformMatrix< IntensityType >::BeforeThreadedGenerateData ( void  )

protectedvirtual

If an imaging filter needs to perform processing after the buffer has been allocated but before threads are spawned, the filter can can provide an implementation for BeforeThreadedGenerateData(). The execution flow in the default GenerateData() method will be: 1) Allocate the output buffer 2) Call BeforeThreadedGenerateData() 3) Spawn threads, calling ThreadedGenerateData() in each thread. 4) Call AfterThreadedGenerateData() Note that this flow of control is only available if a filter provides a ThreadedGenerateData() method and NOT a GenerateData() method.

template<class IntensityType = float>

virtual void itk::CreateEulerAffineTransformMatrix< IntensityType >::EnlargeOutputRequestedRegion ( DataObject *  output )

virtual

template<class IntensityType = float>

void itk::CreateEulerAffineTransformMatrix< IntensityType >::GenerateData ( )

protected

Single threaded execution, for debugging purposes ( call SetSingleThreadedExecution() )

template<class IntensityType = float>

virtual void itk::CreateEulerAffineTransformMatrix< IntensityType >::GenerateInputRequestedRegion ( void  )

virtual

Rather than calculate the input requested region for a particular projection (which might take longer than the actual projection), we simply set the input requested region to the entire 3D input image region. Therefore needs to provide an implementation for GenerateInputRequestedRegion() in order to inform the pipeline execution model.

See also

ProcessObject::GenerateInputRequestedRegion()

template<class IntensityType = float>

virtual void itk::CreateEulerAffineTransformMatrix< IntensityType >::GenerateOutputInformation ( void  )

virtual

CreateEulerAffineTransformMatrix produces a 3D ouput image which is a same resolution and with a different pixel spacing than its 3D input image (obviously). As such, CreateEulerAffineTransformMatrix needs to provide an implementation for GenerateOutputInformation() in order to inform the pipeline execution model. The original documentation of this method is below.

See also

ProcessObject::GenerateOutputInformaton()

template<class IntensityType = float>

virtual EulerAffineTransformType* itk::CreateEulerAffineTransformMatrix< IntensityType >::GetAffineTransform ( )

virtual

Get the affine transformation

Reimplemented from itk::CreateEulerAffineTransformMatrixBaseClass< Image< IntensityType, 3 >, Image< IntensityType, 3 > >.

template<class IntensityType = float>

virtual const char* itk::CreateEulerAffineTransformMatrix< IntensityType >::GetClassName ( ) const

virtual

Run-time type information (and related methods).

Reimplemented from itk::CreateEulerAffineTransformMatrixBaseClass< Image< IntensityType, 3 >, Image< IntensityType, 3 > >.

template<class IntensityType = float>

itk::CreateEulerAffineTransformMatrix< IntensityType >::itkStaticConstMacro	(	InputImageDimension	,
		unsigned	int,
		3
	)

ImageDimension enumeration

template<class IntensityType = float>

itk::CreateEulerAffineTransformMatrix< IntensityType >::itkStaticConstMacro	(	OutputImageDimension	,
		unsigned	int,
		3
	)

template<class IntensityType = float>

static Pointer itk::CreateEulerAffineTransformMatrix< IntensityType >::New ( )

static

Method for creation through the object factory.

template<class IntensityType = float>

void itk::CreateEulerAffineTransformMatrix< IntensityType >::PrintSelf ( std::ostream &  os, Indent  indent  ) const

protected

template<class IntensityType = float>

virtual void itk::CreateEulerAffineTransformMatrix< IntensityType >::SetAffineTransform ( EulerAffineTransformType *  _arg )

virtual

Set the affine transformation

Reimplemented from itk::CreateEulerAffineTransformMatrixBaseClass< Image< IntensityType, 3 >, Image< IntensityType, 3 > >.

template<class IntensityType = float>

void itk::CreateEulerAffineTransformMatrix< IntensityType >::SetSingleThreadedExecution ( void  )

inline

For debugging purposes, set single threaded execution

template<class IntensityType = float>

void itk::CreateEulerAffineTransformMatrix< IntensityType >::SetTransformedImageOrigin ( OutputImagePointType &  outImageOrigin )

inline

Set the origin of the output projected image.

template<class IntensityType = float>

void itk::CreateEulerAffineTransformMatrix< IntensityType >::SetTransformedImageSize ( OutputImageSizeType &  outImageSize )

inline

Set the size in pixels of the output projected image.

template<class IntensityType = float>

void itk::CreateEulerAffineTransformMatrix< IntensityType >::SetTransformedImageSpacing ( OutputImageSpacingType &  outImageSpacing )

inline

Set the resolution in mm of the output projected image.

template<class IntensityType = float>

void itk::CreateEulerAffineTransformMatrix< IntensityType >::ThreadedGenerateData ( const OutputImageRegionType &  outputRegionForThread, ThreadIdType  threadId  )

protected

CreateEulerAffineTransformMatrix can be implemented as a multithreaded filter. Therefore, this implementation provides a ThreadedGenerateData() routine which is called for each processing thread. The output image data is allocated automatically by the superclass prior to calling ThreadedGenerateData(). ThreadedGenerateData can only write to the portion of the output image specified by the parameter "outputRegionForThread"

See also

CreateEulerAffineTransformMatrixBaseClass::ThreadedGenerateData(), CreateEulerAffineTransformMatrixBaseClass::GenerateData()

Member Data Documentation

template<class IntensityType = float>

FullMatrixType itk::CreateEulerAffineTransformMatrix< IntensityType >::m_affineCoreMatrix

protected

The affin transform core matrix and its inverse matrix

template<class IntensityType = float>

FullMatrixType itk::CreateEulerAffineTransformMatrix< IntensityType >::m_affineCoreMatrixInverse

protected

template<class IntensityType = float>

EulerAffineTransformType::Pointer itk::CreateEulerAffineTransformMatrix< IntensityType >::m_AffineTransform

protected

The affine transform

template<class IntensityType = float>

bool itk::CreateEulerAffineTransformMatrix< IntensityType >::m_FlagMultiThreadedExecution

protected

Flag to turn multithreading on or off

template<class IntensityType = float>

VectorType itk::CreateEulerAffineTransformMatrix< IntensityType >::m_inputCoordinateVector

protected

The input and output coordinate vectors

template<class IntensityType = float>

VectorType itk::CreateEulerAffineTransformMatrix< IntensityType >::m_outputCoordinateVector

protected

template<class IntensityType = float>

OutputImagePointType itk::CreateEulerAffineTransformMatrix< IntensityType >::m_OutputImageOrigin

protected

The origin of the output projected image

template<class IntensityType = float>

OutputImageSizeType itk::CreateEulerAffineTransformMatrix< IntensityType >::m_OutputImageSize

protected

The size of the output projected image

template<class IntensityType = float>

OutputImageSpacingType itk::CreateEulerAffineTransformMatrix< IntensityType >::m_OutputImageSpacing

protected

The resolution of the output projected image

template<class IntensityType = float>

SparseMatrixType itk::CreateEulerAffineTransformMatrix< IntensityType >::m_sparseAffineTransformMatrix

protected

Create a sparse matrix to store the affine transformation matrix coefficients

template<class IntensityType = float>

SparseMatrixType itk::CreateEulerAffineTransformMatrix< IntensityType >::m_sparseTransposeAffineTransformMatrix

protected

Create a sparse matrix to store the transpose of the affine transformation matrix

---

The documentation for this class was generated from the following file:

• itkCreateEulerAffineTransformMatrix.h