ITK  4.1.0
Insight Segmentation and Registration Toolkit
Classes | Public Types | Public Member Functions | Static Public Attributes | Protected Member Functions | Static Protected Member Functions
itk::ImageTransformer< TInputImage > Class Template Reference

#include <itkImageTransformer.h>

+ Inheritance diagram for itk::ImageTransformer< TInputImage >:
+ Collaboration diagram for itk::ImageTransformer< TInputImage >:

List of all members.

Classes

struct  ThreadStruct

Public Types

typedef SmartPointer< const SelfConstPointer
typedef DataObject::Pointer DataObjectPointer
typedef InputImageType::PixelType InputImagePixelType
typedef InputImageType::Pointer InputImagePointer
typedef InputImageType::RegionType InputImageRegionType
typedef TInputImage InputImageType
typedef SmartPointer< SelfPointer
typedef ImageTransformer Self
typedef ProcessObject Superclass

Public Member Functions

virtual const char * GetNameOfClass () const
virtual void SetInput (const InputImageType *image)
virtual void SetInput (unsigned int, const TInputImage *image)
const InputImageTypeGetInput (void) const
InputImageTypeGetInput (void)
const InputImageTypeGetInput (unsigned int idx) const
virtual void PushBackInput (const InputImageType *image)
virtual void PopBackInput ()
virtual void PushFrontInput (const InputImageType *image)
virtual void PopFrontInput ()

Static Public Attributes

static const unsigned int InputImageDimension = TInputImage::ImageDimension

Protected Member Functions

virtual void AfterThreadedGenerateData ()
virtual void AllocateOutputs ()
virtual void BeforeThreadedGenerateData ()
virtual void GenerateData ()
virtual void GenerateInputRequestedRegion ()
 ImageTransformer ()
virtual unsigned int SplitRequestedRegion (unsigned int i, unsigned int num, InputImageRegionType &splitRegion)
virtual void ThreadedGenerateData (const InputImageRegionType &inputRegionForThread, ThreadIdType threadId)
virtual ~ImageTransformer ()
void PushBackInput (const DataObject *input)
void PushFrontInput (const DataObject *input)

Static Protected Member Functions

static ITK_THREAD_RETURN_TYPE ThreaderCallback (void *arg)

Private Member Functions

 ImageTransformer (const Self &)
void operator= (const Self &)

Detailed Description

template<class TInputImage>
class itk::ImageTransformer< TInputImage >

Base class for all process objects that transform an image into something else.

ImageTransformer is the base class for all process objects that transform an image data. Specifically, this class defines the SetInput() method that takes a pointer to the input image. The class also defines some internal private data members that are used to manage streaming of data.

Memory management in an ImageTransformer is slightly different than a standard ProcessObject. ProcessObject's always release the bulk data associated with their output prior to GenerateData() being called. ImageTransformers default to not releasing the bulk data incase that particular memory block is large enough to hold the new output values. This avoids unnecessary deallocation/allocation sequences. ImageTransformer's can be forced to use a memory management model similar to the default ProcessObject behaviour by calling ProcessObject::ReleaseDataBeforeUpdateFlagOn(). A user may want to set this flag to limit peak memory usage during a pipeline update.

Definition at line 59 of file itkImageTransformer.h.


Member Typedef Documentation

template<class TInputImage>
typedef SmartPointer< const Self > itk::ImageTransformer< TInputImage >::ConstPointer
template<class TInputImage>
typedef DataObject::Pointer itk::ImageTransformer< TInputImage >::DataObjectPointer

Smart Pointer type to a DataObject.

Reimplemented from itk::ProcessObject.

Definition at line 69 of file itkImageTransformer.h.

template<class TInputImage>
typedef InputImageType::PixelType itk::ImageTransformer< TInputImage >::InputImagePixelType

Definition at line 78 of file itkImageTransformer.h.

template<class TInputImage>
typedef InputImageType::Pointer itk::ImageTransformer< TInputImage >::InputImagePointer

Definition at line 76 of file itkImageTransformer.h.

template<class TInputImage>
typedef InputImageType::RegionType itk::ImageTransformer< TInputImage >::InputImageRegionType

Definition at line 77 of file itkImageTransformer.h.

template<class TInputImage>
typedef TInputImage itk::ImageTransformer< TInputImage >::InputImageType

Some convenient typedefs.

Definition at line 72 of file itkImageTransformer.h.

template<class TInputImage>
typedef SmartPointer< Self > itk::ImageTransformer< TInputImage >::Pointer
template<class TInputImage>
typedef ImageTransformer itk::ImageTransformer< TInputImage >::Self
template<class TInputImage>
typedef ProcessObject itk::ImageTransformer< TInputImage >::Superclass

Constructor & Destructor Documentation

template<class TInputImage>
itk::ImageTransformer< TInputImage >::ImageTransformer ( ) [protected]
template<class TInputImage>
virtual itk::ImageTransformer< TInputImage >::~ImageTransformer ( ) [inline, protected, virtual]

Definition at line 120 of file itkImageTransformer.h.

template<class TInputImage>
itk::ImageTransformer< TInputImage >::ImageTransformer ( const Self ) [private]

