37 #ifndef VIGRA_MULTI_HIERARCHICAL_ITERATOR_HXX 38 #define VIGRA_MULTI_HIERARCHICAL_ITERATOR_HXX 40 #include <sys/types.h> 41 #include "multi_fwd.hxx" 42 #include "iteratortags.hxx" 43 #include "multi_handle.hxx" 57 template <
unsigned int N,
60 class HierarchicalIterator
62 :
public HierarchicalIterator<N, HANDLES, DIMENSION-1>
67 typedef HierarchicalIterator<N, HANDLES, DIMENSION-1> base_type;
68 static const int level = DIMENSION;
69 typedef typename base_type::value_type value_type;
70 typedef typename base_type::reference reference;
71 typedef typename base_type::const_reference const_reference;
72 typedef typename base_type::pointer pointer;
73 typedef typename base_type::const_pointer const_pointer;
74 typedef typename base_type::difference_type difference_type;
75 typedef typename base_type::shape_type shape_type;
77 explicit HierarchicalIterator(HANDLES
const & handles = HANDLES())
83 this->handles_.template increment<level>();
88 this->handles_.template decrement<level>();
91 HierarchicalIterator operator++ (
int)
93 HierarchicalIterator ret = *
this;
98 HierarchicalIterator operator-- (
int)
100 HierarchicalIterator ret = *
this;
105 HierarchicalIterator &
operator+= (difference_type n)
107 this->handles_.addDim(level, n);
111 HierarchicalIterator &
operator+= (shape_type
const & d)
117 HierarchicalIterator &
operator-= (difference_type n)
119 this->handles_.addDim(level, -n);
129 HierarchicalIterator
operator+ (difference_type n)
const 131 return HierarchicalIterator(*
this) += n;
141 difference_type
operator- (HierarchicalIterator
const & d)
const 143 return this->point()[level] - d.point()[level];
146 HierarchicalIterator
operator- (difference_type n)
const 148 return HierarchicalIterator(*
this) -= n;
158 bool operator== (
const HierarchicalIterator &rhs)
const 160 return this->point()[level] == rhs.point()[level];
163 bool operator!= (
const HierarchicalIterator &rhs)
const 165 return this->point()[level] != rhs.point()[level];
168 bool operator< (
const HierarchicalIterator &rhs)
const 170 return this->point()[level] < rhs.point()[level];
173 bool operator<= (
const HierarchicalIterator &rhs)
const 175 return this->point()[level] <= rhs.point()[level];
178 bool operator> (
const HierarchicalIterator &rhs)
const 180 return this->point()[level] > rhs.point()[level];
183 bool operator>= (
const HierarchicalIterator &rhs)
const 185 return this->point()[level] >= rhs.point()[level];
188 base_type begin ()
const 193 base_type end ()
const 195 return base_type(*
this) += this->shape()[level-1] - this->point()[level-1];
198 HierarchicalIterator getEndIterator()
const 200 return HierarchicalIterator(*
this) += this->shape() - this->point();
211 HierarchicalIterator<N, HANDLES, K> &
218 HierarchicalIterator<N, HANDLES, K>
const &
227 template <
unsigned int N,
229 class HierarchicalIterator<N, HANDLES, 0>
232 static const int level = 0;
234 typedef CoupledHandleTraits<HANDLES> HandleTraits;
235 typedef typename HandleTraits::value_type value_type;
236 typedef typename HandleTraits::reference reference;
237 typedef typename HandleTraits::const_reference const_reference;
238 typedef typename HandleTraits::pointer pointer;
239 typedef typename HandleTraits::const_pointer const_pointer;
242 typedef HierarchicalIterator<N, HANDLES, 0> iterator;
243 typedef std::random_access_iterator_tag iterator_category;
249 explicit HierarchicalIterator(HANDLES
const & handles = HANDLES())
255 handles_.template increment<level>();
260 handles_.template decrement<level>();
263 HierarchicalIterator operator++ (
int)
265 HierarchicalIterator ret = *
this;
270 HierarchicalIterator operator-- (
int)
272 HierarchicalIterator ret = *
this;
277 HierarchicalIterator &
operator+= (difference_type n)
279 handles_.addDim(level, n);
283 HierarchicalIterator &
operator+= (shape_type
const & d)
286 handles_.scanOrderIndex_ += detail::CoordinateToScanOrder<N>::exec(shape(), d);
290 HierarchicalIterator &
operator-= (difference_type n)
292 handles_.addDim(level, -n);
302 HierarchicalIterator
operator+ (difference_type n)
const 304 return HierarchicalIterator(*
this) += n;
314 difference_type
operator- (HierarchicalIterator
const & d)
const 316 return point()[level] - d.point()[level];
319 HierarchicalIterator
operator- (difference_type n)
const 321 return HierarchicalIterator(*
this) -= n;
341 reference operator* ()
343 return HandleTraits::dereference(handles_);
346 const_reference operator* ()
const 348 return HandleTraits::dereference(handles_);
351 template <
unsigned int TARGET_INDEX>
352 typename CoupledHandleCast<TARGET_INDEX, HANDLES>::reference
355 return handles_.template get<TARGET_INDEX>();
358 template <
unsigned int TARGET_INDEX>
359 typename CoupledHandleCast<TARGET_INDEX, HANDLES>::const_reference
362 return handles_.template get<TARGET_INDEX>();
367 return &HandleTraits::dereference(handles_);
370 const_pointer operator->()
const 372 return &HandleTraits::dereference(handles_);
375 bool operator== (
const HierarchicalIterator &rhs)
const 377 return point()[level] == rhs.point()[level];
380 bool operator!= (
const HierarchicalIterator &rhs)
const 382 return point()[level] != rhs.point()[level];
385 bool operator< (
const HierarchicalIterator &rhs)
const 387 return point()[level] < rhs.point()[level];
390 bool operator<= (
const HierarchicalIterator &rhs)
const 392 return point()[level] <= rhs.point()[level];
395 bool operator> (
const HierarchicalIterator &rhs)
const 397 return point()[level] > rhs.point()[level];
400 bool operator>= (
const HierarchicalIterator &rhs)
const 402 return point()[level] >= rhs.point()[level];
413 HierarchicalIterator getEndIterator()
const 415 return HierarchicalIterator(*
this) += shape() - point();
418 shape_type
const & point()
const 420 return handles_.point();
423 shape_type
const & shape()
const 425 return handles_.shape();
428 difference_type scanOrderIndex()
const 430 return handles_.scanOrderIndex();
433 HANDLES
const & handles()
const 439 HierarchicalIterator<N, HANDLES, 0> &
446 HierarchicalIterator<N, HANDLES, 0>
const &
463 template <
unsigned int N,
class T1=
void,
class T2=
void,
class T3=
void,
class T4=
void,
class T5=
void>
467 typedef typename CoupledHandleType<N, T1, T2, T3, T4, T5>::type
HandleType;
470 typedef HierarchicalIterator<HandleType::dimensions, HandleType>
IteratorType;
471 typedef IteratorType type;
484 typename HierarchicalIteratorType<N>::type
487 typedef typename CoupledHandleType<N>::type P0;
488 typedef HierarchicalIterator<N, P0> IteratorType;
490 return IteratorType(P0(shape));
495 template <
unsigned int N1,
class T1,
class S1>
496 typename HierarchicalIteratorType<N1, T1>::type
499 typedef typename CoupledHandleType<N1, T1>::type P1;
500 typedef typename P1::base_type P0;
501 typedef HierarchicalIterator<P1::dimensions, P1> IteratorType;
503 return IteratorType(P1(m1,
509 template <
unsigned int N1,
class T1,
class S1,
510 unsigned int N2,
class T2,
class S2>
511 typename HierarchicalIteratorType<N1, T1, T2>::type
515 typedef typename CoupledHandleType<N1, T1, T2>::type P2;
516 typedef typename P2::base_type P1;
517 typedef typename P1::base_type P0;
518 typedef HierarchicalIterator<P2::dimensions, P2> IteratorType;
520 return IteratorType(P2(m2,
527 template <
unsigned int N1,
class T1,
class S1,
528 unsigned int N2,
class T2,
class S2,
529 unsigned int N3,
class T3,
class S3>
530 typename HierarchicalIteratorType<N1, T1, T2, T3>::type
535 typedef typename CoupledHandleType<N1, T1, T2, T3>::type P3;
536 typedef typename P3::base_type P2;
537 typedef typename P2::base_type P1;
538 typedef typename P1::base_type P0;
539 typedef HierarchicalIterator<P3::dimensions, P3> IteratorType;
541 return IteratorType(P3(m3,
549 template <
unsigned int N1,
class T1,
class S1,
550 unsigned int N2,
class T2,
class S2,
551 unsigned int N3,
class T3,
class S3,
552 unsigned int N4,
class T4,
class S4>
553 typename HierarchicalIteratorType<N1, T1, T2, T3, T4>::type
559 typedef typename CoupledHandleType<N1, T1, T2, T3, T4>::type P4;
560 typedef typename P4::base_type P3;
561 typedef typename P3::base_type P2;
562 typedef typename P2::base_type P1;
563 typedef typename P1::base_type P0;
564 typedef HierarchicalIterator<P4::dimensions, P4> IteratorType;
566 return IteratorType(P4(m4,
575 template <
unsigned int N1,
class T1,
class S1,
576 unsigned int N2,
class T2,
class S2,
577 unsigned int N3,
class T3,
class S3,
578 unsigned int N4,
class T4,
class S4,
579 unsigned int N5,
class T5,
class S5>
580 typename HierarchicalIteratorType<N1, T1, T2, T3, T4, T5>::type
587 typedef typename CoupledHandleType<N1, T1, T2, T3, T4, T5>::type P5;
588 typedef typename P5::base_type P4;
589 typedef typename P4::base_type P3;
590 typedef typename P3::base_type P2;
591 typedef typename P2::base_type P1;
592 typedef typename P1::base_type P0;
593 typedef HierarchicalIterator<P5::dimensions, P5> IteratorType;
595 return IteratorType(P5(m5,
600 P0(m1.
shape())))))));
604 template <
unsigned int N,
class A,
class B>
605 HierarchicalIterator<N, typename ZipCoupledHandles<A, B>::type>
606 zip(HierarchicalIterator<N, A>
const & a, HierarchicalIterator<N, B>
const & b)
608 vigra_precondition(a.shape() == b.shape() && a.scanOrderIndex() == b.scanOrderIndex(),
609 "zip(HierarchicalIterator): iterators must have identical shape and position.");
611 typedef typename ZipCoupledHandles<A, B>::type Handle;
612 typedef HierarchicalIterator<N, Handle> IteratorType;
613 return IteratorType(ZipCoupledHandles<A, B>::construct(a.handles(), b.handles()));
631 #endif // VIGRA_MULTI_HIERARCHICAL_ITERATOR_HXX Diff2D operator-(Diff2D const &a, Diff2D const &b)
Definition: diff2d.hxx:711
Diff2D operator+(Diff2D const &a, Diff2D const &b)
Definition: diff2d.hxx:739
std::ptrdiff_t MultiArrayIndex
Definition: multi_fwd.hxx:60
HierarchicalIteratorType< N >::type createHierarchicalIterator(TinyVector< MultiArrayIndex, N > const &shape)
Definition: multi_hierarchical_iterator.hxx:485
Definition: accessor.hxx:43
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)
less or equal
Definition: fixedpoint.hxx:521
FFTWComplex< R > & operator+=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
add-assignment
Definition: fftw3.hxx:859
const difference_type & shape() const
Definition: multi_array.hxx:1596
bool operator!=(FFTWComplex< R > const &a, const FFTWComplex< R > &b)
not equal
Definition: fftw3.hxx:841
bool operator==(FFTWComplex< R > const &a, const FFTWComplex< R > &b)
equal
Definition: fftw3.hxx:825
TinyVector< MultiArrayIndex, N > type
Definition: multi_shape.hxx:250
Class for fixed size vectors.This class contains an array of size SIZE of the specified VALUETYPE...
Definition: accessor.hxx:940
CoupledHandleType< N, T1, T2, T3, T4, T5 >::type HandleType
Definition: multi_hierarchical_iterator.hxx:467
HierarchicalIterator< HandleType::dimensions, HandleType > IteratorType
Definition: multi_hierarchical_iterator.hxx:470
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
Base class for, and view to, vigra::MultiArray.
Definition: multi_array.hxx:652
bool operator>(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
greater
Definition: fixedpoint.hxx:530
Definition: multi_hierarchical_iterator.hxx:464