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