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>
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);
362 base_type::operator+=(i);
366 StridedScanOrderIterator & operator+=(
const shape_type &coordOffset)
368 base_type::operator+=(coordOffset);
372 StridedScanOrderIterator & operator--()
374 base_type::operator--();
378 StridedScanOrderIterator operator--(
int)
380 StridedScanOrderIterator res(*
this);
387 return operator+=(-i);
390 StridedScanOrderIterator & operator-=(
const shape_type &coordOffset)
392 return operator+=(-coordOffset);
395 StridedScanOrderIterator getEndIterator()
const 402 return StridedScanOrderIterator(*
this) += d;
407 return StridedScanOrderIterator(*
this) -= d;
410 MultiArrayIndex operator-(StridedScanOrderIterator
const & other)
const 412 return base_type::operator-(other);
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;
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;
815 MultiIterator &operator+= (difference_type n)
821 MultiIterator & operator+= (multi_difference_type
const & d)
827 MultiIterator &operator-= (difference_type n)
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;
971 typedef T value_type;
972 typedef REFERENCE reference;
973 typedef const value_type &const_reference;
974 typedef POINTER pointer;
975 typedef const value_type *const_pointer;
977 typedef MultiIteratorStrideTraits<POINTER> stride_traits;
978 typedef typename stride_traits::stride_type difference_type;
979 typedef typename stride_traits::stride_array_type difference_array_type;
980 typedef typename stride_traits::shape_array_type shape_array_type;
981 typedef base_type next_type;
982 typedef StridedMultiIterator<1, T, REFERENCE, POINTER> iterator;
983 typedef multi_dimensional_traverser_tag iterator_category;
986 difference_array_type m_stride;
987 shape_array_type m_shape;
994 m_stride (0), m_shape (0)
997 MultiIterator (pointer ptr,
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];
1014 MultiIterator operator++ (
int)
1016 MultiIterator ret = *
this;
1021 MultiIterator operator-- (
int)
1023 MultiIterator ret = *
this;
1028 MultiIterator & operator+= (difference_type n)
1030 this->m_ptr += n * m_stride [level];
1034 MultiIterator & operator+= (multi_difference_type
const & d)
1036 this->m_ptr += total_stride(d.begin());
1040 MultiIterator &operator-= (difference_type n)
1042 this->m_ptr -= n * m_stride [level];
1046 MultiIterator & operator-= (multi_difference_type
const & d)
1048 this->m_ptr -= total_stride(d.begin());
1052 MultiIterator operator+ (difference_type n)
const 1054 MultiIterator ret = *
this;
1059 MultiIterator operator+ (multi_difference_type
const & d)
const 1061 MultiIterator ret = *
this;
1066 difference_type operator- (MultiIterator
const & d)
const 1068 return (this->m_ptr - d.m_ptr) / this->m_stride[level];
1071 MultiIterator operator- (difference_type n)
const 1073 MultiIterator ret = *
this;
1078 MultiIterator operator- (multi_difference_type
const & d)
const 1080 MultiIterator ret = *
this;
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())];
1095 next_type begin ()
const 1100 next_type end ()
const 1102 next_type ret = *
this;
1103 ret += m_shape [level-1];
1107 iterator iteratorForDimension(
unsigned int d)
const 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;
1194 typedef typename stride_traits::stride_type difference_type;
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];
1347 reference operator* ()
const;
1351 pointer
get ()
const;
1355 pointer operator->()
const;
1385 reference operator[] (difference_type n)
const 1387 return this->m_ptr [n* this->m_stride [level]];
1392 reference operator[] (multi_difference_type
const & d)
const 1394 return this->m_ptr [total_stride(d.
begin())];
1429 next_type ret = *
this;
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; }
1488 dim1() {
return *
this; }
1490 dim2() {
return *
this; }
1492 dim3() {
return *
this; }
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>
1524 typedef T value_type;
1525 typedef REFERENCE reference;
1526 typedef const value_type &const_reference;
1527 typedef POINTER pointer;
1528 typedef const value_type *const_pointer;
1530 typedef MultiIteratorStrideTraits<POINTER> stride_traits;
1531 typedef typename stride_traits::stride_type difference_type;
1532 typedef typename stride_traits::stride_array_type difference_array_type;
1533 typedef typename stride_traits::shape_array_type shape_array_type;
1535 typedef std::random_access_iterator_tag iterator_category;
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];
1645 reference operator* ()
const 1650 pointer
get ()
const 1655 pointer operator->()
const 1657 return &(operator*());
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;
1690 iterator iteratorForDimension(
unsigned int d)
const 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>
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>
1734 typedef T value_type;
1735 typedef REFERENCE reference;
1736 typedef const value_type &const_reference;
1737 typedef POINTER pointer;
1738 typedef const value_type *const_pointer;
1740 typedef MultiIteratorStrideTraits<POINTER> stride_traits;
1741 typedef typename stride_traits::stride_type difference_type;
1742 typedef typename stride_traits::stride_array_type difference_array_type;
1743 typedef typename stride_traits::shape_array_type shape_array_type;
1744 typedef base_type next_type;
1746 typedef multi_dimensional_traverser_tag iterator_category;
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())];
1858 next_type begin ()
const 1863 next_type end ()
const 1865 next_type ret = *
this;
1866 ret += m_shape [level-1];
1870 iterator iteratorForDimension(
unsigned int d)
const 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>
1885 dim0() {
return *
this; }
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>
1926 enum { level = N-1 };
1956 typedef MultiIteratorStrideTraits<POINTER> stride_traits;
1957 typedef typename stride_traits::stride_type difference_type;
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];
2109 reference operator* ()
const;
2113 pointer
get ()
const;
2117 pointer operator->()
const;
2147 reference operator[] (difference_type n)
const 2149 return this->m_ptr [n* this->m_stride [level]];
2154 reference operator[] (multi_difference_type
const & d)
const 2156 return this->m_ptr [total_stride(d.
begin())];
2191 next_type ret = *
this;
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; }
2250 dim1() {
return *
this; }
2252 dim2() {
return *
this; }
2254 dim3() {
return *
this; }
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);
2274 template <
unsigned int N,
class T,
class REFERENCE,
class POINTER>
2275 ostream & operator<<(ostream & o, vigra::StridedScanOrderIterator<N, T, REFERENCE, POINTER>
const & i)
2283 #endif // VIGRA_MULTI_ITERATOR_HXX vertex_descriptor Node
The Node descriptor (API: LEMON).
Definition: multi_gridgraph.hxx:1563
StridedMultiIterator< 1, T, REFERENCE, POINTER > iterator
Definition: multi_iterator.hxx:1208
POINTER pointer
Definition: multi_iterator.hxx:1942
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
const value_type & const_reference
Definition: multi_iterator.hxx:1938
Definition: array_vector.hxx:954
multi_dimensional_traverser_tag iterator_category
Definition: multi_iterator.hxx:1974
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
Definition: accessor.hxx:43
MultiIterator< N-1, T, REFERENCE, POINTER > base_type
Definition: multi_iterator.hxx:1159
iterator iteratorForDimension(unsigned int d) const
Definition: multi_iterator.hxx:1450
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
Definition: multi_fwd.hxx:63
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
TinyVector< MultiArrayIndex, N > type
Definition: multi_shape.hxx:250
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
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
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
iterator iteratorForDimension(unsigned int d) const
Definition: multi_iterator.hxx:2212
StridedMultiIterator< N-1, T, REFERENCE, POINTER > base_type
Definition: multi_iterator.hxx:1922
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
T value_type
Definition: multi_iterator.hxx:1930
next_type begin() const
Definition: multi_iterator.hxx:1415
MultiArrayShape< N >::type multi_difference_type
Definition: multi_iterator.hxx:1951
base_type next_type
Definition: multi_iterator.hxx:1203
const value_type * const_pointer
Definition: multi_iterator.hxx:1946