38 #ifndef VIGRA_MULTI_ITERATOR_HXX
39 #define VIGRA_MULTI_ITERATOR_HXX
41 #include <sys/types.h>
42 #include "tinyvector.hxx"
43 #include "iteratortags.hxx"
48 template <
unsigned int N,
class T,
50 template <
unsigned int N,
class T,
353 template <
unsigned int N>
369 template <
class POINTER>
370 struct MultiIteratorStrideTraits
373 typedef const stride_type* stride_array_type;
374 typedef stride_array_type shape_array_type;
375 static stride_array_type shift(stride_array_type s,
unsigned d)
388 template <
unsigned int N,
class T,
class REFERENCE,
class POINTER>
398 template <
class T,
class REFERENCE,
class POINTER>
399 class MultiIterator<1, T, REFERENCE, POINTER>
409 typedef MultiIteratorStrideTraits<POINTER> stride_traits;
411 typedef typename stride_traits::stride_array_type difference_array_type;
412 typedef typename stride_traits::shape_array_type shape_array_type;
413 typedef StridedMultiIterator<1, T, REFERENCE, POINTER>
iterator;
425 const difference_array_type &,
426 const shape_array_type &)
494 return (m_ptr - d.m_ptr);
518 return m_ptr [d[level]];
538 return m_ptr != rhs.m_ptr;
543 return m_ptr == rhs.m_ptr;
548 return m_ptr < rhs.m_ptr;
553 return m_ptr <= rhs.m_ptr;
558 return m_ptr > rhs.m_ptr;
563 return m_ptr >= rhs.m_ptr;
568 vigra_precondition(d == 0,
569 "MultiIterator<1>::iteratorForDimension(d): d == 0 required");
574 template <
unsigned int K>
575 MultiIterator<K+1, T, REFERENCE, POINTER> &
581 MultiIterator<1, T, REFERENCE, POINTER> &
582 dim0() {
return *
this; }
587 total_stride(
typename multi_difference_type::const_iterator d)
const
600 template <
class T,
class REFERENCE,
class POINTER>
601 class MultiIterator<2, T, REFERENCE, POINTER>
603 :
public MultiIterator<1, T, REFERENCE, POINTER>
608 typedef MultiIterator<1, T, REFERENCE, POINTER>
base_type;
616 typedef MultiIteratorStrideTraits<POINTER> stride_traits;
618 typedef typename stride_traits::stride_array_type difference_array_type;
619 typedef typename stride_traits::shape_array_type shape_array_type;
621 typedef StridedMultiIterator<1, T, REFERENCE, POINTER>
iterator;
625 difference_array_type m_stride;
626 shape_array_type m_shape;
633 m_stride (0), m_shape (0)
637 const difference_array_type & stride,
638 const shape_array_type & shape)
640 m_stride (stride), m_shape (shape)
645 this->m_ptr += m_stride [level];
650 this->m_ptr -= m_stride [level];
669 this->m_ptr += n * m_stride [level];
675 this->m_ptr += total_stride(d.begin());
681 this->m_ptr -= n * m_stride [level];
687 this->m_ptr -= total_stride(d.begin());
707 return (this->m_ptr - d.m_ptr) / this->m_stride[level];
726 return this->m_ptr [n*m_stride [level]];
731 return this->m_ptr [total_stride(d.begin())];
742 ret += m_shape [level-1];
748 vigra_precondition(d <= level,
749 "MultiIterator<N>::iteratorForDimension(d): d < N required");
750 return iterator(this->m_ptr, stride_traits::shift(m_stride, d), 0);
753 template <
unsigned int K>
754 MultiIterator<K+1, T, REFERENCE, POINTER> &
760 MultiIterator<1, T, REFERENCE, POINTER> &
761 dim0() {
return *
this; }
762 MultiIterator<2, T, REFERENCE, POINTER> &
763 dim1() {
return *
this; }
768 total_stride(
typename multi_difference_type::const_iterator d)
const
770 return d[level]*m_stride[level] + base_type::total_stride(d);
789 template <
unsigned int N,
class T,
class REFERENCE,
class POINTER>
792 :
public MultiIterator<N-1, T, REFERENCE, POINTER>
803 enum { level = N-1 };
833 typedef MultiIteratorStrideTraits<POINTER> stride_traits;
835 typedef typename stride_traits::stride_array_type difference_array_type;
836 typedef typename stride_traits::shape_array_type shape_array_type;
865 const difference_array_type & stride,
866 const shape_array_type & shape)
875 this->m_ptr += this->m_stride [level];
882 this->m_ptr -= this->m_stride [level];
908 this->m_ptr += n * this->m_stride [level];
917 this->m_ptr += total_stride(d.
begin());
926 this->m_ptr -= n * this->m_stride [level];
935 this->m_ptr -= total_stride(d.
begin());
963 return (this->m_ptr - d.m_ptr) / this->m_stride[level];
1027 return this->m_ptr [n* this->m_stride [level]];
1034 return this->m_ptr [total_stride(d.
begin())];
1070 ret += this->m_shape [level-1];
1092 vigra_precondition(d <= level,
1093 "MultiIterator<N>::iteratorForDimension(d): d < N required");
1094 return iterator(this->m_ptr, stride_traits::shift(this->m_stride, d),0);
1118 template <
unsigned int K>
1126 dim0() {
return *
this; }
1127 MultiIterator<2, T, REFERENCE, POINTER> &
1128 dim1() {
return *
this; }
1129 MultiIterator<3, T, REFERENCE, POINTER> &
1130 dim2() {
return *
this; }
1131 MultiIterator<4, T, REFERENCE, POINTER> &
1132 dim3() {
return *
this; }
1133 MultiIterator<5, T, REFERENCE, POINTER> &
1134 dim4() {
return *
this; }
1139 total_stride(
typename multi_difference_type::const_iterator d)
const
1141 return d[level]*this->m_stride[level] + base_type::total_stride(d);
1152 template <
unsigned int N,
class T,
class REFERENCE,
class POINTER>
1153 class StridedMultiIterator;
1162 template <
class T,
class REFERENCE,
class POINTER>
1163 class StridedMultiIterator<1, T, REFERENCE, POINTER>
1173 typedef MultiIteratorStrideTraits<POINTER> stride_traits;
1175 typedef typename stride_traits::stride_array_type difference_array_type;
1176 typedef typename stride_traits::shape_array_type shape_array_type;
1177 typedef StridedMultiIterator<1, T, REFERENCE, POINTER>
iterator;
1188 : m_ptr (0), m_stride (0)
1192 const difference_array_type & stride,
1193 const shape_array_type &)
1194 : m_ptr (ptr), m_stride (stride [level])
1223 m_ptr += n * m_stride;
1229 m_ptr += d[level] * m_stride;
1235 m_ptr -= n * m_stride;
1241 m_ptr -= d[level] * m_stride;
1261 return (m_ptr - d.m_ptr) / m_stride;
1280 return m_ptr [n*m_stride];
1285 return m_ptr [d[level]*m_stride];
1305 return m_ptr != rhs.m_ptr;
1310 return m_ptr == rhs.m_ptr;
1315 return m_ptr < rhs.m_ptr;
1320 return m_ptr <= rhs.m_ptr;
1325 return m_ptr > rhs.m_ptr;
1330 return m_ptr >= rhs.m_ptr;
1335 vigra_precondition(d == 0,
1336 "StridedMultiIterator<1>::iteratorForDimension(d): d == 0 required");
1338 return iterator(m_ptr, &stride, 0);
1341 template <
unsigned int K>
1342 StridedMultiIterator<K+1, T, REFERENCE, POINTER> &
1348 StridedMultiIterator<1, T, REFERENCE, POINTER> &
1349 dim0() {
return *
this; }
1354 total_stride(
typename multi_difference_type::const_iterator d)
const
1356 return d[level] * m_stride;
1367 template <
class T,
class REFERENCE,
class POINTER>
1368 class StridedMultiIterator<2, T, REFERENCE, POINTER>
1370 :
public StridedMultiIterator<1, T, REFERENCE, POINTER>
1375 typedef StridedMultiIterator<1, T, REFERENCE, POINTER>
base_type;
1383 typedef MultiIteratorStrideTraits<POINTER> stride_traits;
1385 typedef typename stride_traits::stride_array_type difference_array_type;
1386 typedef typename stride_traits::shape_array_type shape_array_type;
1388 typedef StridedMultiIterator<1, T, REFERENCE, POINTER>
iterator;
1392 difference_array_type m_stride;
1393 shape_array_type m_shape;
1400 m_stride (0), m_shape (0)
1404 const difference_array_type & stride,
1405 const shape_array_type & shape)
1407 m_stride (stride), m_shape (shape)
1412 this->m_ptr += m_stride [level];
1417 this->m_ptr -= m_stride [level];
1436 this->m_ptr += n * m_stride [level];
1442 this->m_ptr += total_stride(d.begin());
1448 this->m_ptr -= n * m_stride [level];
1454 this->m_ptr -= total_stride(d.begin());
1474 return (this->m_ptr - d.m_ptr) / this->m_stride[level];
1493 return this->m_ptr [n*m_stride [level]];
1498 return this->m_ptr [total_stride(d.begin())];
1509 ret += m_shape [level-1];
1515 vigra_precondition(d <= level,
1516 "StridedMultiIterator<N>::iteratorForDimension(d): d < N required");
1517 return iterator(this->m_ptr, stride_traits::shift(m_stride, d), 0);
1520 template <
unsigned int K>
1521 StridedMultiIterator<K+1, T, REFERENCE, POINTER> &
1527 StridedMultiIterator<1, T, REFERENCE, POINTER> &
1528 dim0() {
return *
this; }
1529 StridedMultiIterator<2, T, REFERENCE, POINTER> &
1530 dim1() {
return *
this; }
1535 total_stride(
typename multi_difference_type::const_iterator d)
const
1537 return d[level]*m_stride[level] + base_type::total_stride(d);
1556 template <
unsigned int N,
class T,
class REFERENCE,
class POINTER>
1557 class StridedMultiIterator
1559 :
public StridedMultiIterator<N-1, T, REFERENCE, POINTER>
1570 enum { level = N-1 };
1600 typedef MultiIteratorStrideTraits<POINTER> stride_traits;
1602 typedef typename stride_traits::stride_array_type difference_array_type;
1631 const difference_array_type & stride,
1632 const difference_array_type & shape)
1641 this->m_ptr += this->m_stride [level];
1648 this->m_ptr -= this->m_stride [level];
1674 this->m_ptr += n * this->m_stride [level];
1683 this->m_ptr += total_stride(d.
begin());
1692 this->m_ptr -= n * this->m_stride [level];
1701 this->m_ptr -= total_stride(d.
begin());
1729 return (this->m_ptr - d.m_ptr) / this->m_stride[level];
1793 return this->m_ptr [n* this->m_stride [level]];
1800 return this->m_ptr [total_stride(d.
begin())];
1836 ret += this->m_shape [level-1];
1858 vigra_precondition(d <= level,
1859 "StridedMultiIterator<N>::iteratorForDimension(d): d < N required");
1860 return iterator(this->m_ptr, stride_traits::shift(this->m_stride, d),0);
1884 template <
unsigned int K>
1892 dim0() {
return *
this; }
1893 StridedMultiIterator<2, T, REFERENCE, POINTER> &
1894 dim1() {
return *
this; }
1895 StridedMultiIterator<3, T, REFERENCE, POINTER> &
1896 dim2() {
return *
this; }
1897 StridedMultiIterator<4, T, REFERENCE, POINTER> &
1898 dim3() {
return *
this; }
1899 StridedMultiIterator<5, T, REFERENCE, POINTER> &
1900 dim4() {
return *
this; }
1905 total_stride(
typename multi_difference_type::const_iterator d)
const
1907 return d[level]*this->m_stride[level] + base_type::total_stride(d);
1916 struct CoordinateToScanOrder
1920 exec(
const TinyVector <MultiArrayIndex, N> &shape,
1921 const TinyVector <MultiArrayIndex, N> & coordinate)
1923 return coordinate[N-K] + shape[N-K] * CoordinateToScanOrder<K-1>::exec(shape, coordinate);
1928 struct CoordinateToScanOrder<1>
1932 exec(
const TinyVector <MultiArrayIndex, N> & ,
1933 const TinyVector <MultiArrayIndex, N> & coordinate)
1935 return coordinate[N-1];
1940 template <
unsigned int M>
1941 struct MoveToScanOrderIndex
1943 template <
class Shape,
class Ptr>
1946 Shape & point, Ptr & p, Shape
const & strides)
1948 enum { N = Shape::static_size };
1950 p += (newPos - point[N-1-M]) * strides[N-1-M];
1951 point[N-1-M] = newPos;
1952 MoveToScanOrderIndex<M-1>::exec(newIndex / shape[N-1-M], shape, point, p, strides);
1955 template <
class Shape,
class Ptr1,
class Ptr2>
1958 Ptr1 & p1, Shape
const & strides1, Ptr2 & p2, Shape
const & strides2)
1960 enum { N = Shape::static_size };
1962 p1 += (newPos - point[N-1-M]) * strides1[N-1-M];
1963 p2 += (newPos - point[N-1-M]) * strides2[N-1-M];
1964 point[N-1-M] = newPos;
1965 MoveToScanOrderIndex<M-1>::exec(newIndex / shape[N-1-M], shape, point,
1966 p1, strides1, p2, strides2);
1971 struct MoveToScanOrderIndex<0>
1973 template <
class Shape,
class Ptr>
1976 Shape & point, Ptr & p, Shape
const & strides)
1978 enum { N = Shape::static_size };
1980 p += (newPos - point[N-1]) * strides[N-1];
1981 point[N-1] = newPos;
1984 template <
class Shape,
class Ptr1,
class Ptr2>
1987 Ptr1 & p1, Shape
const & strides1, Ptr2 & p2, Shape
const & strides2)
1989 enum { N = Shape::static_size };
1991 p1 += (newPos - point[N-1]) * strides1[N-1];
1992 p2 += (newPos - point[N-1]) * strides2[N-1];
1993 point[N-1] = newPos;
1997 #if 0 // alternative implementation, may be faster on some machines
1998 template <
unsigned int M>
1999 struct MoveToScanOrderIndex
2001 template <
class Shape,
class Ptr>
2004 Shape & point, Ptr & p, Shape
const & strides,
MultiArrayIndex shapeStride = 1)
2006 enum { N = Shape::static_size };
2007 MoveToScanOrderIndex<M-1>::exec(newIndex, shape, point, p, strides, shapeStride*shape[N-1-M]);
2009 p += (newPos - point[N-1-M]) * strides[N-1-M];
2010 point[N-1-M] = newPos;
2011 newIndex %= shapeStride;
2014 template <
class Shape,
class Ptr1,
class Ptr2>
2017 Ptr1 & p1, Shape
const & strides1, Ptr2 & p2, Shape
const & strides2,
2020 enum { N = Shape::static_size };
2021 MoveToScanOrderIndex<M-1>::exec(newIndex, shape, point,
2022 p1, strides1, p2, strides2, shapeStride*shape[N-1-M]);
2024 p1 += (newPos - point[N-1-M]) * strides1[N-1-M];
2025 p2 += (newPos - point[N-1-M]) * strides2[N-1-M];
2026 point[N-1-M] = newPos;
2027 newIndex %= shapeStride;
2032 struct MoveToScanOrderIndex<0>
2034 template <
class Shape,
class Ptr>
2037 Shape & point, Ptr & p, Shape
const & strides,
MultiArrayIndex shapeStride)
2039 enum { N = Shape::static_size };
2041 p += (newPos - point[N-1]) * strides[N-1];
2042 point[N-1] = newPos;
2043 newIndex %= shapeStride;
2046 template <
class Shape,
class Ptr1,
class Ptr2>
2049 Ptr1 & p1, Shape
const & strides1, Ptr2 & p2, Shape
const & strides2,
2052 enum { N = Shape::static_size };
2054 p1 += (newPos - point[N-1]) * strides1[N-1];
2055 p2 += (newPos - point[N-1]) * strides2[N-1];
2056 point[N-1] = newPos;
2057 newIndex %= shapeStride;
2078 template <
unsigned int N,
class T,
class REFERENCE,
class POINTER,
unsigned int M = N>
2085 enum { level = M-1 };
2089 typedef typename base_type::value_type value_type;
2090 typedef typename base_type::pointer pointer;
2091 typedef typename base_type::reference reference;
2092 typedef typename base_type::const_reference const_reference;
2093 typedef typename base_type::shape_type shape_type;
2094 typedef MultiIteratorStrideTraits<POINTER> stride_traits;
2095 typedef typename stride_traits::stride_type difference_type;
2096 typedef typename stride_traits::stride_array_type difference_array_type;
2098 typedef std::random_access_iterator_tag iterator_category;
2104 shape_type
const & shape, shape_type
const & strides)
2110 base_type::operator++();
2111 if(this->point_[level-1] == this->shape_[level-1])
2114 this->i_ += this->strides_[level];
2115 ++this->point_[level];
2129 this->moveToScanOrderIndex(this->index_+i);
2137 this->moveRelative(
dot(coordOffset,this->strides_),
2138 detail::CoordinateToScanOrder<N>::exec(this->shape_, coordOffset),
2144 return operator+=(-coordOffset);
2147 StridedScanOrderIterator & operator--()
2149 base_type::operator--();
2150 if(this->point_[level-1] == -1)
2152 base_type::inverseReset();
2153 this->i_ -= this->strides_[level];
2154 --this->point_[level];
2159 StridedScanOrderIterator operator--(
int)
2161 StridedScanOrderIterator res(*
this);
2168 return operator+=(-i);
2171 StridedScanOrderIterator getEndIterator()
const
2173 StridedScanOrderIterator res(*
this);
2174 res.moveToScanOrderIndex(
prod(this->shape_));
2178 bool atBorder()
const
2180 return base_type::atBorder() ||
2181 this->point_[level] == 0 ||
2182 this->point_[level] == this->shape_[level] - 1;
2185 unsigned int neighborhoodType()
const
2187 unsigned int res = base_type::neighborhoodType();
2188 if(this->point_[level] == 0)
2189 res |= (1 << 2*level);
2190 if(this->point_[level] == this->shape_[level]-1)
2191 res |= (2 << 2*level);
2197 return StridedScanOrderIterator(*
this) += d;
2202 return StridedScanOrderIterator(*
this) -= d;
2206 StridedScanOrderIterator operator+(
const shape_type &coordOffset)
const
2208 return StridedScanOrderIterator(*
this) += coordOffset;
2211 StridedScanOrderIterator operator-(
const shape_type &coordOffset)
const
2213 return StridedScanOrderIterator(*
this) -= coordOffset;
2220 return base_type::operator-(r);
2223 bool operator==(StridedScanOrderIterator
const & r)
2225 return base_type::operator==(r);
2228 bool operator!=(StridedScanOrderIterator
const & r)
const
2230 return base_type::operator!=(r);
2233 bool operator<(StridedScanOrderIterator
const & r)
const
2235 return base_type::operator<(r);
2238 bool operator<=(StridedScanOrderIterator
const & r)
const
2240 return base_type::operator<=(r);
2243 bool operator>(StridedScanOrderIterator
const & r)
const
2245 return base_type::operator>(r);
2248 bool operator>=(StridedScanOrderIterator
const & r)
const
2250 return base_type::operator>=(r);
2253 using base_type::point;
2254 using base_type::shape;
2255 using base_type::strides;
2256 using base_type::ptr;
2257 using base_type::index;
2258 using base_type::operator*;
2259 using base_type::operator->;
2260 using base_type::operator[];
2265 this->i_ -= this->shape_[level]*this->strides_[level];
2266 this->point_[level] = 0;
2271 this->i_ += this->shape_[level]*this->strides_[level];
2272 this->point_[level] = this->shape_[level]-1;
2275 template <
class Ptr>
2276 void increment(Ptr & p2, shape_type
const & strides2)
2278 base_type::increment(p2, strides2);
2279 if(this->point_[level-1] == this->shape_[level-1])
2282 this->i_ += this->strides_[level];
2283 p2 += strides2[level] - this->shape_[level-1]*strides2[level-1];
2284 ++this->point_[level];
2288 template <
class Ptr>
2289 void decrement(Ptr & p2, shape_type
const & strides2)
2291 base_type::decrement(p2, strides2);
2292 if(this->point_[level-1] == -1)
2294 base_type::inverseReset();
2295 this->i_ -= this->strides_[level];
2296 p2 -= strides2[level] - this->shape_[level-1]*strides2[level-1];
2297 --this->point_[level];
2300 StridedScanOrderIterator & moveRelative(
const MultiArrayIndex &pointerOffset,
2302 const shape_type &coordOffset)
2304 base_type::moveRelative(pointerOffset, indexOffset, coordOffset);
2305 this->point_[level] += coordOffset[level];
2310 template <
unsigned int N,
class T,
class REFERENCE,
class POINTER>
2311 class StridedScanOrderIterator<N, T, REFERENCE, POINTER, 1>
2317 typedef T value_type;
2318 typedef POINTER pointer;
2319 typedef T
const * const_pointer;
2320 typedef REFERENCE reference;
2321 typedef T
const & const_reference;
2322 typedef typename MultiArrayShape<N>::type shape_type;
2323 typedef MultiIteratorStrideTraits<POINTER> stride_traits;
2324 typedef typename stride_traits::stride_type difference_type;
2325 typedef typename stride_traits::stride_array_type difference_array_type;
2326 typedef StridedScanOrderIterator iterator;
2327 typedef std::random_access_iterator_tag iterator_category;
2329 StridedScanOrderIterator()
2334 StridedScanOrderIterator(pointer i,
2335 shape_type
const & shape, shape_type
const & strides)
2342 StridedScanOrderIterator & operator++()
2344 i_ += strides_[level];
2350 StridedScanOrderIterator operator++(
int)
2352 StridedScanOrderIterator res(*
this);
2359 this->moveToScanOrderIndex(index_+i);
2364 StridedScanOrderIterator & operator+=(
const shape_type &coordOffset)
2366 this->moveRelative(
dot(coordOffset,strides_),
2367 detail::CoordinateToScanOrder<N>::exec(shape_, coordOffset),
2372 StridedScanOrderIterator & operator-=(
const shape_type &coordOffset)
2374 return operator+=(-coordOffset);
2377 StridedScanOrderIterator & operator--()
2379 i_ -= strides_[level];
2385 StridedScanOrderIterator operator--(
int)
2387 StridedScanOrderIterator res(*
this);
2394 return operator+=(-i);
2397 reference operator*()
2402 const_reference operator*()
const
2407 pointer operator->()
2412 const_pointer operator->()
const
2422 const_pointer ptr()
const
2429 StridedScanOrderIterator t(*
this);
2430 t.moveToScanOrderIndex(index_+i);
2436 StridedScanOrderIterator t(*
this);
2437 t.moveToScanOrderIndex(index_+i);
2441 StridedScanOrderIterator
2444 return StridedScanOrderIterator(*
this) += d;
2447 StridedScanOrderIterator
2450 return StridedScanOrderIterator(*
this) -= d;
2453 StridedScanOrderIterator operator+(
const shape_type &coordOffset)
const
2455 return StridedScanOrderIterator(*
this) += coordOffset;
2458 StridedScanOrderIterator operator-(
const shape_type &coordOffset)
const
2460 return StridedScanOrderIterator(*
this) -= coordOffset;
2464 operator-(StridedScanOrderIterator
const & r)
const
2466 return index() - r.index();
2470 operator==(StridedScanOrderIterator
const & r)
2472 return index() == r.index();
2476 operator!=(StridedScanOrderIterator
const & r)
const
2478 return index() != r.index();
2482 operator<(StridedScanOrderIterator
const & r)
const
2484 return index() < r.index();
2488 operator<=(StridedScanOrderIterator
const & r)
const
2490 return index() <= r.index();
2494 operator>(StridedScanOrderIterator
const & r)
const
2496 return index() > r.index();
2500 operator>=(StridedScanOrderIterator
const & r)
const
2502 return index() >= r.index();
2506 bool atBorder()
const
2508 return point_[level] == 0 || point_[level] == shape_[level] - 1;
2516 shape_type
const & point()
const
2521 shape_type
const & shape()
const
2526 shape_type
const & strides()
const
2531 StridedScanOrderIterator getEndIterator()
const
2533 StridedScanOrderIterator res(*
this);
2534 res.moveToScanOrderIndex(
prod(shape_));
2538 unsigned int neighborhoodType()
const
2540 unsigned int res = 0;
2541 if(this->point_[level] == 0)
2543 if(this->point_[level] == this->shape_[level]-1)
2551 i_ -= shape_[level]*strides_[level];
2557 i_ += shape_[level]*strides_[level];
2558 point_[level] = shape_[level] - 1;
2564 detail::MoveToScanOrderIndex<N-1>::exec(newIndex, shape_, point_, i_, strides_);
2567 template <
class Ptr>
2568 void increment(Ptr & p2, shape_type
const & strides2)
2571 p2 += strides2[level];
2574 template <
class Ptr>
2575 void decrement(Ptr & p2, shape_type
const & strides2)
2578 p2 -= strides2[level];
2581 template <
class Ptr>
2582 void moveToScanOrderIndex(
MultiArrayIndex newIndex, Ptr & p2, shape_type
const & strides2)
2585 detail::MoveToScanOrderIndex<N-1>::exec(newIndex, shape_, point_, i_, strides_, p2, strides2);
2588 StridedScanOrderIterator & moveRelative(
const MultiArrayIndex &pointerOffset,
2590 const shape_type &coordOffset)
2592 point_[level] += coordOffset[level];
2594 index_+= indexOffset;
2595 i_ += pointerOffset;
2601 shape_type point_, shape_, strides_;
2610 #endif // VIGRA_MULTI_ITERATOR_HXX
MultiArrayShape< 3 >::type Shape3
shape type for MultiArray<3, T>
Definition: multi_iterator.hxx:365
Sequential iterator for MultiArrayView.
Definition: multi_iterator.hxx:2079
StridedMultiIterator< 1, T, REFERENCE, POINTER > iterator
Definition: multi_iterator.hxx:848
PromoteTraits< V1, V2 >::Promote dot(RGBValue< V1, RIDX1, GIDX1, BIDX1 > const &r1, RGBValue< V2, RIDX2, GIDX2, BIDX2 > const &r2)
dot product
Definition: rgbvalue.hxx:894
reference operator*() const
reference operator[](difference_type n) const
Definition: multi_iterator.hxx:1791
bool operator<(const MultiIterator &rhs) const
POINTER pointer
Definition: multi_iterator.hxx:1586
StridedMultiIterator()
Definition: multi_iterator.hxx:1624
next_type end() const
Definition: multi_iterator.hxx:1833
A multi-dimensional hierarchical iterator to be used with vigra::MultiArrayView if it is not strided...
Definition: multi_iterator.hxx:49
pointer operator->() const
StridedMultiIterator & operator+=(difference_type n)
Definition: multi_iterator.hxx:1672
MultiIterator operator+(difference_type n) const
Definition: multi_iterator.hxx:941
bool operator>(const StridedMultiIterator &rhs) const
bool operator>=(const StridedMultiIterator &rhs) const
MultiIterator & operator-=(difference_type n)
Definition: multi_iterator.hxx:924
const value_type & const_reference
Definition: multi_iterator.hxx:1582
multi_dimensional_traverser_tag iterator_category
Definition: multi_iterator.hxx:1618
POINTER pointer
Definition: multi_iterator.hxx:819
StridedMultiIterator< K+1, T, REFERENCE, POINTER > & dim()
Definition: multi_iterator.hxx:1886
std::ptrdiff_t MultiArrayIndex
Definition: multi_iterator.hxx:348
StridedMultiIterator & operator-=(difference_type n)
Definition: multi_iterator.hxx:1690
bool operator<=(const MultiIterator &rhs) const
MultiIterator< N-1, T, REFERENCE, POINTER > base_type
Definition: multi_iterator.hxx:799
iterator iteratorForDimension(unsigned int d) const
Definition: multi_iterator.hxx:1090
StridedScanOrderIterator & operator+=(const shape_type &coordOffset)
overload to add a coord-tuple:
Definition: multi_iterator.hxx:2135
void operator++()
Definition: multi_iterator.hxx:1639
StridedMultiIterator(pointer ptr, const difference_array_type &stride, const difference_array_type &shape)
Definition: multi_iterator.hxx:1630
MultiArrayIndex difference_type
Definition: multi_iterator.hxx:1604
REFERENCE reference
Definition: multi_iterator.hxx:1578
base_type next_type
Definition: multi_iterator.hxx:1609
MultiIterator(pointer ptr, const difference_array_type &stride, const shape_array_type &shape)
Definition: multi_iterator.hxx:864
REFERENCE reference
Definition: multi_iterator.hxx:811
Definition: multi_iterator.hxx:354
StridedMultiIterator operator+(difference_type n) const
Definition: multi_iterator.hxx:1707
MultiIterator()
Definition: multi_iterator.hxx:858
NumericTraits< V >::Promote prod(TinyVectorBase< V, SIZE, D1, D2 > const &l)
product of the vector's elements
Definition: tinyvector.hxx:1707
T value_type
Definition: multi_iterator.hxx:807
next_type begin() const
Definition: multi_iterator.hxx:1821
MultiIterator< K+1, T, REFERENCE, POINTER > & dim()
Definition: multi_iterator.hxx:1120
StridedMultiIterator< 1, T, REFERENCE, POINTER > iterator
Definition: multi_iterator.hxx:1614
MultiArrayIndex difference_type
Definition: multi_iterator.hxx:838
iterator begin()
Definition: tinyvector.hxx:724
MultiIterator & operator+=(difference_type n)
Definition: multi_iterator.hxx:906
bool operator<=(const StridedMultiIterator &rhs) const
TinyVector< MultiArrayIndex, N > type
Definition: multi_iterator.hxx:360
bool operator!=(const MultiIterator &rhs) const
difference_type operator-(MultiIterator const &d) const
Definition: multi_iterator.hxx:961
A multi-dimensional hierarchical iterator to be used with vigra::MultiArrayView if it is not strided...
Definition: multi_iterator.hxx:51
Class for fixed size vectors.This class contains an array of size SIZE of the specified VALUETYPE...
Definition: accessor.hxx:939
const value_type & const_reference
Definition: multi_iterator.hxx:815
bool operator>=(const MultiIterator &rhs) const
bool operator==(const MultiIterator &rhs) const
MultiArrayShape< 5 >::type Shape5
shape type for MultiArray<5, T>
Definition: multi_iterator.hxx:367
MultiArrayShape< 2 >::type Shape2
shape type for MultiArray<2, T>
Definition: multi_iterator.hxx:364
const value_type * const_pointer
Definition: multi_iterator.hxx:823
void operator--()
Definition: multi_iterator.hxx:880
MultiArrayShape< 1 >::type Shape1
shape type for MultiArray<1, T>
Definition: multi_iterator.hxx:363
multi_dimensional_traverser_tag iterator_category
Definition: multi_iterator.hxx:852
void operator--()
Definition: multi_iterator.hxx:1646
iterator iteratorForDimension(unsigned int d) const
Definition: multi_iterator.hxx:1856
StridedMultiIterator< N-1, T, REFERENCE, POINTER > base_type
Definition: multi_iterator.hxx:1566
pointer operator->() const
void operator++()
Definition: multi_iterator.hxx:873
bool operator==(const StridedMultiIterator &rhs) const
reference operator[](difference_type n) const
Definition: multi_iterator.hxx:1025
next_type end() const
Definition: multi_iterator.hxx:1067
MultiArrayShape< N >::type multi_difference_type
Definition: multi_iterator.hxx:828
bool operator>(const MultiIterator &rhs) const
T value_type
Definition: multi_iterator.hxx:1574
next_type begin() const
Definition: multi_iterator.hxx:1055
bool operator<(const StridedMultiIterator &rhs) const
bool operator!=(const StridedMultiIterator &rhs) const
MultiArrayShape< N >::type multi_difference_type
Definition: multi_iterator.hxx:1595
base_type next_type
Definition: multi_iterator.hxx:843
MultiArrayShape< 4 >::type Shape4
shape type for MultiArray<4, T>
Definition: multi_iterator.hxx:366
reference operator*() const
difference_type operator-(StridedMultiIterator const &d) const
Definition: multi_iterator.hxx:1727
const value_type * const_pointer
Definition: multi_iterator.hxx:1590