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/assert.hpp>
17 #include <boost/iterator/iterator_facade.hpp>
18 
19 namespace boost { namespace gil {
20 
22 
28 
29 
33 
34 
40 
41 template <typename Loc2> // Models PixelLocatorConcept
42 class iterator_from_2d : public iterator_facade<iterator_from_2d<Loc2>,
43  typename Loc2::value_type,
44  std::random_access_iterator_tag,
45  typename Loc2::reference,
46  typename Loc2::coord_t> {
47  BOOST_GIL_CLASS_REQUIRE(Loc2, boost::gil, PixelLocatorConcept)
48 public:
49  using parent_t = iterator_facade<iterator_from_2d<Loc2>,
50  typename Loc2::value_type,
51  std::random_access_iterator_tag,
52  typename Loc2::reference,
53  typename Loc2::coord_t>;
54  using reference = typename parent_t::reference;
55  using difference_type = typename parent_t::difference_type;
56  using x_iterator = typename Loc2::x_iterator;
57  using point_t = typename Loc2::point_t;
58 
59  std::ptrdiff_t width() const { return _width; } // number of pixels per image row
60  std::ptrdiff_t x_pos() const { return _coords.x; } // current x position
61  std::ptrdiff_t y_pos() const { return _coords.y; } // current y position
62 
65  reference operator[](difference_type d) const { return *(*this+d); }
66 
67  bool is_1d_traversable() const { return _p.is_1d_traversable(width()); } // is there no gap at the end of each row?
68  x_iterator& x() { return _p.x(); }
69 
70  iterator_from_2d() = default;
71  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) {}
72  iterator_from_2d(const iterator_from_2d& pit) : _coords(pit._coords), _width(pit._width), _p(pit._p) {}
73  template <typename Loc> iterator_from_2d(const iterator_from_2d<Loc>& pit) : _coords(pit._coords), _width(pit._width), _p(pit._p) {}
74  iterator_from_2d& operator=(iterator_from_2d const& other) = default;
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(iterator_from_2d const& it) const
120  {
121  BOOST_ASSERT(_width == it.width()); // they must belong to the same image
122  return _coords == it._coords && _p == it._p;
123  }
124 
125  point_t _coords;
126  std::ptrdiff_t _width;
127  Loc2 _p;
128 };
129 
130 template <typename Loc> // Models PixelLocatorConcept
131 struct const_iterator_type<iterator_from_2d<Loc> > {
132  using type = iterator_from_2d<typename Loc::const_t>;
133 };
134 
135 template <typename Loc> // Models PixelLocatorConcept
136 struct iterator_is_mutable<iterator_from_2d<Loc> > : public iterator_is_mutable<typename Loc::x_iterator> {};
137 
138 
140 // HasDynamicXStepTypeConcept
142 
143 template <typename Loc>
144 struct dynamic_x_step_type<iterator_from_2d<Loc> > {
145  using type = iterator_from_2d<typename dynamic_x_step_type<Loc>::type>;
146 };
147 
148 
150 // PixelBasedConcept
152 
153 template <typename Loc> // Models PixelLocatorConcept
154 struct color_space_type<iterator_from_2d<Loc> > : public color_space_type<Loc> {};
155 
156 template <typename Loc> // Models PixelLocatorConcept
157 struct channel_mapping_type<iterator_from_2d<Loc> > : public channel_mapping_type<Loc> {};
158 
159 template <typename Loc> // Models PixelLocatorConcept
160 struct is_planar<iterator_from_2d<Loc> > : public is_planar<Loc> {};
161 
162 template <typename Loc> // Models PixelLocatorConcept
163 struct channel_type<iterator_from_2d<Loc> > : public channel_type<Loc> {};
164 
165 } } // namespace boost::gil
166 
167 #endif
Provides 1D random-access navigation to the pixels of the image. Models: PixelIteratorConcept,...
Definition: iterator_from_2d.hpp:42
reference operator[](difference_type d) const
Definition: iterator_from_2d.hpp:65
GIL's 2-dimensional locator over immutable GIL pixels.
Definition: pixel_locator.hpp:291
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:1029