37 #ifndef VIGRA_IMAGEITERATOR_HXX
38 #define VIGRA_IMAGEITERATOR_HXX
40 #include "utilities.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_;}
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_; }
412 {
return current_ - rhs.current_; }
417 T operator()(
int d)
const
418 {
return current_ + d; }
425 class DirectionSelector<StridedArrayTag>
433 type(
int 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+=(
int dy) {current_ += dy*stride_; }
455 void operator-=(
int 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_); }
476 {
return (current_ - rhs.current_) / stride_; }
481 T operator()(
int d)
const
482 {
return current_ + d*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_));
561 template <
class IMAGEITERATOR,
562 class PIXELTYPE,
class REFERENCE,
class POINTER,
563 class StridedOrUnstrided = UnstridedArrayTag>
567 vigra::detail::LinearIteratorSelector<StridedOrUnstrided>::template type<ImageIteratorBase>
570 vigra::detail::LinearIteratorSelector<StridedArrayTag>::template type<ImageIteratorBase>
571 ColumnIteratorSelector;
574 PIXELTYPE, REFERENCE, POINTER, StridedOrUnstrided>
self_type;
615 vigra::detail::DirectionSelector<StridedOrUnstrided>::template type<pointer>
MoveX;
620 vigra::detail::DirectionSelector<StridedArrayTag>::template type<int>
MoveY;
628 return (
x == rhs.
x) && (
y == rhs.
y);
635 return (
x != rhs.
x) || (
y != rhs.
y);
732 return static_cast<IMAGEITERATOR &
>(*this);
740 return static_cast<IMAGEITERATOR &
>(*this);
747 IMAGEITERATOR ret(static_cast<IMAGEITERATOR const &>(*
this));
758 IMAGEITERATOR ret(static_cast<IMAGEITERATOR const &>(*
this));
789 return *current(d.
x, d.
y);
797 return *current(dx, dy);
812 return RowIteratorSelector::construct(current(),
x);
817 return ColumnIteratorSelector::construct(current(),
y);
823 {
return x() +
y(); }
825 pointer current(
int dx,
int dy)
const
826 {
return x(dx) +
y(dy); }
849 template <
class PIXELTYPE>
852 PIXELTYPE, PIXELTYPE &, PIXELTYPE *>
856 PIXELTYPE, PIXELTYPE &, PIXELTYPE *>
Base;
869 :
Base(base, ystride)
895 template <
class PIXELTYPE>
898 PIXELTYPE, PIXELTYPE const &, PIXELTYPE const *>
902 PIXELTYPE, PIXELTYPE
const &, PIXELTYPE
const *>
Base;
915 :
Base(base, ystride)
969 template <
class PIXELTYPE>
972 PIXELTYPE, PIXELTYPE &, PIXELTYPE *, StridedArrayTag>
986 :
Base(base, xskip, ystride*yskip)
1030 template <
class PIXELTYPE>
1033 PIXELTYPE, PIXELTYPE const &, PIXELTYPE const *,
1038 PIXELTYPE, PIXELTYPE
const &, PIXELTYPE
const *,
1049 :
Base(base, xskip, ystride*yskip)
1078 #ifndef NO_PARTIAL_TEMPLATE_SPECIALIZATION
1081 struct IteratorTraits<ImageIterator<T> >
1082 :
public IteratorTraitsBase<ImageIterator<T> >
1084 typedef ImageIterator<T> mutable_iterator;
1085 typedef ConstImageIterator<T> const_iterator;
1086 typedef typename AccessorTraits<T>::default_accessor DefaultAccessor;
1087 typedef DefaultAccessor default_accessor;
1088 typedef VigraTrueType hasConstantStrides;
1092 struct IteratorTraits<ConstImageIterator<T> >
1093 :
public IteratorTraitsBase<ConstImageIterator<T> >
1095 typedef ImageIterator<T> mutable_iterator;
1096 typedef ConstImageIterator<T> const_iterator;
1097 typedef typename AccessorTraits<T>::default_const_accessor DefaultAccessor;
1098 typedef DefaultAccessor default_accessor;
1099 typedef VigraTrueType hasConstantStrides;
1103 struct IteratorTraits<StridedImageIterator<T> >
1104 :
public IteratorTraitsBase<StridedImageIterator<T> >
1106 typedef StridedImageIterator<T> mutable_iterator;
1107 typedef ConstStridedImageIterator<T> const_iterator;
1108 typedef typename AccessorTraits<T>::default_accessor DefaultAccessor;
1109 typedef DefaultAccessor default_accessor;
1110 typedef VigraTrueType hasConstantStrides;
1114 struct IteratorTraits<ConstStridedImageIterator<T> >
1115 :
public IteratorTraitsBase<ConstStridedImageIterator<T> >
1117 typedef StridedImageIterator<T> mutable_iterator;
1118 typedef ConstStridedImageIterator<T> const_iterator;
1119 typedef typename AccessorTraits<T>::default_const_accessor DefaultAccessor;
1120 typedef DefaultAccessor default_accessor;
1121 typedef VigraTrueType hasConstantStrides;
1124 #else // NO_PARTIAL_TEMPLATE_SPECIALIZATION
1126 #define VIGRA_DEFINE_ITERATORTRAITS(VALUETYPE) \
1128 struct IteratorTraits<ImageIterator<VALUETYPE > > \
1129 : public IteratorTraitsBase<ImageIterator<VALUETYPE > > \
1131 typedef ImageIterator<VALUETYPE> mutable_iterator; \
1132 typedef ConstImageIterator<VALUETYPE> const_iterator; \
1133 typedef typename AccessorTraits<VALUETYPE >::default_accessor DefaultAccessor; \
1134 typedef DefaultAccessor default_accessor; \
1135 typedef VigraTrueType hasConstantStrides; \
1139 struct IteratorTraits<ConstImageIterator<VALUETYPE > > \
1140 : public IteratorTraitsBase<ConstImageIterator<VALUETYPE > > \
1142 typedef ImageIterator<VALUETYPE> mutable_iterator; \
1143 typedef ConstImageIterator<VALUETYPE> const_iterator; \
1144 typedef typename AccessorTraits<VALUETYPE >::default_const_accessor DefaultAccessor; \
1145 typedef DefaultAccessor default_accessor; \
1146 typedef VigraTrueType hasConstantStrides; \
1149 struct IteratorTraits<StridedImageIterator<VALUETYPE > > \
1150 : public IteratorTraitsBase<StridedImageIterator<VALUETYPE > > \
1152 typedef StridedImageIterator<VALUETYPE> mutable_iterator; \
1153 typedef ConstStridedImageIterator<VALUETYPE> const_iterator; \
1154 typedef typename AccessorTraits<VALUETYPE >::default_accessor DefaultAccessor; \
1155 typedef DefaultAccessor default_accessor; \
1156 typedef VigraTrueType hasConstantStrides; \
1160 struct IteratorTraits<ConstStridedImageIterator<VALUETYPE > > \
1161 : public IteratorTraitsBase<ConstStridedImageIterator<VALUETYPE > > \
1163 typedef StridedImageIterator<VALUETYPE> mutable_iterator; \
1164 typedef ConstStridedImageIterator<VALUETYPE> const_iterator; \
1165 typedef typename AccessorTraits<VALUETYPE >::default_const_accessor DefaultAccessor; \
1166 typedef DefaultAccessor default_accessor; \
1167 typedef VigraTrueType hasConstantStrides; \
1170 VIGRA_DEFINE_ITERATORTRAITS(RGBValue<unsigned char>)
1171 VIGRA_DEFINE_ITERATORTRAITS(RGBValue<
short>)
1172 VIGRA_DEFINE_ITERATORTRAITS(RGBValue<
int>)
1173 VIGRA_DEFINE_ITERATORTRAITS(RGBValue<
float>)
1174 VIGRA_DEFINE_ITERATORTRAITS(RGBValue<
double>)
1176 #define VIGRA_PIXELTYPE TinyVector<unsigned char, 2>
1177 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1178 #undef VIGRA_PIXELTYPE
1179 #define VIGRA_PIXELTYPE TinyVector<unsigned char, 3>
1180 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1181 #undef VIGRA_PIXELTYPE
1182 #define VIGRA_PIXELTYPE TinyVector<unsigned char, 4>
1183 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1184 #undef VIGRA_PIXELTYPE
1185 #define VIGRA_PIXELTYPE TinyVector<short, 2>
1186 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1187 #undef VIGRA_PIXELTYPE
1188 #define VIGRA_PIXELTYPE TinyVector<short, 3>
1189 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1190 #undef VIGRA_PIXELTYPE
1191 #define VIGRA_PIXELTYPE TinyVector<short, 4>
1192 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1193 #undef VIGRA_PIXELTYPE
1194 #define VIGRA_PIXELTYPE TinyVector<int, 2>
1195 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1196 #undef VIGRA_PIXELTYPE
1197 #define VIGRA_PIXELTYPE TinyVector<int, 3>
1198 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1199 #undef VIGRA_PIXELTYPE
1200 #define VIGRA_PIXELTYPE TinyVector<int, 4>
1201 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1202 #undef VIGRA_PIXELTYPE
1203 #define VIGRA_PIXELTYPE TinyVector<float, 2>
1204 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1205 #undef VIGRA_PIXELTYPE
1206 #define VIGRA_PIXELTYPE TinyVector<float, 3>
1207 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1208 #undef VIGRA_PIXELTYPE
1209 #define VIGRA_PIXELTYPE TinyVector<float, 4>
1210 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1211 #undef VIGRA_PIXELTYPE
1212 #define VIGRA_PIXELTYPE TinyVector<double, 2>
1213 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1214 #undef VIGRA_PIXELTYPE
1215 #define VIGRA_PIXELTYPE TinyVector<double, 3>
1216 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1217 #undef VIGRA_PIXELTYPE
1218 #define VIGRA_PIXELTYPE TinyVector<double, 4>
1219 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
1220 #undef VIGRA_PIXELTYPE
1222 #undef VIGRA_DEFINE_ITERATORTRAITS
1224 #endif // NO_PARTIAL_TEMPLATE_SPECIALIZATION
1226 template <
class PIXELTYPE>
1227 class ConstValueIteratorPolicy
1231 typedef PIXELTYPE value_type;
1232 typedef int difference_type;
1233 typedef PIXELTYPE
const & reference;
1234 typedef PIXELTYPE
const & index_reference;
1235 typedef PIXELTYPE
const * pointer;
1236 typedef std::random_access_iterator_tag iterator_category;
1240 BaseType(PIXELTYPE
const & v = PIXELTYPE(),
int p = 0)
1248 static void initialize(BaseType & d) {}
1250 static reference dereference(BaseType
const & d)
1253 static index_reference dereference(BaseType d, difference_type)
1258 static bool equal(BaseType
const & d1, BaseType
const & d2)
1259 {
return d1.pos == d2.pos; }
1261 static bool less(BaseType
const & d1, BaseType
const & d2)
1262 {
return d1.pos < d2.pos; }
1264 static difference_type difference(BaseType
const & d1, BaseType
const & d2)
1265 {
return d1.pos - d2.pos; }
1267 static void increment(BaseType & d)
1270 static void decrement(BaseType & d)
1273 static void advance(BaseType & d, difference_type n)
1294 template <
class PIXELTYPE>
1346 : value_(NumericTraits<PIXELTYPE>::zero()),
x(0),
y(0)
1352 : value_(v),
x(0),
y(0)
1358 : value_(v.value_),
x(v.
x),
y(v.
y)
1421 return (
x == r.
x) && (
y == r.
y);
1428 return (
x != r.
x) || (
y != r.
y);
1462 {
return row_iterator(
typename row_iterator::BaseType(value_,
x)); }
1482 #ifndef NO_PARTIAL_TEMPLATE_SPECIALIZATION
1488 typedef Iterator iterator;
1489 typedef typename iterator::iterator_category iterator_category;
1490 typedef typename iterator::value_type value_type;
1491 typedef typename iterator::reference reference;
1492 typedef typename iterator::index_reference index_reference;
1493 typedef typename iterator::pointer pointer;
1494 typedef typename iterator::difference_type difference_type;
1495 typedef typename iterator::row_iterator row_iterator;
1496 typedef typename iterator::column_iterator column_iterator;
1499 typedef VigraTrueType hasConstantStrides;
1571 #endif // VIGRA_IMAGEITERATOR_HXX