Templated n-dimensional nonrectilinear-coordinate image base class. More...

#include <itkSpecialCoordinatesImage.h>

Inheritance diagram for itk::SpecialCoordinatesImage< TPixel, VImageDimension >:

Collaboration diagram for itk::SpecialCoordinatesImage< TPixel, VImageDimension >:

Public Types
typedef DefaultPixelAccessorFunctor < Self >	AccessorFunctorType
typedef DefaultPixelAccessor < PixelType >	AccessorType
typedef SmartPointer< const Self >	ConstPointer
typedef WeakPointer< const Self >	ConstWeakPointer
typedef Superclass::IndexType	IndexType
typedef TPixel	InternalPixelType
typedef PixelType	IOPixelType
typedef Superclass::OffsetType	OffsetType
typedef ImportImageContainer < SizeValueType, PixelType >	PixelContainer
typedef PixelContainer::ConstPointer	PixelContainerConstPointer
typedef PixelContainer::Pointer	PixelContainerPointer
typedef TPixel	PixelType
typedef SmartPointer< Self >	Pointer
typedef Superclass::PointType	PointType
typedef Superclass::RegionType	RegionType
typedef SpecialCoordinatesImage	Self
typedef Superclass::SizeType	SizeType
typedef Superclass::SpacingType	SpacingType
typedef ImageBase < VImageDimension >	Superclass
typedef TPixel	ValueType
Public Member Functions
void	Allocate ()
virtual ::itk::LightObject::Pointer	CreateAnother (void) const
void	FillBuffer (const TPixel &value)
virtual const char *	GetNameOfClass () const
const TPixel &	GetPixel (const IndexType &index) const
TPixel &	GetPixel (const IndexType &index)
const AccessorType	GetPixelAccessor (void) const
AccessorType	GetPixelAccessor (void)
const PixelContainer *	GetPixelContainer () const
PixelContainer *	GetPixelContainer ()
virtual void	Initialize ()
const TPixel &	operator[] (const IndexType &index) const
TPixel &	operator[] (const IndexType &index)
void	SetPixel (const IndexType &index, const TPixel &value)
void	SetPixelContainer (PixelContainer *container)
void	SetRegions (SizeType size)

void	SetRegions (RegionType region)

TPixel *	GetBufferPointer ()
const TPixel *	GetBufferPointer () const

virtual void	SetSpacing (const SpacingType &)
virtual void	SetSpacing (const double[VImageDimension])
virtual void	SetSpacing (const float[VImageDimension])
virtual void	SetOrigin (const PointType)
virtual void	SetOrigin (const double[VImageDimension])
virtual void	SetOrigin (const float[VImageDimension])
Static Public Member Functions
static Pointer	New ()
Static Public Attributes
static const unsigned int	ImageDimension = VImageDimension
Protected Member Functions
void	PrintSelf (std::ostream &os, Indent indent) const
	SpecialCoordinatesImage ()
virtual	~SpecialCoordinatesImage ()
Private Member Functions
void	operator= (const Self &)
	SpecialCoordinatesImage (const Self &)
Private Attributes
PixelContainerPointer	m_Buffer

Detailed Description

template<class TPixel, unsigned int VImageDimension = 2>
class itk::SpecialCoordinatesImage< TPixel, VImageDimension >

Templated n-dimensional nonrectilinear-coordinate image base class.

SpecialCoordinatesImages are templated over a pixel type (modeling the dependent variables), and a dimension (number of independent variables). The container for the pixel data is the ImportImageContainer.

Within the pixel container, images are modeled as arrays, defined by a start index and a size.

Almost arbitrary mappings between index space & Cartesian physical space are possible, and so m_Origin and m_Spacing should be ignored. They exist only to allow the possibility of running a "spatially-aware" filter in raw index space, as if the SpecialCoordinatesImage data was laid out on a regular grid. Note that this may or may not produce useful results, and it is up the the user to determine the appropriateness of running a filter designed for normal images on special-coordinates images.

The only correct generic method for operating on a SpecialCoordinatesImage in physical space is to use the virtual functions TransformPhysicalPointToIndex, TransformPhysicalPointToContinuousIndex, TransformIndexToPhysicalPoint, and TransformContinuousIndexToPhysicalPoint. All of these methods transform points in Cartesian physical space to and from indices in the special (typically non-Cartesian) index space. It is also possible to check the type of coordinate representation being used by a SpecialCoordinatesImage, and then use representation-specific code to speed up the filter for certain coordinate representations, falling back to the generic method for unrecognized and/or unoptimized coordinate representations.

There are three sets of meta-data describing portions of a SpecialCoordinatesImages. These are "Region" objects that define a portion of an image via a starting index for the image array and a size. The ivar LargestPossibleRegion defines the size and starting index of the image dataset. The entire image dataset, however, need not be resident in memory. The region of the image that is resident in memory is defined by the "BufferedRegion". The Buffer is a contiguous block of memory. The third set of meta-data defines a region of interest, called the "RequestedRegion". The RequestedRegion is used by the pipeline execution model to define what a filter is requested to produce.

[RegionIndex, RegionSize] C [BufferIndex, BufferSize] C [ImageIndex, ImageSize]

Pixels can be accessed direcly using the SetPixel() and GetPixel() methods or can be accessed via iterators. Begin() creates an iterator that can walk a specified region of a buffer.

The pixel type may be one of the native types; a Insight-defined class type such as Vector; or a user-defined type. Note that depending on the type of pixel that you use, the process objects (i.e., those filters processing data objects) may not operate on the image and/or pixel type. This becomes apparent at compile-time because operator overloading (for the pixel type) is not supported.

The data in an image is arranged in a 1D array as [][][][slice][row][col] with the column index varying most rapidly. The Index type reverses the order so that with Index[0] = col, Index[1] = row, Index[2] = slice, ...

See also:: ImageContainerInterface; Image

Definition at line 95 of file itkSpecialCoordinatesImage.h.