37#ifndef VIGRA_MULTI_ITERATOR_HXX
38#define VIGRA_MULTI_ITERATOR_HXX
41#include "multi_fwd.hxx"
42#include "iteratortags.hxx"
43#include "multi_iterator_coupled.hxx"
86template<
unsigned int N>
93 typedef typename base_type::shape_type shape_type;
94 typedef typename base_type::difference_type difference_type;
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;
116 this->restrictToSubarray(start, end);
119 template<
class DirectedTag>
125 template<
class DirectedTag>
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>();
171 base_type::operator++();
184 base_type::operator+=(
i);
196 base_type::operator--();
209 return operator+=(-
i);
244 return base_type::operator-(other);
270template <
unsigned int N,
class V,
class REFERENCE,
class POINTER>
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;
281 typedef std::random_access_iterator_tag iterator_category;
283 typedef typename detail::ResolveChunkedMemory<V>::type T;
284 typedef T value_type;
309 return this->
template get<1>();
314 return this->
template get<1>();
319 return &this->
template get<1>();
324 return &this->
template get<1>();
349 base_type::operator++();
362 base_type::operator+=(
i);
374 base_type::operator--();
412 return base_type::operator-(other);
427 return this->scanOrderIndex();
431 restrictToSubarray(shape_type
const & start, shape_type
const & stop)
433 base_type::restrictToSubarray(start, stop);
734template <
class POINTER>
735struct 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)
759template <
class T,
class REFERENCE,
class POINTER>
760class 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;
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
961template <
class T,
class REFERENCE,
class POINTER>
962class 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)
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];
1087 return this->m_ptr [n*m_stride [level]];
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);
1149template <
unsigned int N,
class T,
class REFERENCE,
class POINTER>
1163 enum { level = N-1 };
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)
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];
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);
1519template <
class T,
class REFERENCE,
class POINTER>
1520class 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;
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;
1637 return m_ptr [n*m_stride];
1642 return m_ptr [d[level]*m_stride];
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");
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;
1724template <
class T,
class REFERENCE,
class POINTER>
1725class 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)
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];
1850 return this->m_ptr [n*m_stride [level]];
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);
1912template <
unsigned int N,
class T,
class REFERENCE,
class POINTER>
1926 enum { level = N-1 };
1958 typedef typename stride_traits::stride_array_type difference_array_type;
1987 const difference_array_type & stride,
1988 const difference_array_type & 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];
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);
2276template <
unsigned int N,
class T,
class REFERENCE,
class POINTER>
Iterate over multiple images simultaneously in scan order.
Definition multi_iterator_coupled.hxx:196
CoupledScanOrderIterator getEndIterator() const
Definition multi_iterator_coupled.hxx:282
TinyVector< MultiArrayIndex, N > type
Definition multi_shape.hxx:272
Iterate over a virtual array where each element contains its coordinate.
Definition multi_iterator.hxx:89
A multi-dimensional hierarchical iterator to be used with vigra::MultiArrayView if it is not strided.
Definition multi_iterator.hxx:1154
void operator++()
Definition multi_iterator.hxx:1233
const value_type * const_pointer
Definition multi_iterator.hxx:1183
multi_dimensional_traverser_tag iterator_category
Definition multi_iterator.hxx:1212
iterator iteratorForDimension(unsigned int d) const
Definition multi_iterator.hxx:1450
bool operator>(const MultiIterator &rhs) const
MultiIterator operator+(difference_type n) const
Definition multi_iterator.hxx:1301
T value_type
Definition multi_iterator.hxx:1167
StridedMultiIterator< 1, T, REFERENCE, POINTER > iterator
Definition multi_iterator.hxx:1208
MultiIterator< N-1, T, REFERENCE, POINTER > base_type
Definition multi_iterator.hxx:1159
bool operator>=(const MultiIterator &rhs) const
bool operator==(const MultiIterator &rhs) const
base_type next_type
Definition multi_iterator.hxx:1203
void operator--()
Definition multi_iterator.hxx:1240
MultiIterator(pointer ptr, const difference_array_type &stride, const shape_array_type &shape)
Definition multi_iterator.hxx:1224
reference operator[](difference_type n) const
Definition multi_iterator.hxx:1385
MultiIterator & operator-=(difference_type n)
Definition multi_iterator.hxx:1284
next_type end() const
Definition multi_iterator.hxx:1427
MultiIterator & operator+=(difference_type n)
Definition multi_iterator.hxx:1266
bool operator<=(const MultiIterator &rhs) const
MultiIterator()
Definition multi_iterator.hxx:1218
REFERENCE reference
Definition multi_iterator.hxx:1171
difference_type operator-(MultiIterator const &d) const
Definition multi_iterator.hxx:1321
reference operator*() const
bool operator<(const MultiIterator &rhs) const
bool operator!=(const MultiIterator &rhs) const
MultiArrayIndex difference_type
Definition multi_iterator.hxx:1198
MultiArrayShape< N >::type multi_difference_type
Definition multi_iterator.hxx:1188
MultiIterator< K+1, T, REFERENCE, POINTER > & dim()
Definition multi_iterator.hxx:1480
pointer operator->() const
next_type begin() const
Definition multi_iterator.hxx:1415
const value_type & const_reference
Definition multi_iterator.hxx:1175
POINTER pointer
Definition multi_iterator.hxx:1179
Class for a single RGB value.
Definition rgbvalue.hxx:128
A multi-dimensional hierarchical iterator to be used with vigra::MultiArrayView if it is not strided.
Definition multi_iterator.hxx:1917
void operator++()
Definition multi_iterator.hxx:1995
const value_type * const_pointer
Definition multi_iterator.hxx:1946
multi_dimensional_traverser_tag iterator_category
Definition multi_iterator.hxx:1974
iterator iteratorForDimension(unsigned int d) const
Definition multi_iterator.hxx:2212
bool operator>=(const StridedMultiIterator &rhs) const
StridedMultiIterator & operator-=(difference_type n)
Definition multi_iterator.hxx:2046
bool operator!=(const StridedMultiIterator &rhs) const
T value_type
Definition multi_iterator.hxx:1930
StridedMultiIterator< 1, T, REFERENCE, POINTER > iterator
Definition multi_iterator.hxx:1970
StridedMultiIterator operator+(difference_type n) const
Definition multi_iterator.hxx:2063
difference_type operator-(StridedMultiIterator const &d) const
Definition multi_iterator.hxx:2083
base_type next_type
Definition multi_iterator.hxx:1965
void operator--()
Definition multi_iterator.hxx:2002
reference operator[](difference_type n) const
Definition multi_iterator.hxx:2147
next_type end() const
Definition multi_iterator.hxx:2189
bool operator==(const StridedMultiIterator &rhs) const
StridedMultiIterator(pointer ptr, const difference_array_type &stride, const difference_array_type &shape)
Definition multi_iterator.hxx:1986
StridedMultiIterator< N-1, T, REFERENCE, POINTER > base_type
Definition multi_iterator.hxx:1922
bool operator>(const StridedMultiIterator &rhs) const
StridedMultiIterator< K+1, T, REFERENCE, POINTER > & dim()
Definition multi_iterator.hxx:2242
StridedMultiIterator & operator+=(difference_type n)
Definition multi_iterator.hxx:2028
REFERENCE reference
Definition multi_iterator.hxx:1934
reference operator*() const
StridedMultiIterator()
Definition multi_iterator.hxx:1980
MultiArrayIndex difference_type
Definition multi_iterator.hxx:1960
MultiArrayShape< N >::type multi_difference_type
Definition multi_iterator.hxx:1951
bool operator<=(const StridedMultiIterator &rhs) const
bool operator<(const StridedMultiIterator &rhs) const
pointer operator->() const
next_type begin() const
Definition multi_iterator.hxx:2177
const value_type & const_reference
Definition multi_iterator.hxx:1938
POINTER pointer
Definition multi_iterator.hxx:1942
Sequential iterator for MultiArrayView.
Definition multi_iterator.hxx:273
iterator begin()
Definition tinyvector.hxx:861
Class for fixed size vectors.
Definition tinyvector.hxx:1008
LookupTag< TAG, A >::result_type get(A const &a)
Definition accumulator.hxx:2942
Diff2D operator+(Diff2D const &a, Diff2D const &b)
Definition diff2d.hxx:739
bool operator<=(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
less or equal
Definition fixedpoint.hxx:521
bool operator>=(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
greater or equal
Definition fixedpoint.hxx:539
FFTWComplex< R > & operator+=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
add-assignment
Definition fftw3.hxx:859
FFTWComplex< R > & operator-=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
subtract-assignment
Definition fftw3.hxx:867
bool operator>(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
greater
Definition fixedpoint.hxx:530
std::ptrdiff_t MultiArrayIndex
Definition multi_fwd.hxx:60
bool operator<(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
less than
Definition fixedpoint.hxx:512
bool operator==(FFTWComplex< R > const &a, const FFTWComplex< R > &b)
equal
Definition fftw3.hxx:825
bool operator!=(FFTWComplex< R > const &a, const FFTWComplex< R > &b)
not equal
Definition fftw3.hxx:841
Diff2D operator-(Diff2D const &a, Diff2D const &b)
Definition diff2d.hxx:711