37 #ifndef VIGRA_MULTI_ITERATOR_HXX 
   38 #define VIGRA_MULTI_ITERATOR_HXX 
   40 #include <sys/types.h> 
   41 #include "multi_fwd.hxx" 
   42 #include "iteratortags.hxx" 
   43 #include "multi_iterator_coupled.hxx" 
   86 template<
unsigned int N>
 
   87 class MultiCoordinateIterator
 
   88     : 
public CoupledScanOrderIterator<N>
 
   91     typedef CoupledScanOrderIterator<N>            base_type;
 
   93     typedef typename base_type::shape_type         shape_type;
 
   94     typedef typename base_type::difference_type    difference_type;
 
   95     typedef MultiCoordinateIterator                iterator;
 
   96     typedef std::random_access_iterator_tag        iterator_category;
 
   98     typedef typename base_type::value_type         handle_type;
 
   99     typedef typename handle_type::value_type       value_type;
 
  100     typedef typename handle_type::reference        reference;
 
  101     typedef typename handle_type::const_reference  const_reference;
 
  102     typedef typename handle_type::pointer          pointer;
 
  103     typedef typename handle_type::const_pointer    const_pointer;
 
  105     MultiCoordinateIterator()
 
  106         : base_type(handle_type())
 
  109     explicit MultiCoordinateIterator(shape_type 
const & shape)
 
  110         : base_type(handle_type(shape))
 
  113     explicit MultiCoordinateIterator(shape_type 
const & start, shape_type 
const & end)
 
  114         : base_type(handle_type(end))
 
  116         this->restrictToSubarray(start, end);
 
  119     template<
class DirectedTag>
 
  120     explicit MultiCoordinateIterator(GridGraph<N, DirectedTag> 
const & g)
 
  121        : base_type(handle_type(g.shape()))
 
  125     template<
class DirectedTag>
 
  126     explicit MultiCoordinateIterator(GridGraph<N, DirectedTag> 
const & g, 
const typename  GridGraph<N, DirectedTag>::Node & node)
 
  127        : base_type(handle_type(g.shape()))
 
  129         if( isInside(g,node))
 
  132             *
this=this->getEndIterator();
 
  139     reference operator*()
 
  141         return this->
template get<0>();
 
  144     const_reference operator*()
 const 
  146         return this->
template get<0>();
 
  149     operator value_type()
 const 
  156         return &this->
template get<0>();
 
  159     const_pointer operator->()
 const 
  161         return &this->
template get<0>();
 
  166         return *(MultiCoordinateIterator(*
this) += i);
 
  169     MultiCoordinateIterator & operator++()
 
  171         base_type::operator++();
 
  175     MultiCoordinateIterator operator++(
int)
 
  177         MultiCoordinateIterator res(*
this);
 
  184         base_type::operator+=(i);
 
  188     MultiCoordinateIterator & operator+=(
const shape_type &coordOffset)
 
  190         base_type::operator+=(coordOffset);
 
  194     MultiCoordinateIterator & operator--()
 
  196         base_type::operator--();
 
  200     MultiCoordinateIterator operator--(
int)
 
  202         MultiCoordinateIterator res(*
this);
 
  209         return operator+=(-i);
 
  212     MultiCoordinateIterator & operator-=(
const shape_type &coordOffset)
 
  214         return operator+=(-coordOffset);
 
  217     MultiCoordinateIterator getEndIterator()
 const 
  224         return MultiCoordinateIterator(*
this) += d;
 
  229         return MultiCoordinateIterator(*
this) -= d;
 
  232     MultiCoordinateIterator operator+(
const shape_type &coordOffset)
 const 
  234         return MultiCoordinateIterator(*
this) += coordOffset;
 
  237     MultiCoordinateIterator operator-(
const shape_type &coordOffset)
 const 
  239         return MultiCoordinateIterator(*
this) -= coordOffset;
 
  244         return base_type::operator-(other);
 
  248     MultiCoordinateIterator(base_type 
const & base)
 
  270 template <
