[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]

details MultiIterator
[Multi-dimensional Array Iterators]
VIGRA

A multi-dimensional hierarchical iterator to be used with vigra::MultiArrayView if it is not strided. More...

#include <vigra/multi_iterator.hxx>

Inherited by MultiIterator< 2, T, REFERENCE, POINTER >.

List of all members.

Public Types

enum  
typedef MultiIterator< N-1, T,
REFERENCE, POINTER > 
base_type
typedef const value_typeconst_pointer
typedef const value_typeconst_reference
typedef MultiArrayIndex difference_type
typedef StridedMultiIterator
< 1, T, REFERENCE, POINTER > 
iterator
typedef
multi_dimensional_traverser_tag 
iterator_category
typedef MultiArrayShape< N >::type multi_difference_type
typedef base_type next_type
typedef POINTER pointer
typedef REFERENCE reference
typedef T value_type

Public Member Functions

next_type begin () const
template<unsigned int K>
MultiIterator< K+1, T,
REFERENCE, POINTER > & 
dim ()
next_type end () const
pointer get () const
iterator iteratorForDimension (unsigned int d) const
 MultiIterator (pointer ptr, const difference_type *stride, const difference_type *shape)
 MultiIterator ()
bool operator!= (const MultiIterator &rhs) const
reference operator* () const
MultiIterator operator+ (multi_difference_type const &d) const
MultiIterator operator+ (difference_type n) const
MultiIterator operator++ (int)
void operator++ ()
MultiIteratoroperator+= (multi_difference_type const &d)
MultiIteratoroperator+= (difference_type n)
MultiIterator operator- (multi_difference_type const &d) const
MultiIterator operator- (difference_type n) const
difference_type operator- (MultiIterator const &d) const
MultiIterator operator-- (int)
void operator-- ()
MultiIteratoroperator-= (multi_difference_type const &d)
MultiIteratoroperator-= (difference_type n)
pointer operator-> () const
bool operator< (const MultiIterator &rhs) const
bool operator<= (const MultiIterator &rhs) const
bool operator== (const MultiIterator &rhs) const
bool operator> (const MultiIterator &rhs) const
bool operator>= (const MultiIterator &rhs) const
reference operator[] (multi_difference_type const &d) const
reference operator[] (difference_type n) const


Detailed Description

template<unsigned int N, class T, class REFERENCE, class POINTER>
class vigra::MultiIterator< N, T, REFERENCE, POINTER >

A multi-dimensional hierarchical iterator to be used with vigra::MultiArrayView if it is not strided.

See Multi-dimensional Array Iterators for further documentation.

#include <vigra/multi_iterator.hxx>

Namespace: vigra


Member Typedef Documentation

typedef MultiIterator<N-1, T, REFERENCE, POINTER> base_type

the type of the parent in the inheritance hierarchy.

typedef const value_type* const_pointer

const pointer type

typedef const value_type& const_reference

const reference type (result of operator[] const)

difference type (used for offsetting)

typedef StridedMultiIterator<1, T, REFERENCE, POINTER> iterator

the 1-dimensional iterator for this iterator hierarchy (result of iteratorForDimension()).

typedef multi_dimensional_traverser_tag iterator_category

the iterator tag (image traverser)

multi difference type (used for offsetting along all axes simultaneously)

the MultiIterator for the next lower dimension.

typedef POINTER pointer

pointer type

typedef REFERENCE reference

reference type (result of operator[])

typedef T value_type

the iterator's value type


Member Enumeration Documentation

anonymous enum

the iterator's level in the dimension hierarchy


Constructor & Destructor Documentation

MultiIterator (  ) 

default constructor.

MultiIterator ( pointer  ptr,
const difference_type stride,
const difference_type shape 
)

construct from pointer, strides (offset of a sample to the next) for every dimension, and the shape.


Member Function Documentation

next_type begin (  )  const

Return the (N-1)-dimensional multi-iterator that points to the first (N-1)-dimensional subarray of the N-dimensional array this iterator is referring to. The result is only valid if this iterator refers to location 0 in all dimensions below its current dimension N, otherwise it is undefined. Usage:

            MultiIterator<2, int> outer = ...;  // this iterator

            MultiIterator<2, int>::next_type inner = outer.begin();
            for(; inner != outer.end(); ++inner)
            {
                // manipulate current 1D subimage
            }