Member Function Documentation

template<class TInputImage>
virtual void itk::ImageTransformer< TInputImage >::AfterThreadedGenerateData ( ) [inline, protected, virtual]

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.

Reimplemented in itk::Statistics::ImageToHistogramFilter< TImage >.

Definition at line 209 of file itkImageTransformer.h.

template<class TInputImage>
virtual void itk::ImageTransformer< TInputImage >::AllocateOutputs ( ) [protected, virtual]

The GenerateData method normally allocates the buffers for all of the outputs of a filter. Some filters may want to override this default behavior. For example, a filter may have multiple outputs with varying resolution. Or a filter may want to process data in place by grafting its input to its output.

template<class TInputImage>
virtual void itk::ImageTransformer< TInputImage >::BeforeThreadedGenerateData ( void  ) [inline, protected, virtual]

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.

Reimplemented in itk::Statistics::ImageToHistogramFilter< TImage >.

Definition at line 197 of file itkImageTransformer.h.

template<class TInputImage>
virtual void itk::ImageTransformer< TInputImage >::GenerateData ( ) [protected, virtual]

A version of GenerateData() specific for image processing filters. This implementation will split the processing across multiple threads. The buffer is allocated by this method. Then the BeforeThreadedGenerateData() method is called (if provided). Then, a series of threads are spawned each calling ThreadedGenerateData(). After all the threads have completed processing, the AfterThreadedGenerateData() method is called (if provided). If an image processing filter cannot be threaded, the filter should provide an implementation of GenerateData(). That implementation is responsible for allocating the output buffer. If a filter an be threaded, it should NOT provide a GenerateData() method but should provide a ThreadedGenerateData() instead.

See also:
ThreadedGenerateData()

Reimplemented from itk::ProcessObject.

template<class TInputImage>
virtual void itk::ImageTransformer< TInputImage >::GenerateInputRequestedRegion ( ) [protected, virtual]

The image transformer is assumed to need the whole input.

This implementation of GenerateInputRequestedRegion() only processes the inputs that are a subclass of the ImageBase<InputImageDimension>. If an input is another type of DataObject (including an Image of a different dimension), they are skipped by this method. The subclasses of ImageToImageFilter are responsible for providing an implementation of GenerateInputRequestedRegion() when there are multiple inputs of different types.

See also:
ProcessObject::GenerateInputRequestedRegion(), ImageSource::GenerateInputRequestedRegion()

Reimplemented from itk::ProcessObject.

template<class TInputImage>
const InputImageType* itk::ImageTransformer< TInputImage >::GetInput ( void  ) const
template<class TInputImage>
InputImageType* itk::ImageTransformer< TInputImage >::GetInput ( void  )
template<class TInputImage>
const InputImageType* itk::ImageTransformer< TInputImage >::GetInput ( unsigned int  idx) const
template<class TInputImage>
virtual const char* itk::ImageTransformer< TInputImage >::GetNameOfClass ( ) const [virtual]

Run-time type information (and related methods).

Reimplemented from itk::ProcessObject.

Reimplemented in itk::Statistics::ImageToHistogramFilter< TImage >, and itk::Statistics::MaskedImageToHistogramFilter< TImage, TMaskImage >.

template<class TInputImage>
void itk::ImageTransformer< TInputImage >::operator= ( const Self ) [private]
template<class TInputImage>
virtual void itk::ImageTransformer< TInputImage >::PopBackInput ( ) [virtual]

Push/Pop the input of this process object. These methods allow a filter to model its input vector as a queue or stack. These routines may not be appropriate for all filters, especially filters with different types of inputs. These routines follow the semantics of STL.

The routines are useful for applications that need to process "rolling" sets of images. For instance, if an application has 10 images and they need to run a filter on images 1, 2, 3, 4, then run the filter on images 2, 3, 4, 5, then run the filter on images 3, 4, 5, 6, the application can accomplish this by popping an input off the front of the input list and push a new image onto the back of input list. Again, this only makes sense for filters that single type of input.

Other uses are also possible. For a single input filter, pushing and popping inputs allow the application to temporarily replace an input to a filter.

Reimplemented from itk::ProcessObject.

template<class TInputImage>
virtual void itk::ImageTransformer< TInputImage >::PopFrontInput ( ) [virtual]

Push/Pop the input of this process object. These methods allow a filter to model its input vector as a queue or stack. These routines may not be appropriate for all filters, especially filters with different types of inputs. These routines follow the semantics of STL.

The routines are useful for applications that need to process "rolling" sets of images. For instance, if an application has 10 images and they need to run a filter on images 1, 2, 3, 4, then run the filter on images 2, 3, 4, 5, then run the filter on images 3, 4, 5, 6, the application can accomplish this by popping an input off the front of the input list and push a new image onto the back of input list. Again, this only makes sense for filters that single type of input.

Other uses are also possible. For a single input filter, pushing and popping inputs allow the application to temporarily replace an input to a filter.

Reimplemented from itk::ProcessObject.

template<class TInputImage>
virtual void itk::ImageTransformer< TInputImage >::PushBackInput ( const InputImageType image) [virtual]