unsigned int N, 
class V, 
class REFERENCE, 
class POINTER>
 
  271 class StridedScanOrderIterator
 
  272     : 
public CoupledIteratorType<N, V>::type
 
  275     typedef typename CoupledIteratorType<N, V>::type  base_type;
 
  276     typedef typename base_type::value_type            handle_type;
 
  278     typedef typename base_type::shape_type         shape_type;
 
  279     typedef typename base_type::difference_type    difference_type;
 
  280     typedef StridedScanOrderIterator               iterator;
 
  281     typedef std::random_access_iterator_tag        iterator_category;
 
  283     typedef typename detail::ResolveChunkedMemory<V>::type T;
 
  284     typedef T                                      value_type;
 
  285     typedef REFERENCE                              reference;
 
  286     typedef T 
const &                              const_reference;
 
  287     typedef POINTER                                pointer;
 
  288     typedef T 
const *                              const_pointer;
 
  290     StridedScanOrderIterator()
 
  295     explicit StridedScanOrderIterator(MultiArrayView<N, T, S> 
const & view)
 
  296         : base_type(createCoupledIterator(view))
 
  299     StridedScanOrderIterator(POINTER p, shape_type 
const & shape, shape_type 
const & strides)
 
  300         : base_type(createCoupledIterator(MultiArrayView<N, T, StridedArrayTag>(shape, strides, const_cast<T *>(p))))
 
  303     StridedScanOrderIterator(handle_type 
const & handle)
 
  307     reference operator*()
 
  309         return this->
template get<1>();
 
  312     const_reference operator*()
 const 
  314         return this->
template get<1>();
 
  319         return &this->
template get<1>();
 
  322     const_pointer operator->()
 const 
  324         return &this->
template get<1>();
 
  329         return *(StridedScanOrderIterator(*
this) += i);
 
  334         return *(StridedScanOrderIterator(*
this) += i);
 
  337     reference operator[](
const shape_type& coordOffset)
 
  339         return *(StridedScanOrderIterator(*
this) += coordOffset);
 
  342     const_reference operator[](
const shape_type& coordOffset)
 const 
  344         return *(StridedScanOrderIterator(*
this) += coordOffset);
 
  347     StridedScanOrderIterator & operator++()
 
  349         base_type::operator++();
 
  353     StridedScanOrderIterator operator++(
int)
 
  355         StridedScanOrderIterator res(*
this);
 
  366     StridedScanOrderIterator & 
operator+=(
const shape_type &coordOffset)
 
  372     StridedScanOrderIterator & operator--()
 
  374         base_type::operator--();
 
  378     StridedScanOrderIterator operator--(
int)
 
  380         StridedScanOrderIterator res(*
this);
 
  390     StridedScanOrderIterator & 
operator-=(
const shape_type &coordOffset)
 
  395     StridedScanOrderIterator getEndIterator()
 const 
  397         return StridedScanOrderIterator(base_type::getEndIterator());
 
  402         return StridedScanOrderIterator(*
this) += d;
 
  407         return StridedScanOrderIterator(*
this) -= d;
 
  415     StridedScanOrderIterator 
operator+(
const shape_type &coordOffset)
 const 
  417         return StridedScanOrderIterator(*
this) += coordOffset;
 
  420     StridedScanOrderIterator 
operator-(
const shape_type &coordOffset)
 const 
  422         return StridedScanOrderIterator(*
this) -= coordOffset;
 
  427         return this->scanOrderIndex();
 
  430     StridedScanOrderIterator &
 
  431     restrictToSubarray(shape_type 
const & start, shape_type 
const & stop)
 
  433         base_type::restrictToSubarray(start, stop);
 
  438     StridedScanOrderIterator(base_type 
const & base)
 
  734 template <