MultiIterator<K+1, T, REFERENCE, POINTER>& dim (  ) 

Return the multi-iterator that operates on dimension K in order to manipulate this dimension directly. Usage:

            MultiIterator<3, int> i3 = ...;
                
            i3.template dim<2>()++;  // increment outer dimension
            i3.template dim<0>()++;  // increment inner dimension

For convenience, the same functionality is also available as dim0(), dim1() etc. up to dim4():

            MultiIterator<3, int> i3 = ...;
                
            i3.dim2()++;  // increment outer dimension
            i3.dim0()++;  // increment inner dimension

next_type end (  )  const

Return the (N-1)-dimensional multi-iterator that points beyond the last (N-1)-dimensional subarray of the N-dimensional array this iterator is referring to. The result is only valid if this iterator refers to location 0 in all dimensions below its current dimension N, otherwise it is undefined.

pointer get (  )  const

get address of current item

iterator iteratorForDimension ( unsigned int  d  )  const

Get a 1-dimensional, STL-compatible iterator for the given dimension, pointing to the current element of this. Usage:

            MultiIterator<3, int> outer = ...;  // this iterator

            MultiIterator<3, int>::iterator i = outer.iteratorForDimension(1);
            MultiIterator<3, int>::iterator end = i + height;
            for(; i != end; ++i)
            {
                // go down the current column starting at the location of 'outer'
            }

bool operator!= ( const MultiIterator< N, T, REFERENCE, POINTER > &  rhs  )  const

inequality. True if iterators reference different items.

reference operator* (  )  const

derefenrence item

MultiIterator operator+ ( multi_difference_type const &  d  )  const

addition along all dimensions

MultiIterator operator+ ( difference_type  n  )  const

addition within current dimension

MultiIterator operator++ ( int   ) 

postfix-increment the iterator in it's current dimension

void operator++ (  ) 

prefix-increment the iterator in it's current dimension

MultiIterator& operator+= ( multi_difference_type const &  d  ) 

increment the iterator in all dimensions by the given offset.

MultiIterator& operator+= ( difference_type  n  ) 

increment the iterator in it's current dimension by the given value.

MultiIterator operator- ( multi_difference_type const &  d  )  const

subtraction along all dimensions

MultiIterator operator- ( difference_type  n  )  const

subtraction within current dimension

difference_type operator- ( MultiIterator< N, T, REFERENCE, POINTER > const &  d  )  const

difference of two iterators in the current dimension. The result of this operation is undefined if the iterator doesn't point to element 0 in all dimensions below its current dimension.

MultiIterator operator-- ( int   ) 

postfix-decrement the iterator in it's current dimension

void operator-- (  ) 

prefix-decrement the iterator in it's current dimension

MultiIterator& operator-= ( multi_difference_type const &  d  ) 

decrement the iterator in all dimensions by the given offset.

MultiIterator& operator-= ( difference_type  n  ) 

decrement the iterator in it's current dimension by the given value.

pointer operator-> (  )  const

call method of current item

bool operator< ( const MultiIterator< N, T, REFERENCE, POINTER > &  rhs  )  const

less than.

bool operator<= ( const MultiIterator< N, T, REFERENCE, POINTER > &  rhs  )  const

less or equal.

bool operator== ( const MultiIterator< N, T, REFERENCE, POINTER > &  rhs  )  const

equality. True if iterators reference the same items.

bool operator> ( const MultiIterator< N, T, REFERENCE, POINTER > &  rhs  )  const

greater than.

bool operator>= ( const MultiIterator< N, T, REFERENCE, POINTER > &  rhs  )  const

greater or equal.

reference operator[] ( multi_difference_type const &  d  )  const

access the array element at the given offset.

reference operator[] ( difference_type  n  )  const

access the array element at the given offset in the current dimension.


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

© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de)
Heidelberg Collaboratory for Image Processing, University of Heidelberg, Germany

html generated using doxygen and Python
vigra 1.7.0 (20 Apr 2010)