1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
/*
Copyright 2005-2007 Adobe Systems Incorporated
Use, modification and distribution are subject to the Boost Software License,
Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt).
See http://opensource.adobe.com/gil for most recent version including documentation.
*/
/*************************************************************************************************/
#ifndef GIL_ITERATOR_FROM_2D_H
#define GIL_ITERATOR_FROM_2D_H
////////////////////////////////////////////////////////////////////////////////////////
/// \file
/// \brief pixel step iterator, pixel image iterator and pixel dereference iterator
/// \author Lubomir Bourdev and Hailin Jin \n
/// Adobe Systems Incorporated
/// \date 2005-2007 \n Last updated on September 18, 2007
///
////////////////////////////////////////////////////////////////////////////////////////
#include <cassert>
#include <boost/iterator/iterator_facade.hpp>
#include "gil_concept.hpp"
#include "gil_config.hpp"
#include "pixel_iterator.hpp"
#include "locator.hpp"
namespace boost { namespace gil {
////////////////////////////////////////////////////////////////////////////////////////
///
/// ITERATOR FROM 2D ADAPTOR
///
////////////////////////////////////////////////////////////////////////////////////////
/// \defgroup PixelIteratorModelFromLocator iterator_from_2d
/// \ingroup PixelIteratorModel
/// \brief An iterator over two-dimensional locator. Useful for iterating over the pixels of an image view. Models PixelIteratorConcept, PixelBasedConcept, HasDynamicXStepTypeConcept
/// \ingroup PixelIteratorModelFromLocator PixelBasedModel
/// \brief Provides 1D random-access navigation to the pixels of the image. Models: PixelIteratorConcept, PixelBasedConcept, HasDynamicXStepTypeConcept
///
/// Pixels are traversed from the top to the bottom row and from the left to the right
/// within each row
template <typename Loc2> // Models PixelLocatorConcept
class iterator_from_2d : public iterator_facade<iterator_from_2d<Loc2>,
typename Loc2::value_type,
std::random_access_iterator_tag,
typename Loc2::reference,
typename Loc2::coord_t> {
GIL_CLASS_REQUIRE(Loc2, boost::gil, PixelLocatorConcept)
public:
typedef iterator_facade<iterator_from_2d<Loc2>,
typename Loc2::value_type,
std::random_access_iterator_tag,
typename Loc2::reference,
typename Loc2::coord_t> parent_t;
typedef typename parent_t::reference reference;
typedef typename parent_t::difference_type difference_type;
typedef typename Loc2::x_iterator x_iterator;
typedef typename Loc2::point_t point_t;
std::ptrdiff_t width() const { return _width; } // number of pixels per image row
std::ptrdiff_t x_pos() const { return _coords.x; } // current x position
std::ptrdiff_t y_pos() const { return _coords.y; } // current y position
/// For some reason operator[] provided by iterator_adaptor returns a custom class that is convertible to reference
/// We require our own reference because it is registered in iterator_traits
reference operator[](difference_type d) const { return *(*this+d); }
bool is_1d_traversable() const { return _p.is_1d_traversable(width()); } // is there no gap at the end of each row?
x_iterator& x() { return _p.x(); }
iterator_from_2d(){}
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) {}
iterator_from_2d(const iterator_from_2d& pit) : _coords(pit._coords), _width(pit._width), _p(pit._p) {}
template <typename Loc> iterator_from_2d(const iterator_from_2d<Loc>& pit) : _coords(pit._coords), _width(pit._width), _p(pit._p) {}
private:
template <typename Loc> friend class iterator_from_2d;
friend class boost::iterator_core_access;
reference dereference() const { return *_p; }
void increment() {
++_coords.x;
++_p.x();
if (_coords.x>=_width) {
_coords.x=0;
++_coords.y;
_p+=point_t(-_width,1);
}
}
void decrement() {
--_coords.x;
--_p.x();
if (_coords.x<0) {
_coords.x=_width-1;
--_coords.y;
_p+=point_t(_width,-1);
}
}
GIL_FORCEINLINE void advance(difference_type d) {
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.
point_t delta;
if (_coords.x+d>=0) { // not going back to a previous row?
delta.x=(_coords.x+(std::ptrdiff_t)d)%_width - _coords.x;
delta.y=(_coords.x+(std::ptrdiff_t)d)/_width;
} else {
delta.x=(_coords.x+(std::ptrdiff_t)d*(1-_width))%_width -_coords.x;
delta.y=-(_width-_coords.x-(std::ptrdiff_t)d-1)/_width;
}
_p+=delta;
_coords.x+=delta.x;
_coords.y+=delta.y;
}
difference_type distance_to(const iterator_from_2d& it) const {
if (_width==0) return 0;
return (it.y_pos()-_coords.y)*_width + (it.x_pos()-_coords.x);
}
bool equal(const iterator_from_2d& it) const {
assert(_width==it.width()); // they must belong to the same image
return _coords==it._coords && _p==it._p;
}
point2<std::ptrdiff_t> _coords;
std::ptrdiff_t _width;
Loc2 _p;
};
template <typename Loc> // Models PixelLocatorConcept
struct const_iterator_type<iterator_from_2d<Loc> > {
typedef iterator_from_2d<typename Loc::const_t> type;
};
template <typename Loc> // Models PixelLocatorConcept
struct iterator_is_mutable<iterator_from_2d<Loc> > : public iterator_is_mutable<typename Loc::x_iterator> {};
/////////////////////////////
// HasDynamicXStepTypeConcept
/////////////////////////////
template <typename Loc>
struct dynamic_x_step_type<iterator_from_2d<Loc> > {
typedef iterator_from_2d<typename dynamic_x_step_type<Loc>::type> type;
};
/////////////////////////////
// PixelBasedConcept
/////////////////////////////
template <typename Loc> // Models PixelLocatorConcept
struct color_space_type<iterator_from_2d<Loc> > : public color_space_type<Loc> {};
template <typename Loc> // Models PixelLocatorConcept
struct channel_mapping_type<iterator_from_2d<Loc> > : public channel_mapping_type<Loc> {};
template <typename Loc> // Models PixelLocatorConcept
struct is_planar<iterator_from_2d<Loc> > : public is_planar<Loc> {};
template <typename Loc> // Models PixelLocatorConcept
struct channel_type<iterator_from_2d<Loc> > : public channel_type<Loc> {};
} } // namespace boost::gil
#endif
|
