itkNeighborhoodIterator.h File Reference

Go to the source code of this file.

Namespaces

namespace itk

Functions

**itk::NeighborhoodIterator<
ImageType > * iterator (operator->GetRadius(), myImage, myImage->GetRequestedRegion())

*endcode **Most of the work
for the programmer in the
code above is in setting up
for *the iteration There are
three steps First an inner
product function *object is
created which will be used
to effect convolution with
the *derivative kernel Setting
up the derivative *involves
setting the order and direction
of the derivative we *create
an iterator over the RequestedRegion
of the itk::Image (see Image)*using the radius of the derivative kernel as the size.**Itk iterators only loosely follow STL conventions.Notice that instead of *asking myImage for myImage.begin() and myImage.end()

* operator->CreateDirectional ()

* operator->SetDirection (0)

* operator->SetOrder (1)

*endcode **Most of the work
for the programmer in the
code above is in setting up
for *the iteration There are
three steps First an inner
product function *object is
created which will be used
to effect convolution with
the *derivative kernel Setting
up the derivative *involves
setting the order and direction
of the derivative we *create
an iterator over the RequestedRegion
of the iterator pointer style
STL and the increased *overhead
required to conform to the
complete STL API is not always
*justified **The API for creating
and manipulating a NeighborhoodIterator
mimics *that of the itk::ImageIterators
Like the a *ConstNeighborhoodIterator
is defined on a region of
interest in an itk::Image
*Iteration is constrained
within that region of interest
**A NeighborhoodIterator is
constructed as a container
of pointers (offsets)*to a geometric neighborhood of image pixels.As the central pixel position *in the mask is moved around the image

**iterator SetToBegin ()

* while (!iterator.IsAtEnd())*

Variables

*endcode **Most of the work
for the programmer in the
code above is in setting up
for *the iteration There are
three steps First an inner
product function *object is
created which will be used
to effect convolution with
the *derivative kernel Setting
up the derivative DerivativeOperator

*endcode **Most of the work
for the programmer in the
code above is in setting up
for *the iteration There are
three steps First an inner
product function *object is
created which will be used
to effect convolution with
the *derivative kernel Setting
up the derivative *involves
setting the order and direction
of the derivative Finally

*endcode **Most of the work
for the programmer in the
code above is in setting up
for *the iteration There are
three steps First an inner
product function *object is
created which will be used
to effect convolution with
the *derivative kernel Setting
up the derivative *involves
setting the order and direction
of the derivative we *create
an iterator over the RequestedRegion
of the iterator pointer style
STL and the increased *overhead
required to conform to the
complete STL API is not always
*justified **The API for creating
and manipulating a NeighborhoodIterator
mimics *that of the itk::ImageIterators
Like the a *ConstNeighborhoodIterator
is defined on a region of
interest in an itk::Image
*Iteration is constrained
within that region of interest
**A NeighborhoodIterator is
constructed as a container
of the neighboring pixel pointers
*offsets are moved accordingly
**A em pixel em neighborhood
is defined as a central pixel
location and an *N dimensional
radius extending outward from
that location *Pixels in a
neighborhood can be accessed
through a NeighborhoodIterator
*like elements in an array
For a D neighborhood with
radius x1 *has indices

*endcode **Most of the work
for the programmer in the
code above is in setting up
for *the iteration There are
three steps First an inner
product function *object is
created which will be used
to effect convolution with
the *derivative kernel Setting
up the derivative *involves
setting the order and direction
of the derivative we *create
an iterator over the RequestedRegion
of the iterator pointer style
STL iterators

*endcode **Most of the work
for the programmer in the
code above is in setting up
for *the iteration There are
three steps First an inner
product function *object is
created which will be used
to effect convolution with
the *derivative kernel Setting
up the derivative kernel

*class NeighborhoodIterator
*brief Defines iteration of
a local N dimensional neighborhood
of pixels *across an itk::Image
**This class is a loose extension
of the Standard Template Library
*(STL)*bi-directional iterator
concept to\em masks of pixel
neighborhoods within *itk
*itk::DerivativeOperator<
ImageType operator )

*::size_t s = iterator.GetStride(1)

Function Documentation

* * itk::NeighborhoodIterator<ImageType>* itk::iterator ( operator-> GetRadius(),

myImage ,

myImage-> GetRequestedRegion()

)

Referenced by itk::fem::FEMPArray< T >::Find(), itk::CellInterface< TPixelType, TCellTraits >::MultiVisitor::GetVisitor(), itk::Statistics::Subsample< TSample >::InitializeWithAllInstances(), main(), PrintAvailableTests(), and itk::fem::FEMPArray< T >::Renumber().

* itk::operator->CreateDirectional ( )

* itk::operator->SetDirection ( 0 )

* itk::operator->SetOrder ( 1 )

* itk::while ( !iterator. IsAtEnd() )

Definition at line 61 of file itkNeighborhoodIterator.h.

Variable Documentation