class POINTER>
 
  735 struct MultiIteratorStrideTraits
 
  738     typedef const stride_type* stride_array_type;
 
  739     typedef stride_array_type  shape_array_type;
 
  740     static stride_array_type shift(stride_array_type s, 
unsigned d)
 
  759 template <
class T, 
class REFERENCE, 
class POINTER>
 
  760 class MultiIterator<1, T, REFERENCE, POINTER>
 
  764     typedef T value_type;
 
  765     typedef REFERENCE reference;
 
  766     typedef const value_type &const_reference;
 
  767     typedef POINTER pointer;
 
  768     typedef const value_type *const_pointer;
 
  769     typedef typename MultiArrayShape<1>::type multi_difference_type;
 
  770     typedef MultiIteratorStrideTraits<POINTER> stride_traits;
 
  771     typedef typename stride_traits::stride_type difference_type;
 
  772     typedef typename stride_traits::stride_array_type difference_array_type;
 
  773     typedef typename stride_traits::shape_array_type shape_array_type;
 
  774     typedef StridedMultiIterator<1, T, REFERENCE, POINTER> iterator;
 
  775     typedef std::random_access_iterator_tag iterator_category;
 
  785     MultiIterator (pointer ptr,
 
  786           const difference_array_type &,
 
  787           const shape_array_type &)
 
  801     MultiIterator operator++ (
int)
 
  803         MultiIterator ret = *
this;
 
  808     MultiIterator operator-- (
int)
 
  810         MultiIterator ret = *
this;
 
  821     MultiIterator & 
operator+= (multi_difference_type 
const & d)
 
  833     MultiIterator & 
operator-= (multi_difference_type 
const & d)
 
  839     MultiIterator 
operator+ (difference_type n)
 const 
  841         MultiIterator ret = *
this;
 
  846     MultiIterator 
operator+ (multi_difference_type 
const & d)
 const 
  848         MultiIterator ret = *
this;
 
  853     difference_type 
operator- (MultiIterator 
const & d)
 const 
  855         return (m_ptr - d.m_ptr);
 
  858     MultiIterator 
operator- (difference_type n)
 const 
  860         MultiIterator ret = *
this;
 
  865     MultiIterator 
operator- (multi_difference_type 
const & d)
 const 
  867         MultiIterator ret = *
this;
 
  872     reference operator[] (difference_type n)
 const 
  877     reference operator[] (multi_difference_type 
const & d)
 const 
  879         return m_ptr [d[level]];
 
  882     reference operator* ()
 const 
  892     pointer operator->()
 const 
  894         return &(operator*());
 
  897     bool operator!= (
const MultiIterator &rhs)
 const 
  899         return m_ptr != rhs.m_ptr;
 
  902     bool operator== (
const MultiIterator &rhs)
 const 
  904         return m_ptr == rhs.m_ptr;
 
  907     bool operator< (
const MultiIterator &rhs)
 const 
  909         return m_ptr < rhs.m_ptr;
 
  912     bool operator<= (
const MultiIterator &rhs)
 const 
  914         return m_ptr <= rhs.m_ptr;
 
  917     bool operator> (
const MultiIterator &rhs)
 const 
  919         return m_ptr > rhs.m_ptr;
 
  922     bool operator>= (
const MultiIterator &rhs)
 const 
  924         return m_ptr >= rhs.m_ptr;
 
  927     iterator iteratorForDimension(
unsigned int d)
 const 
  929         vigra_precondition(d == 0,
 
  930             "MultiIterator<1>::iteratorForDimension(d): d == 0 required");
 
  931         const difference_type stride = 1;
 
  932         return iterator(m_ptr, &stride, 0);
 
  935     template <
unsigned int K>
 
  936     MultiIterator<K+1, T, REFERENCE, POINTER> &
 
  942     MultiIterator<1, T, REFERENCE, POINTER> &
 
  943     dim0() { 
return *
this; }
 
  948     total_stride(
typename multi_difference_type::const_iterator d)
 const 
  961 template <
