 |
ITK
4.2.0
Insight Segmentation and Registration Toolkit
|
|
ITK
4.2.0
Insight Segmentation and Registration Toolkit
|
#include <itkImageTransformer.h>
Inheritance diagram for itk::ImageTransformer< TInputImage >: Collaboration diagram for itk::ImageTransformer< TInputImage >:Classes | |
| struct | ThreadStruct |
Public Types | |
| typedef SmartPointer< const Self > | ConstPointer |
| typedef DataObject::Pointer | DataObjectPointer |
| typedef InputImageType::PixelType | InputImagePixelType |
| typedef InputImageType::Pointer | InputImagePointer |
| typedef InputImageType::RegionType | InputImageRegionType |
| typedef TInputImage | InputImageType |
| typedef SmartPointer< Self > | Pointer |
| typedef ImageTransformer | Self |
| typedef ProcessObject | Superclass |
| Public Types inherited from itk::ProcessObject | |
| typedef DataObject::DataObjectIdentifierType | DataObjectIdentifierType |
| typedef std::vector < DataObjectPointer > | DataObjectPointerArray |
| typedef DataObjectPointerArray::size_type | DataObjectPointerArraySizeType |
| typedef std::vector < DataObjectIdentifierType > | NameArray |
| Public Types inherited from itk::Object | |
| Public Types inherited from itk::LightObject | |
Static Public Attributes | |
| static const unsigned int | InputImageDimension = TInputImage::ImageDimension |
Static Protected Member Functions | |
| static ITK_THREAD_RETURN_TYPE | ThreaderCallback (void *arg) |
Private Member Functions | |
| ImageTransformer (const Self &) | |
| void | operator= (const Self &) |
Additional Inherited Members | |
| Protected Attributes inherited from itk::ProcessObject | |
| bool | m_Updating |
| TimeStamp | m_OutputInformationMTime |
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.
| typedef SmartPointer< const Self > itk::ImageTransformer< TInputImage >::ConstPointer |
Reimplemented from itk::ProcessObject.
Reimplemented in itk::Statistics::ImageToHistogramFilter< TImage >, and itk::Statistics::MaskedImageToHistogramFilter< TImage, TMaskImage >.
Definition at line 66 of file itkImageTransformer.h.
| 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.
| typedef InputImageType::PixelType itk::ImageTransformer< TInputImage >::InputImagePixelType |
Definition at line 78 of file itkImageTransformer.h.
| typedef InputImageType::Pointer itk::ImageTransformer< TInputImage >::InputImagePointer |
Definition at line 76 of file itkImageTransformer.h.
| typedef InputImageType::RegionType itk::ImageTransformer< TInputImage >::InputImageRegionType |
Definition at line 77 of file itkImageTransformer.h.
| typedef TInputImage itk::ImageTransformer< TInputImage >::InputImageType |
Some convenient typedefs.
Definition at line 72 of file itkImageTransformer.h.
| typedef SmartPointer< Self > itk::ImageTransformer< TInputImage >::Pointer |
Reimplemented from itk::ProcessObject.
Reimplemented in itk::Statistics::ImageToHistogramFilter< TImage >, and itk::Statistics::MaskedImageToHistogramFilter< TImage, TMaskImage >.
Definition at line 65 of file itkImageTransformer.h.
| typedef ImageTransformer itk::ImageTransformer< TInputImage >::Self |
Standard class typedefs.
Reimplemented from itk::ProcessObject.
Reimplemented in itk::Statistics::ImageToHistogramFilter< TImage >, and itk::Statistics::MaskedImageToHistogramFilter< TImage, TMaskImage >.
Definition at line 63 of file itkImageTransformer.h.
| typedef ProcessObject itk::ImageTransformer< TInputImage >::Superclass |
Reimplemented from itk::ProcessObject.
Reimplemented in itk::Statistics::ImageToHistogramFilter< TImage >, and itk::Statistics::MaskedImageToHistogramFilter< TImage, TMaskImage >.
Definition at line 64 of file itkImageTransformer.h.
|
protected |
|
inlineprotectedvirtual |
Definition at line 120 of file itkImageTransformer.h.
|
private |
|
inlineprotectedvirtual |
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.
|
protectedvirtual |
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.
|
inlineprotectedvirtual |
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.
|
protectedvirtual |
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.
Reimplemented from itk::ProcessObject.
|
protectedvirtual |
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.
Reimplemented from itk::ProcessObject.
| const InputImageType* itk::ImageTransformer< TInputImage >::GetInput | ( | void | ) | const |
| InputImageType* itk::ImageTransformer< TInputImage >::GetInput | ( | void | ) |
| const InputImageType* itk::ImageTransformer< TInputImage >::GetInput | ( | unsigned int | idx | ) | 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 >.
|
private |
|
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.
|
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.
|
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.
|
inlineprotectedvirtual |
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.
|
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.
|
inlineprotectedvirtual |
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.
|
virtual |
|
virtual |
|
protectedvirtual |
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".
|
protectedvirtual |
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).
|
staticprotected |
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().
|
static |
ImageDimension constant
Definition at line 82 of file itkImageTransformer.h.
1.8.1