Push/Pop the input of this process object. These methods allow a filter to model its input vector as a queue or stack. These routines may not be appropriate for all filters, especially filters with different types of inputs. These routines follow the semantics of STL.

The routines are useful for applications that need to process "rolling" sets of images. For instance, if an application has 10 images and they need to run a filter on images 1, 2, 3, 4, then run the filter on images 2, 3, 4, 5, then run the filter on images 3, 4, 5, 6, the application can accomplish this by popping an input off the front of the input list and push a new image onto the back of input list. Again, this only makes sense for filters that single type of input.

Other uses are also possible. For a single input filter, pushing and popping inputs allow the application to temporarily replace an input to a filter.

template<class TInputImage>
void itk::ImageTransformer< TInputImage >::PushBackInput ( const DataObject input) [inline, protected, virtual]

PushBackInput(), PushFrontInput() in the public section force the input to be the type expected by an ImageTransformer. However, these methods end up "hiding" the versions from the superclass (ProcessObject) whose arguments are DataObjects. Here, we re-expose the versions from ProcessObject to avoid warnings about hiding methods from the superclass. NOTE: The same code resides in ImageToImageFilter

Reimplemented from itk::ProcessObject.

Definition at line 233 of file itkImageTransformer.h.

template<class TInputImage>
virtual void itk::ImageTransformer< TInputImage >::PushFrontInput ( const InputImageType image) [virtual]

Push/Pop the input of this process object. These methods allow a filter to model its input vector as a queue or stack. These routines may not be appropriate for all filters, especially filters with different types of inputs. These routines follow the semantics of STL.

The routines are useful for applications that need to process "rolling" sets of images. For instance, if an application has 10 images and they need to run a filter on images 1, 2, 3, 4, then run the filter on images 2, 3, 4, 5, then run the filter on images 3, 4, 5, 6, the application can accomplish this by popping an input off the front of the input list and push a new image onto the back of input list. Again, this only makes sense for filters that single type of input.

Other uses are also possible. For a single input filter, pushing and popping inputs allow the application to temporarily replace an input to a filter.

template<class TInputImage>
void itk::ImageTransformer< TInputImage >::PushFrontInput ( const DataObject input) [inline, protected, virtual]

PushBackInput(), PushFrontInput() in the public section force the input to be the type expected by an ImageTransformer. However, these methods end up "hiding" the versions from the superclass (ProcessObject) whose arguments are DataObjects. Here, we re-expose the versions from ProcessObject to avoid warnings about hiding methods from the superclass. NOTE: The same code resides in ImageToImageFilter

Reimplemented from itk::ProcessObject.

Definition at line 235 of file itkImageTransformer.h.

template<class TInputImage>
virtual void itk::ImageTransformer< TInputImage >::SetInput ( const InputImageType image) [virtual]
template<class TInputImage>
virtual void itk::ImageTransformer< TInputImage >::SetInput ( unsigned  int,
const TInputImage *  image 
) [virtual]
template<class TInputImage>
virtual unsigned int itk::ImageTransformer< TInputImage >::SplitRequestedRegion ( unsigned int  i,
unsigned int  num,
InputImageRegionType splitRegion 
) [protected, virtual]

Split the input's RequestedRegion into "num" pieces, returning region "i" as "splitRegion". This method is called "num" times. The regions must not overlap. The method returns the number of pieces that the routine is capable of splitting the input RequestedRegion, i.e. return value is less than or equal to "num".

template<class TInputImage>
virtual void itk::ImageTransformer< TInputImage >::ThreadedGenerateData ( const InputImageRegionType inputRegionForThread,
ThreadIdType  threadId 
) [protected, virtual]

If an imaging filter can be implemented as a multithreaded algorithm, the filter will provide an implementation of ThreadedGenerateData(). This superclass will automatically split the output image into a number of pieces, spawn multiple threads, and call ThreadedGenerateData() in each thread. Prior to spawning threads, the BeforeThreadedGenerateData() method is called. After all the threads have completed, the AfterThreadedGenerateData() method is called. If an image processing filter cannot support threading, that filter should provide an implementation of the GenerateData() method instead of providing an implementation of ThreadedGenerateData(). If a filter provides a GenerateData() method as its implementation, then the filter is responsible for allocating the output data. If a filter provides a ThreadedGenerateData() method as its implementation, then the output memory will allocated automatically by this superclass. The ThreadedGenerateData() method should only produce the output specified by "inputThreadRegion" parameter. ThreadedGenerateData() cannot write to any other portion of the output image (as this is responsibility of a different thread).

See also:
GenerateData(), SplitRequestedRegion()
template<class TInputImage>
static ITK_THREAD_RETURN_TYPE itk::ImageTransformer< TInputImage >::ThreaderCallback ( void *  arg) [static, protected]

Static function used as a "callback" by the MultiThreader. The threading library will call this routine for each thread, which will delegate the control to ThreadedGenerateData().


Member Data Documentation

template<class TInputImage>
const unsigned int itk::ImageTransformer< TInputImage >::InputImageDimension = TInputImage::ImageDimension [static]

ImageDimension constant

Definition at line 82 of file itkImageTransformer.h.


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