class T, 
class REFERENCE, 
class POINTER>
 
  962 class MultiIterator<2, T, REFERENCE, POINTER>
 
  964 : 
public MultiIterator<1, T, REFERENCE, POINTER>
 
  969     typedef MultiIterator<1, T, REFERENCE, POINTER> 
base_type;
 
  977     typedef MultiIteratorStrideTraits<POINTER> stride_traits;
 
  979     typedef typename stride_traits::stride_array_type difference_array_type;
 
  980     typedef typename stride_traits::shape_array_type shape_array_type;
 
  982     typedef StridedMultiIterator<1, T, REFERENCE, POINTER> 
iterator;
 
  986     difference_array_type m_stride;
 
  987     shape_array_type      m_shape;
 
  994           m_stride (0), m_shape (0)
 
  998           const difference_array_type & stride,
 
  999           const shape_array_type & shape)
 
 1000         : base_type (ptr, stride, shape),
 
 1001           m_stride (stride), m_shape (shape)
 
 1006         this->m_ptr += m_stride [level];
 
 1011         this->m_ptr -= m_stride [level];
 
 1030         this->m_ptr += n * m_stride [level];
 
 1036         this->m_ptr += total_stride(d.begin());
 
 1042         this->m_ptr -= n * m_stride [level];
 
 1048         this->m_ptr -= total_stride(d.begin());
 
 1068         return (this->m_ptr - d.m_ptr) / this->m_stride[level];
 
 1085     reference 
operator[] (difference_type n)
 const 
 1087         return this->m_ptr [n*m_stride [level]];
 
 1090     reference 
operator[] (multi_difference_type 
const & d)
 const 
 1092         return this->m_ptr [total_stride(d.begin())];
 
 1103         ret += m_shape [level-1];
 
 1109         vigra_precondition(d <= level,
 
 1110             "MultiIterator<N>::iteratorForDimension(d): d < N required");
 
 1111         return iterator(this->m_ptr, stride_traits::shift(m_stride, d), 0);
 
 1114     template <
unsigned int K>
 
 1115     MultiIterator<K+1, T, REFERENCE, POINTER> &
 
 1121     MultiIterator<1, T, REFERENCE, POINTER> &
 
 1122     dim0() { 
return *
this; }
 
 1123     MultiIterator<2, T, REFERENCE, POINTER> &
 
 1124     dim1() { 
return *
this; }
 
 1129     total_stride(
typename multi_difference_type::const_iterator d)
 const 
 1131         return d[level]*m_stride[level] + base_type::total_stride(d);
 
 1149 template <
unsigned int N, 
class T, 
class REFERENCE, 
class POINTER>
 
 1152 : 
public MultiIterator<N-1, T, REFERENCE, POINTER>
 
 1163     enum { level = N-1 };
 
 1193     typedef MultiIteratorStrideTraits<POINTER> stride_traits;
 
 1195     typedef typename stride_traits::stride_array_type difference_array_type;
 
 1196     typedef typename stride_traits::shape_array_type shape_array_type;
 
 1225                    const difference_array_type & stride,
 
 1226                    const shape_array_type & shape)
 
 1227         : base_type (ptr, stride, shape)
 
 1235         this->m_ptr += this->m_stride [level];
 
 1242         this->m_ptr -= this->m_stride [level];
 
 1268         this->m_ptr += n * this->m_stride [level];
 
 1277         this->m_ptr += total_stride(d.
begin());
 
 1286         this->m_ptr -= n * this->m_stride [level];
 
 1295         this->m_ptr -= total_stride(d.
begin());
 
 1323         return (this->m_ptr - d.m_ptr) / this->m_stride[level];
 
 1351     pointer 
