Boost GIL


iterator_from_2d.hpp
1 //
2 // Copyright 2005-2007 Adobe Systems Incorporated
3 //
4 // Distributed under the Boost Software License, Version 1.0
5 // See accompanying file LICENSE_1_0.txt or copy at
6 // http://www.boost.org/LICENSE_1_0.txt
7 //
8 #ifndef BOOST_GIL_ITERATOR_FROM_2D_HPP
9 #define BOOST_GIL_ITERATOR_FROM_2D_HPP
10 
11 #include <boost/gil/concepts.hpp>
12 #include <boost/gil/locator.hpp>
13 #include <boost/gil/pixel_iterator.hpp>
14 #include <boost/gil/point.hpp>
15 
16 #include <boost/iterator/iterator_facade.hpp>
17 
18 #include <cassert>
19 
20 namespace boost { namespace gil {
21 
23 
29 
30 
34 
35 
41 
42 template <typename Loc2> // Models PixelLocatorConcept
43 class iterator_from_2d : public iterator_facade<iterator_from_2d<Loc2>,
44  typename Loc2::value_type,
45  std::random_access_iterator_tag,
46  typename Loc2::reference,
47  typename Loc2::coord_t> {
48  GIL_CLASS_REQUIRE(Loc2, boost::gil, PixelLocatorConcept)
49 public:
50  typedef iterator_facade<iterator_from_2d<Loc2>,
51  typename Loc2::value_type,
52  std::random_access_iterator_tag,
53  typename Loc2::reference,
54  typename Loc2::coord_t> parent_t;
55  typedef typename parent_t::reference reference;
56  typedef typename parent_t::difference_type difference_type;
57  typedef typename Loc2::x_iterator x_iterator;
58  typedef typename Loc2::point_t point_t;
59 
60  std::ptrdiff_t width() const { return _width; } // number of pixels per image row
61  std::ptrdiff_t x_pos() const { return _coords.x; } // current x position
62  std::ptrdiff_t y_pos() const { return _coords.y; } // current y position
63 
66  reference operator[](difference_type d) const { return *(*this+d); }
67 
68  bool is_1d_traversable() const { return _p.is_1d_traversable(width()); } // is there no gap at the end of each row?
69  x_iterator& x() { return _p.x(); }
70 
71  iterator_from_2d(){}
72  iterator_from_2d(const Loc2& p, std::ptrdiff_t width, std::ptrdiff_t x=0, std::ptrdiff_t y=0) : _coords(x,y), _width(width), _p(p) {}
73  iterator_from_2d(const iterator_from_2d& pit) : _coords(pit._coords), _width(pit._width), _p(pit._p) {}
74  template <typename Loc> iterator_from_2d(const iterator_from_2d<Loc>& pit) : _coords(pit._coords), _width(pit._width), _p(pit._p) {}
75 
76 private:
77  template <typename Loc> friend class iterator_from_2d;
78  friend class boost::iterator_core_access;
79  reference dereference() const { return *_p; }
80  void increment() {
81  ++_coords.x;
82  ++_p.x();
83  if (_coords.x>=_width) {
84  _coords.x=0;
85  ++_coords.y;
86  _p+=point_t(-_width,1);
87  }
88  }
89  void decrement() {
90  --_coords.x;
91  --_p.x();
92  if (_coords.x<0) {
93  _coords.x=_width-1;
94  --_coords.y;
95  _p+=point_t(_width,-1);
96  }
97  }
98 
99  BOOST_FORCEINLINE void advance(difference_type d) {
100  if (_width==0) return; // unfortunately we need to check for that. Default-constructed images have width of 0 and the code below will throw if executed.
101  point_t delta;
102  if (_coords.x+d>=0) { // not going back to a previous row?
103  delta.x=(_coords.x+(std::ptrdiff_t)d)%_width - _coords.x;
104  delta.y=(_coords.x+(std::ptrdiff_t)d)/_width;
105  } else {
106  delta.x=(_coords.x+(std::ptrdiff_t)d*(1-_width))%_width -_coords.x;
107  delta.y=-(_width-_coords.x-(std::ptrdiff_t)d-1)/_width;
108  }
109  _p+=delta;
110  _coords.x+=delta.x;
111  _coords.y+=delta.y;
112  }
113 
114  difference_type distance_to(const iterator_from_2d& it) const {
115  if (_width==0) return 0;
116  return (it.y_pos()-_coords.y)*_width + (it.x_pos()-_coords.x);
117  }
118 
119  bool equal(const iterator_from_2d& it) const {
120  assert(_width==it.width()); // they must belong to the same image
121  return _coords==it._coords && _p==it._p;
122  }
123 
124  point_t _coords;
125  std::ptrdiff_t _width;
126  Loc2 _p;
127 };
128 
129 template <typename Loc> // Models PixelLocatorConcept
130 struct const_iterator_type<iterator_from_2d<Loc> > {
131  typedef iterator_from_2d<typename Loc::const_t> type;
132 };
133 
134 template <typename Loc> // Models PixelLocatorConcept
135 struct iterator_is_mutable<iterator_from_2d<Loc> > : public iterator_is_mutable<typename Loc::x_iterator> {};
136 
137 
139 // HasDynamicXStepTypeConcept
141 
142 template <typename Loc>
143 struct dynamic_x_step_type<iterator_from_2d<Loc> > {
144  typedef iterator_from_2d<typename dynamic_x_step_type<Loc>::type> type;
145 };
146 
147 
149 // PixelBasedConcept
151 
152 template <typename Loc> // Models PixelLocatorConcept
153 struct color_space_type<iterator_from_2d<Loc> > : public color_space_type<Loc> {};
154 
155 template <typename Loc> // Models PixelLocatorConcept
156 struct channel_mapping_type<iterator_from_2d<Loc> > : public channel_mapping_type<Loc> {};
157 
158 template <typename Loc> // Models PixelLocatorConcept
159 struct is_planar<iterator_from_2d<Loc> > : public is_planar<Loc> {};
160 
161 template <typename Loc> // Models PixelLocatorConcept
162 struct channel_type<iterator_from_2d<Loc> > : public channel_type<Loc> {};
163 
164 } } // namespace boost::gil
165 
166 #endif
Provides 1D random-access navigation to the pixels of the image. Models: PixelIteratorConcept, PixelBasedConcept, HasDynamicXStepTypeConcept.
Definition: iterator_from_2d.hpp:43
GIL's 2-dimensional locator over immutable GIL pixels.
Definition: concepts.hpp:1606
BOOST_FORCEINLINE bool equal(boost::gil::iterator_from_2d< Loc1 > first, boost::gil::iterator_from_2d< Loc1 > last, boost::gil::iterator_from_2d< Loc2 > first2)
std::equal(I1,I1,I2) with I1 and I2 being a iterator_from_2d
Definition: algorithm.hpp:915
reference operator[](difference_type d) const
Definition: iterator_from_2d.hpp:66