37 #ifndef VIGRA_IMAGEITERATOR_HXX
38 #define VIGRA_IMAGEITERATOR_HXX
41 #include "accessor.hxx"
42 #include "iteratortraits.hxx"
43 #include "metaprogramming.hxx"
47 template <
class IMAGEITERATOR>
48 class StridedIteratorPolicy
51 typedef IMAGEITERATOR ImageIterator;
52 typedef typename IMAGEITERATOR::value_type value_type;
53 typedef typename IMAGEITERATOR::difference_type::MoveY
55 typedef typename IMAGEITERATOR::reference reference;
56 typedef typename IMAGEITERATOR::index_reference index_reference;
57 typedef typename IMAGEITERATOR::pointer pointer;
58 typedef std::random_access_iterator_tag iterator_category;
63 explicit BaseType(pointer c = 0, difference_type stride = 0)
64 : current_(c), stride_(stride)
68 difference_type stride_;
71 static void initialize(BaseType & ) {}
73 static reference dereference(BaseType
const & d)
74 {
return const_cast<reference
>(*d.current_); }
76 static index_reference dereference(BaseType
const & d, difference_type n)
78 return const_cast<index_reference
>(d.current_[n*d.stride_]);
81 static bool equal(BaseType
const & d1, BaseType
const & d2)
82 {
return d1.current_ == d2.current_; }
84 static bool less(BaseType
const & d1, BaseType
const & d2)
85 {
return d1.current_ < d2.current_; }
87 static difference_type difference(BaseType
const & d1, BaseType
const & d2)
88 {
return (d1.current_ - d2.current_) / d1.stride_; }
90 static void increment(BaseType & d)
91 { d.current_ += d.stride_; }
93 static void decrement(BaseType & d)
94 { d.current_ -= d.stride_; }
96 static void advance(BaseType & d, difference_type n)
97 { d.current_ += d.stride_*n; }
360 template <
class Str
idedOrUnstr
ided>
361 class DirectionSelector;
364 class DirectionSelector<UnstridedArrayTag>
376 type(type
const & rhs)
377 : current_(rhs.current_)
380 type & operator=(type
const & rhs)
382 current_ = rhs.current_;
386 void operator++() {++current_;}
387 void operator++(
int) {++current_;}
388 void operator--() {--current_;}
389 void operator--(
int) {--current_;}
390 void operator+=(std::ptrdiff_t dx) {current_ += dx; }
391 void operator-=(std::ptrdiff_t dx) {current_ -= dx; }
394 {
return current_ == rhs.current_; }
397 {
return current_ != rhs.current_; }
400 {
return current_ < rhs.current_; }
403 {
return current_ <= rhs.current_; }
406 {
return current_ > rhs.current_; }
409 {
return current_ >= rhs.current_; }
411 std::ptrdiff_t
operator-(type
const & rhs)
const
412 {
return current_ - rhs.current_; }
417 T operator()(std::ptrdiff_t d)
const
418 {
return current_ + d; }
425 class DirectionSelector<StridedArrayTag>
433 type(std::ptrdiff_t stride, T base = 0)
438 type(type
const & rhs)
439 : stride_(rhs.stride_),
440 current_(rhs.current_)
443 type & operator=(type
const & rhs)
445 stride_ = rhs.stride_;
446 current_ = rhs.current_;
450 void operator++() {current_ += stride_; }
451 void operator++(
int) {current_ += stride_; }
452 void operator--() {current_ -= stride_; }
453 void operator--(
int) {current_ -= stride_; }
454 void operator+=(std::ptrdiff_t dy) {current_ += dy*stride_; }
455 void operator-=(std::ptrdiff_t dy) {current_ -= dy*stride_; }
458 {
return (current_ == rhs.current_); }
461 {
return (current_ != rhs.current_); }
464 {
return (current_ < rhs.current_); }
467 {
return (current_ <= rhs.current_); }
470 {
return (current_ > rhs.current_); }
473 {
return (current_ >= rhs.current_); }
475 std::ptrdiff_t
operator-(type
const & rhs)
const
476 {
return (current_ - rhs.current_) / stride_; }
481 T operator()(std::ptrdiff_t d)
const
482 {
return current_ + d*stride_; }
484 std::ptrdiff_t stride_;
489 template <
class Str
idedOrUnstr
ided>
490 class LinearIteratorSelector;
493 class LinearIteratorSelector<UnstridedArrayTag>
496 template <
class IMAGEITERATOR>
500 typedef typename IMAGEITERATOR::pointer res;
502 template <
class DirSelect>
503 static res construct(
typename IMAGEITERATOR::pointer data, DirSelect
const &)
511 class LinearIteratorSelector<StridedArrayTag>
514 template <
class IMAGEITERATOR>
518 typedef IteratorAdaptor<StridedIteratorPolicy<IMAGEITERATOR> > res;
520 template <
class DirSelect>
521 static res construct(
typename IMAGEITERATOR::pointer data, DirSelect
const & d)
523 typedef typename res::BaseType Base;
524 return res(Base(data, d.stride_));
560 template <
class IMAGEITERATOR,
561 class PIXELTYPE,
class REFERENCE,
class POINTER,
562 class StridedOrUnstrided = UnstridedArrayTag>
566 vigra::detail::LinearIteratorSelector<StridedOrUnstrided>::template type<ImageIteratorBase>
569 vigra::detail::LinearIteratorSelector<StridedArrayTag>::template type<ImageIteratorBase>
570 ColumnIteratorSelector;
573 PIXELTYPE, REFERENCE, POINTER, StridedOrUnstrided>
self_type;
614 vigra::detail::DirectionSelector<StridedOrUnstrided>::template type<pointer>
MoveX;
619 vigra::detail::DirectionSelector<StridedArrayTag>::template type<std::ptrdiff_t>
MoveY;
627 return (
x == rhs.
x) && (
y == rhs.
y);
634 return (
x != rhs.
x) || (
y != rhs.
y);
731 return static_cast<IMAGEITERATOR &
>(*this);
739 return static_cast<IMAGEITERATOR &
>(*this);
746 IMAGEITERATOR ret(static_cast<IMAGEITERATOR const &>(*
this));
757 IMAGEITERATOR ret(static_cast<IMAGEITERATOR const &>(*
this));
788 return *current(d.
x, d.
y);
796 return *current(dx, dy);
811 return RowIteratorSelector::construct(current(),
x);
816 return ColumnIteratorSelector::construct(current(),
y);
822 {
return x() +
y(); }
824 pointer current(std::ptrdiff_t dx, std::ptrdiff_t dy)
const
825 {
return x(dx) +
y(dy); }
847 template <
class PIXELTYPE>
850 PIXELTYPE, PIXELTYPE &, PIXELTYPE *>
854 PIXELTYPE, PIXELTYPE &, PIXELTYPE *>
Base;
867 :
Base(base, ystride)
892 template <
class PIXELTYPE>
895 PIXELTYPE, PIXELTYPE const &, PIXELTYPE const *>
899 PIXELTYPE, PIXELTYPE
const &, PIXELTYPE
const *>
Base;
912 :
Base(base, ystride)
965 template <
class PIXELTYPE>
968 PIXELTYPE, PIXELTYPE &, PIXELTYPE *, StridedArrayTag>
982 :
Base(base, xskip, ystride*yskip)
1025 template <
class PIXELTYPE>
1028 PIXELTYPE, PIXELTYPE const &, PIXELTYPE const *,
1033 PIXELTYPE, PIXELTYPE
const &, PIXELTYPE
const *,
1044 :
Base(base, xskip, ystride*yskip)
1073 #ifndef NO_PARTIAL_TEMPLATE_SPECIALIZATION
1076 struct IteratorTraits<ImageIterator<T> >
1077 :
public IteratorTraitsBase<ImageIterator<T> >
1079 typedef ImageIterator<T> mutable_iterator;
1080 typedef ConstImageIterator<T> const_iterator;
1081 typedef typename AccessorTraits<T>::default_accessor DefaultAccessor;
1082 typedef DefaultAccessor default_accessor;
1083 typedef VigraTrueType hasConstantStrides;
1087 struct IteratorTraits<ConstImageIterator<T> >
1088 :
public IteratorTraitsBase<ConstImageIterator<T> >
1090 typedef ImageIterator<T> mutable_iterator;
1091 typedef ConstImageIterator<T> const_iterator;
1092 typedef typename AccessorTraits<T>::default_const_accessor DefaultAccessor;
1093 typedef DefaultAccessor default_accessor;
1094 typedef VigraTrueType hasConstantStrides;
1098 struct IteratorTraits<StridedImageIterator<T> >
1099 :
public IteratorTraitsBase<StridedImageIterator<T> >
1101 typedef StridedImageIterator<T> mutable_iterator;
1102 typedef ConstStridedImageIterator<T> const_iterator;
1103 typedef typename AccessorTraits<T>::default_accessor DefaultAccessor;
1104 typedef DefaultAccessor default_accessor;
1105 typedef VigraTrueType hasConstantStrides;
1109 struct IteratorTraits<ConstStridedImageIterator<T> >
1110 :
public IteratorTraitsBase<ConstStridedImageIterator<T> >
1112 typedef StridedImageIterator<T> mutable_iterator;
1113 typedef ConstStridedImageIterator<T> const_iterator;
1114 typedef typename AccessorTraits<T>::default_const_accessor DefaultAccessor;
1115 typedef DefaultAccessor default_accessor;
1116 typedef VigraTrueType hasConstantStrides;
1119 #else // NO_PARTIAL_TEMPLATE_SPECIALIZATION
1121 #define VIGRA_DEFINE_ITERATORTRAITS(VALUETYPE) \
1123 struct IteratorTraits<ImageIterator<VALUETYPE > > \
1124 : public IteratorTraitsBase<ImageIterator<VALUETYPE > > \
1126 typedef ImageIterator<VALUETYPE> mutable_iterator; \
1127 typedef ConstImageIterator<VALUETYPE> const_iterator; \
1128 typedef typename AccessorTraits<VALUETYPE >::default_accessor DefaultAccessor; \
1129 typedef DefaultAccessor default_accessor; \
1130 typedef VigraTrueType hasConstantStrides; \
1134 struct IteratorTraits<ConstImageIterator<VALUETYPE > > \
1135 : public IteratorTraitsBase<ConstImageIterator<VALUETYPE > > \
1137 typedef ImageIterator<VALUETYPE> mutable_iterator; \
1138 typedef ConstImageIterator<VALUETYPE> const_iterator; \
1139 typedef typename AccessorTraits<VALUETYPE >::default_const_accessor DefaultAccessor; \
1140 typedef DefaultAccessor default_accessor; \
1141 typedef VigraTrueType hasConstantStrides; \
1144 struct IteratorTraits<StridedImageIterator<VALUETYPE > > \
1145 : public IteratorTraitsBase<StridedImageIterator<VALUETYPE > > \
1147 typedef StridedImageIterator<VALUETYPE> mutable_iterator; \
1148 typedef ConstStridedImageIterator<VALUETYPE> const_iterator; \
1149 typedef typename AccessorTraits<VALUETYPE >::default_accessor DefaultAccessor; \
1150 typedef DefaultAccessor default_accessor; \
1151 typedef VigraTrueType hasConstantStrides; \
1155 struct IteratorTraits<ConstStridedImageIterator<VALUETYPE > > \
1156 : public IteratorTraitsBase<ConstStridedImageIterator<VALUETYPE > > \
1158 typedef StridedImageIterator<VALUETYPE> mutable_iterator; \
1159 typedef ConstStridedImageIterator<VALUETYPE> const_iterator; \
1160 typedef typename AccessorTraits<VALUETYPE >::default_const_accessor DefaultAccessor; \
1161 typedef DefaultAccessor default_accessor; \
1162 typedef VigraTrueType hasConstantStrides; \
1165 VIGRA_DEFINE_ITERATORTRAITS(RGBValue<unsigned char>)
1166 VIGRA_DEFINE_ITERATORTRAITS(RGBValue<
short>)
1167 VIGRA_DEFINE_ITERATORTRAITS(RGBValue<
int>)
1168 VIGRA_DEFINE_ITERATORTRAITS(RGBValue<
float>)
1169 VIGRA_DEFINE_ITERATORTRAITS(RGBValue<
double>)
1171 #define VIGRA_PIXELTYPE TinyVector<unsigned char, 2>
1172 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1173 #undef VIGRA_PIXELTYPE
1174 #define VIGRA_PIXELTYPE TinyVector<unsigned char, 3>
1175 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1176 #undef VIGRA_PIXELTYPE
1177 #define VIGRA_PIXELTYPE TinyVector<unsigned char, 4>
1178 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1179 #undef VIGRA_PIXELTYPE
1180 #define VIGRA_PIXELTYPE TinyVector<short, 2>
1181 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1182 #undef VIGRA_PIXELTYPE
1183 #define VIGRA_PIXELTYPE TinyVector<short, 3>
1184 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1185 #undef VIGRA_PIXELTYPE
1186 #define VIGRA_PIXELTYPE TinyVector<short, 4>
1187 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1188 #undef VIGRA_PIXELTYPE
1189 #define VIGRA_PIXELTYPE TinyVector<int, 2>
1190 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1191 #undef VIGRA_PIXELTYPE
1192 #define VIGRA_PIXELTYPE TinyVector<int, 3>
1193 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1194 #undef VIGRA_PIXELTYPE
1195 #define VIGRA_PIXELTYPE TinyVector<int, 4>
1196 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1197 #undef VIGRA_PIXELTYPE
1198 #define VIGRA_PIXELTYPE TinyVector<float, 2>
1199 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1200 #undef VIGRA_PIXELTYPE
1201 #define VIGRA_PIXELTYPE TinyVector<float, 3>
1202 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1203 #undef VIGRA_PIXELTYPE
1204 #define VIGRA_PIXELTYPE TinyVector<float, 4>
1205 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1206 #undef VIGRA_PIXELTYPE
1207 #define VIGRA_PIXELTYPE TinyVector<double, 2>
1208 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1209 #undef VIGRA_PIXELTYPE
1210 #define VIGRA_PIXELTYPE TinyVector<double, 3>
1211 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1212 #undef VIGRA_PIXELTYPE
1213 #define VIGRA_PIXELTYPE TinyVector<double, 4>
1214 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1215 #undef VIGRA_PIXELTYPE
1217 #undef VIGRA_DEFINE_ITERATORTRAITS
1219 #endif // NO_PARTIAL_TEMPLATE_SPECIALIZATION
1221 template <
class PIXELTYPE>
1222 class ConstValueIteratorPolicy
1226 typedef PIXELTYPE value_type;
1227 typedef std::ptrdiff_t difference_type;
1228 typedef PIXELTYPE
const & reference;
1229 typedef PIXELTYPE
const & index_reference;
1230 typedef PIXELTYPE
const * pointer;
1231 typedef std::random_access_iterator_tag iterator_category;
1235 BaseType(PIXELTYPE
const & v = PIXELTYPE(), std::ptrdiff_t p = 0)
1243 static void initialize(BaseType & ) {}
1245 static reference dereference(BaseType
const & d)
1248 static index_reference dereference(BaseType d, difference_type)
1253 static bool equal(BaseType
const & d1, BaseType
const & d2)
1254 {
return d1.pos == d2.pos; }
1256 static bool less(BaseType
const & d1, BaseType
const & d2)
1257 {
return d1.pos < d2.pos; }
1259 static difference_type difference(BaseType
const & d1, BaseType
const & d2)
1260 {
return d1.pos - d2.pos; }
1262 static void increment(BaseType & d)
1265 static void decrement(BaseType & d)
1268 static void advance(BaseType & d, difference_type n)
1288 template <
class PIXELTYPE>
1340 : value_(NumericTraits<PIXELTYPE>::zero()),
x(0),
y(0)
1346 : value_(v),
x(0),
y(0)
1352 : value_(v.value_),
x(v.
x),
y(v.
y)
1415 return (
x == r.
x) && (
y == r.
y);
1422 return (
x != r.
x) || (
y != r.
y);
1456 {
return row_iterator(
typename row_iterator::BaseType(value_,
x)); }
1476 #ifndef NO_PARTIAL_TEMPLATE_SPECIALIZATION
1482 typedef Iterator iterator;
1483 typedef typename iterator::iterator_category iterator_category;
1484 typedef typename iterator::value_type value_type;
1485 typedef typename iterator::reference reference;
1486 typedef typename iterator::index_reference index_reference;
1487 typedef typename iterator::pointer pointer;
1488 typedef typename iterator::difference_type difference_type;
1489 typedef typename iterator::row_iterator row_iterator;
1490 typedef typename iterator::column_iterator column_iterator;
1493 typedef VigraTrueType hasConstantStrides;
1564 #endif // VIGRA_IMAGEITERATOR_HXX
POINTER pointer
Definition: imageiterator.hxx:593
ConstValueIterator(PixelType const &v)
Definition: imageiterator.hxx:1345
PIXELTYPE PixelType
Definition: imageiterator.hxx:581
Export associated information for each image iterator.
Definition: iteratortraits.hxx:109
image_traverser_tag iterator_category
Definition: imageiterator.hxx:601
ImageIteratorBase()
Definition: imageiterator.hxx:706
IteratorAdaptor< ConstValueIteratorPolicy< PIXELTYPE > > column_iterator
Definition: imageiterator.hxx:1326
MoveX x
Definition: imageiterator.hxx:660
int y
Definition: diff2d.hxx:392
pointer operator->() const
Definition: imageiterator.hxx:778
Diff2D operator-(Diff2D const &a, Diff2D const &b)
Definition: diff2d.hxx:711
ConstValueIterator()
Definition: imageiterator.hxx:1339
REFERENCE reference
Definition: imageiterator.hxx:585
MoveY y
Definition: imageiterator.hxx:673
ImageIteratorBase(pointer base, std::ptrdiff_t ystride)
Definition: imageiterator.hxx:683
pointer operator->() const
Definition: imageiterator.hxx:1434
ConstValueIterator & operator-=(Diff2D const &d)
Definition: imageiterator.hxx:1379
int x
Definition: diff2d.hxx:385
ImageIteratorBase & operator=(ImageIteratorBase const &rhs)
Definition: imageiterator.hxx:712
RowIteratorSelector::res row_iterator
Definition: imageiterator.hxx:605
ConstValueIterator operator+(Diff2D const &d) const
Definition: imageiterator.hxx:1388
ImageIteratorBase(pointer base, std::ptrdiff_t xstride, std::ptrdiff_t ystride)
Definition: imageiterator.hxx:694
Two dimensional difference vector.
Definition: diff2d.hxx:185
ColumnIteratorSelector::res column_iterator
Definition: imageiterator.hxx:609
std::ptrdiff_t y
refer to y coordinate
Definition: imageiterator.hxx:1468
ImageIterator(pointer base, std::ptrdiff_t ystride)
Definition: imageiterator.hxx:866
bool operator!=(ImageIteratorBase const &rhs) const
Definition: imageiterator.hxx:632
ImageIterator()
Definition: imageiterator.hxx:871
Standard 2D random access const iterator for images that store the data as a linear array...
Definition: imageiterator.hxx:893
IMAGEITERATOR & operator-=(difference_type const &s)
Definition: imageiterator.hxx:735
StridedImageIterator(pointer base, std::ptrdiff_t ystride, std::ptrdiff_t xskip, std::ptrdiff_t yskip)
Definition: imageiterator.hxx:981
StridedImageIterator()
Definition: imageiterator.hxx:986
ConstValueIterator & operator=(ConstValueIterator const &v)
Definition: imageiterator.hxx:1357
Diff2D CoordinateIterator
Simulate an image where each pixel contains its coordinate.
Definition: imageiterator.hxx:1558
FFTWComplex< R > & operator-=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
subtract-assignment
Definition: fftw3.hxx:867
ConstValueIterator & operator+=(Diff2D const &d)
Definition: imageiterator.hxx:1370
ConstStridedImageIterator(StridedImageIterator< PIXELTYPE > const &o)
Definition: imageiterator.hxx:1048
bool operator!=(ConstValueIterator const &r) const
Definition: imageiterator.hxx:1420
PIXELTYPE value_type
Definition: imageiterator.hxx:577
Const iterator to be used when pixels are to be skipped.
Definition: imageiterator.hxx:1026
bool operator<=(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
less or equal
Definition: fixedpoint.hxx:521
reference operator*() const
Definition: imageiterator.hxx:1427
difference_type operator-(ImageIteratorBase const &rhs) const
Definition: imageiterator.hxx:639
FFTWComplex< R > & operator+=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
add-assignment
Definition: fftw3.hxx:859
bool operator==(ImageIteratorBase const &rhs) const
Definition: imageiterator.hxx:625
vigra::detail::DirectionSelector< StridedArrayTag >::template type< std::ptrdiff_t > MoveY
Definition: imageiterator.hxx:619
PIXELTYPE const * pointer
Definition: imageiterator.hxx:1310
IteratorAdaptor< ConstValueIteratorPolicy< PIXELTYPE > > row_iterator
Definition: imageiterator.hxx:1322
bool operator!=(FFTWComplex< R > const &a, const FFTWComplex< R > &b)
not equal
Definition: fftw3.hxx:841
ConstStridedImageIterator & operator=(StridedImageIterator< PIXELTYPE > const &o)
Definition: imageiterator.hxx:1058
std::ptrdiff_t MoveY
Definition: imageiterator.hxx:1334
bool operator==(FFTWComplex< R > const &a, const FFTWComplex< R > &b)
equal
Definition: fftw3.hxx:825
Diff2D difference_type
Definition: imageiterator.hxx:1314
index_reference operator[](Diff2D const &) const
Definition: imageiterator.hxx:1448
Definition: metaprogramming.hxx:116
IMAGEITERATOR operator-(difference_type const &s) const
Definition: imageiterator.hxx:755
Diff2D difference_type
Definition: imageiterator.hxx:597
bool operator<(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
less than
Definition: fixedpoint.hxx:512
Iterator that always returns the constant specified in the constructor.
Definition: imageiterator.hxx:1289
ConstValueIterator operator-(Diff2D const &d) const
Definition: imageiterator.hxx:1397
Standard 2D random access iterator for images that store the data in a linear array.
Definition: imageiterator.hxx:848
ConstValueIterator(ConstValueIterator const &v)
Definition: imageiterator.hxx:1351
Encapsulate read access to the values an iterator points to.
Definition: accessor.hxx:269
bool operator>=(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
greater or equal
Definition: fixedpoint.hxx:539
index_reference operator[](Diff2D const &d) const
Definition: imageiterator.hxx:786
ConstImageIterator(pointer base, std::ptrdiff_t ystride)
Definition: imageiterator.hxx:911
vigra::detail::DirectionSelector< StridedOrUnstrided >::template type< pointer > MoveX
Definition: imageiterator.hxx:614
ConstStridedImageIterator(pointer base, std::ptrdiff_t ystride, std::ptrdiff_t xskip, std::ptrdiff_t yskip)
Definition: imageiterator.hxx:1043
row_iterator rowIterator() const
Definition: imageiterator.hxx:1455
image_traverser_tag iterator_category
Definition: imageiterator.hxx:1318
std::ptrdiff_t MoveX
Definition: imageiterator.hxx:1330
IMAGEITERATOR operator+(difference_type const &s) const
Definition: imageiterator.hxx:744
PIXELTYPE const & reference
Definition: imageiterator.hxx:1302
index_reference operator()(std::ptrdiff_t dx, std::ptrdiff_t dy) const
Definition: imageiterator.hxx:794
ImageIteratorBase(ImageIteratorBase const &rhs)
Definition: imageiterator.hxx:700
PIXELTYPE const & index_reference
Definition: imageiterator.hxx:1306
Iterator to be used when pixels are to be skipped.
Definition: imageiterator.hxx:966
IMAGEITERATOR & operator+=(difference_type const &s)
Definition: imageiterator.hxx:727
bool operator>(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
greater
Definition: fixedpoint.hxx:530
Quickly create 1-dimensional iterator adapters.
Definition: iteratoradapter.hxx:147
std::ptrdiff_t x
refer to x coordinate
Definition: imageiterator.hxx:1466
pointer operator[](std::ptrdiff_t dy) const
Definition: imageiterator.hxx:803
index_reference operator()(std::ptrdiff_t const &, std::ptrdiff_t const &) const
Definition: imageiterator.hxx:1441
column_iterator columnIterator() const
Definition: imageiterator.hxx:1460
reference operator*() const
Definition: imageiterator.hxx:770
PIXELTYPE value_type
Definition: imageiterator.hxx:1294
Diff2D operator-(ConstValueIterator const &r) const
Definition: imageiterator.hxx:1406
ConstImageIterator()
Definition: imageiterator.hxx:920
REFERENCE index_reference
Definition: imageiterator.hxx:589
Base class for 2D random access iterators.
Definition: imageiterator.hxx:563
PIXELTYPE PixelType
Definition: imageiterator.hxx:1298
ConstStridedImageIterator()
Definition: imageiterator.hxx:1053
bool operator==(ConstValueIterator const &r) const
Definition: imageiterator.hxx:1413