get () 
const;
 
 1387         return this->m_ptr [n* this->m_stride [level]];
 
 1394         return this->m_ptr [total_stride(d.
begin())];
 
 1430         ret += this->m_shape [level-1];
 
 1452         vigra_precondition(d <= level,
 
 1453             "MultiIterator<N>::iteratorForDimension(d): d < N required");
 
 1454         return iterator(this->m_ptr, stride_traits::shift(this->m_stride, d),0);
 
 1478     template <
unsigned int K>
 
 1486     dim0() { 
return *
this; }
 
 1487     MultiIterator<2, T, REFERENCE, POINTER> &
 
 1488     dim1() { 
return *
this; }
 
 1489     MultiIterator<3, T, REFERENCE, POINTER> &
 
 1490     dim2() { 
return *
this; }
 
 1491     MultiIterator<4, T, REFERENCE, POINTER> &
 
 1492     dim3() { 
return *
this; }
 
 1493     MultiIterator<5, T, REFERENCE, POINTER> &
 
 1494     dim4() { 
return *
this; }
 
 1499     total_stride(
typename multi_difference_type::const_iterator d)
 const 
 1501         return d[level]*this->m_stride[level] + base_type::total_stride(d);
 
 1519 template <
class T, 
class REFERENCE, 
class POINTER>
 
 1520 class StridedMultiIterator<1, T, REFERENCE, POINTER>
 
 1530     typedef MultiIteratorStrideTraits<POINTER> stride_traits;
 
 1532     typedef typename stride_traits::stride_array_type difference_array_type;
 
 1533     typedef typename stride_traits::shape_array_type shape_array_type;
 
 1534     typedef StridedMultiIterator<1, T, REFERENCE, POINTER> 
iterator;
 
 1539     difference_type m_stride;
 
 1545         : m_ptr (0), m_stride (0)
 
 1549           const difference_array_type & stride,
 
 1550           const shape_array_type &)
 
 1551         : m_ptr (ptr), m_stride (stride [level])
 
 1580         m_ptr += n * m_stride;
 
 1586         m_ptr += d[level] * m_stride;
 
 1592         m_ptr -= n * m_stride;
 
 1598         m_ptr -= d[level] * m_stride;
 
 1618         return (m_ptr - d.m_ptr) / m_stride;
 
 1635     reference 
operator[] (difference_type n)
 const 
 1637         return m_ptr [n*m_stride];
 
 1640     reference 
operator[] (multi_difference_type 
const & d)
 const 
 1642         return m_ptr [d[level]*m_stride];
 
 1650     pointer 
get () 
const 
 1662         return m_ptr != rhs.m_ptr;
 
 1667         return m_ptr == rhs.m_ptr;
 
 1672         return m_ptr < rhs.m_ptr;
 
 1677         return m_ptr <= rhs.m_ptr;
 
 1682         return m_ptr > rhs.m_ptr;
 
 1687         return m_ptr >= rhs.m_ptr;
 
 1692         vigra_precondition(d == 0,
 
 1693             "StridedMultiIterator<1>::iteratorForDimension(d): d == 0 required");
 
 1694         const difference_type stride = 1;
 
 1695         return iterator(m_ptr, &stride, 0);
 
 1698     template <
unsigned int K>
 
 1699     StridedMultiIterator<K+1, T, REFERENCE, POINTER> &
 
 1705     StridedMultiIterator<1, T, REFERENCE, POINTER> &
 
 1706     dim0() { 
return *
this; }
 
 1711     total_stride(
typename multi_difference_type::const_iterator d)
 const 
 1713         return d[level] * m_stride;
 
 1724 template <
class T, 
class REFERENCE, 
class POINTER>
 
 1725 class StridedMultiIterator<2, T, REFERENCE, POINTER>
 
 1727 : 
public StridedMultiIterator<1, T, REFERENCE, POINTER>
 
 1732     typedef StridedMultiIterator<1, T, REFERENCE, POINTER> 