* endcode* * Most of the work for the programmer in the code above is in setting up for* the iteration There are three steps First an inner product function* object is created which will be used to effect convolution with the* derivative kernel Setting up the derivative * involves setting the order and direction of the derivative we* create an iterator over the RequestedRegion of the iterator pointer style STL and the increased* overhead required to conform to the complete STL API is not always* justified* * The API for creating and manipulating a NeighborhoodIterator mimics* that of the itk::ImageIterators Like the a* ConstNeighborhoodIterator is defined on a region of interest in an itk::Image* Iteration is constrained within that region of interest* * A NeighborhoodIterator is constructed as a container of the neighboring pixel pointers* offsets are moved accordingly* * A em pixel em neighborhood is defined as a central pixel location and an* N dimensional radius extending outward from that location* Pixels in a neighborhood can be accessed through a NeighborhoodIterator* like elements in an array For a D neighborhood with radius x1* has itk::indices

Definition at line 99 of file itkNeighborhoodIterator.h.

* class NeighborhoodIterator* brief Defines iteration of a local N dimensional neighborhood of pixels* across an itk::Image* * This class is a loose extension of the Standard Template Library* (STL) * bi-directional iterator concept to \em masks of pixel neighborhoods within * itk * itk::DerivativeOperator<ImageType itk::operator)

Definition at line 32 of file itkNeighborhoodIterator.h.

* ::size_t itk::s = iterator.GetStride(1)

Definition at line 126 of file itkNeighborhoodIterator.h.
Referenced by itk::Statistics::MersenneTwisterRandomVariateGenerator::Initialize(), itk::Statistics::MersenneTwisterRandomVariateGenerator::PrintSelf(), and itk::Neighborhood< TImage::InternalPixelType *,::itk::GetImageDimension< TImage >::ImageDimension >::SetRadius().

Generated at Sun Jul 9 18:46:15 2006 for ITK by


Namespaces
namespace	itk
Functions
*itk::NeighborhoodIterator< ImageType >	iterator (operator->GetRadius(), myImage, myImage->GetRequestedRegion())
endcode Most of the work for the programmer in the code above is in setting up for the iteration There are three steps First an inner product function object is created which will be used to effect convolution with the derivative kernel Setting up the derivative involves setting the order and direction of the derivative we create an iterator over the RequestedRegion of the	itk::Image (see Image)using the radius of the derivative kernel as the size.Itk iterators only loosely follow STL conventions.Notice that instead of asking myImage for myImage.begin() and myImage.end()
*	operator->CreateDirectional ()
*	operator->SetDirection (0)
*	operator->SetOrder (1)
endcode Most of the work for the programmer in the code above is in setting up for the iteration There are three steps First an inner product function object is created which will be used to effect convolution with the derivative kernel Setting up the derivative involves setting the order and direction of the derivative we create an iterator over the RequestedRegion of the iterator pointer style STL and the increased overhead required to conform to the complete STL API is not always justified *The API for creating and manipulating a NeighborhoodIterator mimics that of the itk::ImageIterators Like the a ConstNeighborhoodIterator is defined on a region of interest in an itk::Image Iteration is constrained within that region of interest **A NeighborhoodIterator is constructed as a container of	pointers (offsets)to a geometric neighborhood of image pixels.As the central pixel position in the mask is moved around the image
**iterator	SetToBegin ()
*	while (!iterator.IsAtEnd())*
Variables
endcode Most of the work for the programmer in the code above is in setting up for the iteration There are three steps First an inner product function object is created which will be used to effect convolution with the derivative kernel Setting up the derivative	DerivativeOperator
endcode Most of the work for the programmer in the code above is in setting up for the iteration There are three steps First an inner product function object is created which will be used to effect convolution with the derivative kernel Setting up the derivative *involves setting the order and direction of the derivative	Finally
endcode Most of the work for the programmer in the code above is in setting up for the iteration There are three steps First an inner product function object is created which will be used to effect convolution with the derivative kernel Setting up the derivative involves setting the order and direction of the derivative we create an iterator over the RequestedRegion of the iterator pointer style STL and the increased overhead required to conform to the complete STL API is not always justified *The API for creating and manipulating a NeighborhoodIterator mimics that of the itk::ImageIterators Like the a ConstNeighborhoodIterator is defined on a region of interest in an itk::Image Iteration is constrained within that region of interest *A NeighborhoodIterator is constructed as a container of the neighboring pixel pointers offsets are moved accordingly *A em pixel em neighborhood is defined as a central pixel location and an N dimensional radius extending outward from that location Pixels in a neighborhood can be accessed through a NeighborhoodIterator like elements in an array For a D neighborhood with radius x1 *has	indices
endcode Most of the work for the programmer in the code above is in setting up for the iteration There are three steps First an inner product function object is created which will be used to effect convolution with the derivative kernel Setting up the derivative involves setting the order and direction of the derivative we create an iterator over the RequestedRegion of the iterator pointer style STL	iterators
endcode Most of the work for the programmer in the code above is in setting up for the iteration There are three steps First an inner product function object is created which will be used to effect convolution with the derivative kernel Setting up the derivative	kernel
class NeighborhoodIterator brief Defines iteration of a local N dimensional neighborhood of pixels across an itk::Image This class is a loose extension of the Standard Template Library (STL)bi-directional iterator concept to\em masks of pixel neighborhoods within itk *itk::DerivativeOperator< ImageType	operator )
*::size_t	s = iterator.GetStride(1)