base_type;
 
 1740     typedef MultiIteratorStrideTraits<POINTER> stride_traits;
 
 1742     typedef typename stride_traits::stride_array_type difference_array_type;
 
 1743     typedef typename stride_traits::shape_array_type shape_array_type;
 
 1745     typedef StridedMultiIterator<1, T, REFERENCE, POINTER> 
iterator;
 
 1749     difference_array_type m_stride;
 
 1750     shape_array_type m_shape;
 
 1757           m_stride (0), m_shape (0)
 
 1761           const difference_array_type & stride,
 
 1762           const shape_array_type & shape)
 
 1763         : base_type (ptr, stride, shape),
 
 1764           m_stride (stride), m_shape (shape)
 
 1769         this->m_ptr += m_stride [level];
 
 1774         this->m_ptr -= m_stride [level];
 
 1793         this->m_ptr += n * m_stride [level];
 
 1799         this->m_ptr += total_stride(d.begin());
 
 1805         this->m_ptr -= n * m_stride [level];
 
 1811         this->m_ptr -= total_stride(d.begin());
 
 1831         return (this->m_ptr - d.m_ptr) / this->m_stride[level];
 
 1848     reference 
operator[] (difference_type n)
 const 
 1850         return this->m_ptr [n*m_stride [level]];
 
 1853     reference 
operator[] (multi_difference_type 
const & d)
 const 
 1855         return this->m_ptr [total_stride(d.begin())];
 
 1866         ret += m_shape [level-1];
 
 1872         vigra_precondition(d <= level,
 
 1873             "StridedMultiIterator<N>::iteratorForDimension(d): d < N required");
 
 1874         return iterator(this->m_ptr, stride_traits::shift(m_stride, d), 0);
 
 1877     template <
unsigned int K>
 
 1878     StridedMultiIterator<K+1, T, REFERENCE, POINTER> &
 
 1884     StridedMultiIterator<1, T, REFERENCE, POINTER> &
 
 1885     dim0() { 
return *
this; }
 
 1886     StridedMultiIterator<2, T, REFERENCE, POINTER> &
 
 1887     dim1() { 
return *
this; }
 
 1892     total_stride(
typename multi_difference_type::const_iterator d)
 const 
 1894         return d[level]*m_stride[level] + base_type::total_stride(d);
 
 1912 template <
unsigned int N, 
class T, 
class REFERENCE, 
class POINTER>
 
 1913 class StridedMultiIterator
 
 1915 : 
public StridedMultiIterator<N-1, T, REFERENCE, POINTER>
 
 1926     enum { level = N-1 };
 
 1956     typedef MultiIteratorStrideTraits<POINTER> stride_traits;
 
 1958     typedef typename stride_traits::stride_array_type difference_array_type;
 
 1987                    const difference_array_type & stride,
 
 1988                    const difference_array_type & shape)
 
 1989         : base_type (ptr, stride, shape)
 
 1997         this->m_ptr += this->m_stride [level];
 
 2004         this->m_ptr -= this->m_stride [level];
 
 2030         this->m_ptr += n * this->m_stride [level];
 
 2039         this->m_ptr += total_stride(d.
begin());
 
 2048         this->m_ptr -= n * this->m_stride [level];
 
 2057         this->m_ptr -= total_stride(d.
begin());
 
 2085         return (this->m_ptr - d.m_ptr) / this->m_stride[level];
 
 2113     pointer 
get () 
const;
 
 2149         return this->m_ptr [n* this->m_stride [level]];
 
 2156         return this->m_ptr [total_stride(d.
begin())];
 
 2192         ret += this->m_shape [level-1];
 
 2214         vigra_precondition(d <= level,
 
 2215             "StridedMultiIterator<N>::iteratorForDimension(d): d < N required");
 
 2216         return iterator(this->m_ptr, stride_traits::shift(this->m_stride, d),0);
 
 2240     template <
unsigned int K>
 
 2248     dim0() { 
return *
this; }
 
 2249     StridedMultiIterator<2, T, REFERENCE, POINTER> &
 
 2250     dim1() { 
return *
this; }
 
 2251     StridedMultiIterator<3, T, REFERENCE, POINTER> &
 
 2252     dim2() { 
return *
this; }
 
 2253     StridedMultiIterator<4, T, REFERENCE, POINTER> &
 
 2254     dim3() { 
return *
this; }
 
 2255     StridedMultiIterator<5, T, REFERENCE, POINTER> &
 
 2256     dim4() { 
return *
this; }
 
 2261     total_stride(
typename multi_difference_type::const_iterator d)
 const 
 2263         return d[level]*this->m_stride[level] + base_type::total_stride(d);
 
 2276 template <
unsigned int N, 
class T, 
class REFERENCE, 
class POINTER>
 
 2277 ostream & operator<<(ostream & o, vigra::StridedScanOrderIterator<N, T, REFERENCE, POINTER> 
const & i)
 
 2285 #endif // VIGRA_MULTI_ITERATOR_HXX 
StridedMultiIterator< 1, T, REFERENCE, POINTER > iterator
Definition: multi_iterator.hxx:1208
reference operator*() const 
reference operator[](difference_type n) const 
Definition: multi_iterator.hxx:2147
bool operator<(const MultiIterator &rhs) const 
POINTER pointer
Definition: multi_iterator.hxx:1942
Diff2D operator-(Diff2D const &a, Diff2D const &b)
Definition: diff2d.hxx:711
StridedMultiIterator()
Definition: multi_iterator.hxx:1980
next_type end() const 
Definition: multi_iterator.hxx:2189
A multi-dimensional hierarchical iterator to be used with vigra::MultiArrayView if it is not strided...
Definition: multi_fwd.hxx:148
pointer operator->() const 
StridedMultiIterator & operator+=(difference_type n)
Definition: multi_iterator.hxx:2028
MultiIterator operator+(difference_type n) const 
Definition: multi_iterator.hxx:1301
bool operator>(const StridedMultiIterator &rhs) const 
bool operator>=(const StridedMultiIterator &rhs) const 
MultiIterator & operator-=(difference_type n)
Definition: multi_iterator.hxx:1284
const value_type & const_reference
Definition: multi_iterator.hxx:1938
multi_dimensional_traverser_tag iterator_category
Definition: multi_iterator.hxx:1974
Diff2D operator+(Diff2D const &a, Diff2D const &b)
Definition: diff2d.hxx:739
POINTER pointer
Definition: multi_iterator.hxx:1179
StridedMultiIterator< K+1, T, REFERENCE, POINTER > & dim()
Definition: multi_iterator.hxx:2242
std::ptrdiff_t MultiArrayIndex
Definition: multi_fwd.hxx:60
StridedMultiIterator & operator-=(difference_type n)
Definition: multi_iterator.hxx:2046
bool operator<=(const MultiIterator &rhs) const 
MultiIterator< N-1, T, REFERENCE, POINTER > base_type
Definition: multi_iterator.hxx:1159
FFTWComplex< R > & operator-=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
subtract-assignment 
Definition: fftw3.hxx:867
iterator iteratorForDimension(unsigned int d) const 
Definition: multi_iterator.hxx:1450
void operator++()
Definition: multi_iterator.hxx:1995
StridedMultiIterator(pointer ptr, const difference_array_type &stride, const difference_array_type &shape)
Definition: multi_iterator.hxx:1986
MultiArrayIndex difference_type
Definition: multi_iterator.hxx:1960
REFERENCE reference
Definition: multi_iterator.hxx:1934
base_type next_type
Definition: multi_iterator.hxx:1965
bool operator<=(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
less or equal 
Definition: fixedpoint.hxx:521
MultiIterator(pointer ptr, const difference_array_type &stride, const shape_array_type &shape)
Definition: multi_iterator.hxx:1224
REFERENCE reference
Definition: multi_iterator.hxx:1171
FFTWComplex< R > & operator+=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
add-assignment 
Definition: fftw3.hxx:859
StridedMultiIterator operator+(difference_type n) const 
Definition: multi_iterator.hxx:2063
MultiIterator()
Definition: multi_iterator.hxx:1218
T value_type
Definition: multi_iterator.hxx:1167
next_type begin() const 
Definition: multi_iterator.hxx:2177
MultiIterator< K+1, T, REFERENCE, POINTER > & dim()
Definition: multi_iterator.hxx:1480
StridedMultiIterator< 1, T, REFERENCE, POINTER > iterator
Definition: multi_iterator.hxx:1970
bool operator!=(FFTWComplex< R > const &a, const FFTWComplex< R > &b)
not equal 
Definition: fftw3.hxx:841
MultiArrayIndex difference_type
Definition: multi_iterator.hxx:1198
CoupledScanOrderIterator getEndIterator() const
Definition: multi_iterator_coupled.hxx:282
iterator begin()
Definition: tinyvector.hxx:861
bool operator==(FFTWComplex< R > const &a, const FFTWComplex< R > &b)
equal 
Definition: fftw3.hxx:825
MultiIterator & operator+=(difference_type n)
Definition: multi_iterator.hxx:1266
bool operator<=(const StridedMultiIterator &rhs) const 
TinyVector< MultiArrayIndex, N > type
Definition: multi_shape.hxx:272
bool operator!=(const MultiIterator &rhs) const 
difference_type operator-(MultiIterator const &d) const 
Definition: multi_iterator.hxx:1321
A multi-dimensional hierarchical iterator to be used with vigra::MultiArrayView if it is not strided...
Definition: multi_fwd.hxx:153
Class for fixed size vectors.This class contains an array of size SIZE of the specified VALUETYPE...
Definition: accessor.hxx:940
const value_type & const_reference
Definition: multi_iterator.hxx:1175
bool operator>=(const MultiIterator &rhs) const 
bool operator==(const MultiIterator &rhs) const 
const value_type * const_pointer
Definition: multi_iterator.hxx:1183
bool operator<(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
less than 
Definition: fixedpoint.hxx:512
void operator--()
Definition: multi_iterator.hxx:1240
bool operator>=(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
greater or equal 
Definition: fixedpoint.hxx:539
multi_dimensional_traverser_tag iterator_category
Definition: multi_iterator.hxx:1212
void operator--()
Definition: multi_iterator.hxx:2002
iterator iteratorForDimension(unsigned int d) const 
Definition: multi_iterator.hxx:2212
StridedMultiIterator< N-1, T, REFERENCE, POINTER > base_type
Definition: multi_iterator.hxx:1922
pointer operator->() const 
void operator++()
Definition: multi_iterator.hxx:1233
bool operator==(const StridedMultiIterator &rhs) const 
reference operator[](difference_type n) const 
Definition: multi_iterator.hxx:1385
next_type end() const 
Definition: multi_iterator.hxx:1427
bool operator>(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
greater 
Definition: fixedpoint.hxx:530
MultiArrayShape< N >::type multi_difference_type
Definition: multi_iterator.hxx:1188
bool operator>(const MultiIterator &rhs) const 
T value_type
Definition: multi_iterator.hxx:1930
next_type begin() const 
Definition: multi_iterator.hxx:1415
bool operator<(const StridedMultiIterator &rhs) const 
bool operator!=(const StridedMultiIterator &rhs) const 
MultiArrayShape< N >::type multi_difference_type
Definition: multi_iterator.hxx:1951
base_type next_type
Definition: multi_iterator.hxx:1203
reference operator*() const 
difference_type operator-(StridedMultiIterator const &d) const 
Definition: multi_iterator.hxx:2083
const value_type * const_pointer
Definition: multi_iterator.hxx:1946