]>
Commit | Line | Data |
---|---|---|
92f5a8d4 TL |
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_PLANAR_PIXEL_ITERATOR_HPP | |
9 | #define BOOST_GIL_PLANAR_PIXEL_ITERATOR_HPP | |
10 | ||
11 | #include <boost/gil/pixel.hpp> | |
12 | #include <boost/gil/step_iterator.hpp> | |
13 | #include <boost/gil/detail/mp11.hpp> | |
7c673cae | 14 | |
92f5a8d4 | 15 | #include <boost/iterator/iterator_facade.hpp> |
7c673cae | 16 | |
7c673cae | 17 | #include <iterator> |
92f5a8d4 | 18 | #include <type_traits> |
7c673cae FG |
19 | |
20 | namespace boost { namespace gil { | |
21 | ||
22 | //forward declaration (as this file is included in planar_pixel_reference.hpp) | |
92f5a8d4 | 23 | template <typename ChannelReference, typename ColorSpace> |
7c673cae FG |
24 | struct planar_pixel_reference; |
25 | ||
92f5a8d4 | 26 | /// \defgroup ColorBaseModelPlanarPtr planar_pixel_iterator |
7c673cae FG |
27 | /// \ingroup ColorBaseModel |
28 | /// \brief A homogeneous color base whose element is a channel iterator. Models HomogeneousColorBaseValueConcept | |
29 | /// This class is used as an iterator to a planar pixel. | |
30 | ||
31 | /// \defgroup PixelIteratorModelPlanarPtr planar_pixel_iterator | |
32 | /// \ingroup PixelIteratorModel | |
33 | /// \brief An iterator over planar pixels. Models PixelIteratorConcept, HomogeneousPixelBasedConcept, MemoryBasedIteratorConcept, HasDynamicXStepTypeConcept | |
34 | ||
35 | //////////////////////////////////////////////////////////////////////////////////////// | |
36 | /// \brief An iterator over planar pixels. Models HomogeneousColorBaseConcept, PixelIteratorConcept, HomogeneousPixelBasedConcept, MemoryBasedIteratorConcept, HasDynamicXStepTypeConcept | |
37 | /// | |
38 | /// Planar pixels have channel data that is not consecutive in memory. | |
39 | /// To abstract this we use classes to represent references and pointers to planar pixels. | |
92f5a8d4 | 40 | /// |
7c673cae FG |
41 | /// \ingroup PixelIteratorModelPlanarPtr ColorBaseModelPlanarPtr PixelBasedModel |
42 | template <typename ChannelPtr, typename ColorSpace> | |
92f5a8d4 TL |
43 | struct planar_pixel_iterator |
44 | : | |
45 | iterator_facade | |
46 | < | |
47 | planar_pixel_iterator<ChannelPtr, ColorSpace>, | |
48 | pixel<typename std::iterator_traits<ChannelPtr>::value_type,layout<ColorSpace>>, | |
49 | std::random_access_iterator_tag, | |
50 | planar_pixel_reference<typename std::iterator_traits<ChannelPtr>::reference, ColorSpace> const | |
51 | >, | |
52 | detail::homogeneous_color_base | |
53 | < | |
54 | ChannelPtr, | |
55 | layout<ColorSpace>, | |
56 | mp11::mp_size<ColorSpace>::value | |
57 | > | |
58 | { | |
7c673cae | 59 | private: |
92f5a8d4 TL |
60 | using parent_t = iterator_facade |
61 | < | |
62 | planar_pixel_iterator<ChannelPtr, ColorSpace>, | |
63 | pixel<typename std::iterator_traits<ChannelPtr>::value_type,layout<ColorSpace>>, | |
64 | std::random_access_iterator_tag, | |
65 | planar_pixel_reference<typename std::iterator_traits<ChannelPtr>::reference, ColorSpace> const | |
66 | >; | |
67 | ||
68 | using color_base_parent_t = detail::homogeneous_color_base | |
69 | < | |
70 | ChannelPtr, | |
71 | layout<ColorSpace>, | |
72 | mp11::mp_size<ColorSpace>::value | |
73 | >; | |
74 | ||
75 | using channel_t = typename std::iterator_traits<ChannelPtr>::value_type; | |
76 | ||
7c673cae | 77 | public: |
92f5a8d4 TL |
78 | using value_type = typename parent_t::value_type; |
79 | using reference = typename parent_t::reference; | |
80 | using difference_type = typename parent_t::difference_type; | |
7c673cae | 81 | |
92f5a8d4 | 82 | planar_pixel_iterator() : color_base_parent_t(0) {} |
7c673cae FG |
83 | planar_pixel_iterator(bool) {} // constructor that does not fill with zero (for performance) |
84 | ||
85 | planar_pixel_iterator(const ChannelPtr& v0, const ChannelPtr& v1) : color_base_parent_t(v0,v1) {} | |
86 | planar_pixel_iterator(const ChannelPtr& v0, const ChannelPtr& v1, const ChannelPtr& v2) : color_base_parent_t(v0,v1,v2) {} | |
87 | planar_pixel_iterator(const ChannelPtr& v0, const ChannelPtr& v1, const ChannelPtr& v2, const ChannelPtr& v3) : color_base_parent_t(v0,v1,v2,v3) {} | |
88 | planar_pixel_iterator(const ChannelPtr& v0, const ChannelPtr& v1, const ChannelPtr& v2, const ChannelPtr& v3, const ChannelPtr& v4) : color_base_parent_t(v0,v1,v2,v3,v4) {} | |
89 | ||
92f5a8d4 | 90 | template <typename IC1,typename C1> |
7c673cae FG |
91 | planar_pixel_iterator(const planar_pixel_iterator<IC1,C1>& ptr) : color_base_parent_t(ptr) {} |
92 | ||
7c673cae FG |
93 | /// Copy constructor and operator= from pointers to compatible planar pixels or planar pixel references. |
94 | /// That allow constructs like pointer = &value or pointer = &reference | |
95 | /// Since we should not override operator& that's the best we can do. | |
92f5a8d4 | 96 | template <typename P> |
7c673cae FG |
97 | planar_pixel_iterator(P* pix) : color_base_parent_t(pix, true) { |
98 | function_requires<PixelsCompatibleConcept<P,value_type> >(); | |
99 | } | |
100 | ||
101 | struct address_of { template <typename T> T* operator()(T& t) { return &t; } }; | |
92f5a8d4 | 102 | template <typename P> |
7c673cae FG |
103 | planar_pixel_iterator& operator=(P* pix) { |
104 | function_requires<PixelsCompatibleConcept<P,value_type> >(); | |
105 | static_transform(*pix,*this, address_of()); | |
106 | ||
107 | // PERFORMANCE_CHECK: Compare to this: | |
108 | //this->template semantic_at_c<0>()=&pix->template semantic_at_c<0>(); | |
109 | //this->template semantic_at_c<1>()=&pix->template semantic_at_c<1>(); | |
110 | //this->template semantic_at_c<2>()=&pix->template semantic_at_c<2>(); | |
111 | return *this; | |
112 | } | |
113 | ||
114 | /// For some reason operator[] provided by iterator_facade returns a custom class that is convertible to reference | |
115 | /// We require our own reference because it is registered in iterator_traits | |
116 | reference operator[](difference_type d) const { return memunit_advanced_ref(*this,d*sizeof(channel_t));} | |
117 | ||
118 | reference operator->() const { return **this; } | |
119 | ||
120 | // PERFORMANCE_CHECK: Remove? | |
121 | bool operator< (const planar_pixel_iterator& ptr) const { return gil::at_c<0>(*this)< gil::at_c<0>(ptr); } | |
122 | bool operator!=(const planar_pixel_iterator& ptr) const { return gil::at_c<0>(*this)!=gil::at_c<0>(ptr); } | |
123 | private: | |
124 | friend class boost::iterator_core_access; | |
125 | ||
126 | void increment() { static_transform(*this,*this,detail::inc<ChannelPtr>()); } | |
127 | void decrement() { static_transform(*this,*this,detail::dec<ChannelPtr>()); } | |
92f5a8d4 | 128 | void advance(std::ptrdiff_t d){ static_transform(*this,*this,std::bind(detail::plus_asymmetric<ChannelPtr,std::ptrdiff_t>(),std::placeholders::_1,d)); } |
7c673cae FG |
129 | reference dereference() const { return this->template deref<reference>(); } |
130 | ||
92f5a8d4 | 131 | std::ptrdiff_t distance_to(const planar_pixel_iterator& it) const { return gil::at_c<0>(it)-gil::at_c<0>(*this); } |
7c673cae FG |
132 | bool equal(const planar_pixel_iterator& it) const { return gil::at_c<0>(*this)==gil::at_c<0>(it); } |
133 | }; | |
134 | ||
135 | namespace detail { | |
92f5a8d4 TL |
136 | template <typename I> |
137 | struct channel_iterator_is_mutable : std::true_type {}; | |
138 | ||
139 | template <typename I> | |
140 | struct channel_iterator_is_mutable<I const*> : std::false_type {}; | |
7c673cae | 141 | |
92f5a8d4 TL |
142 | } // namespace detail |
143 | ||
144 | template <typename IC, typename C> | |
145 | struct const_iterator_type<planar_pixel_iterator<IC,C> > { | |
7c673cae | 146 | private: |
92f5a8d4 | 147 | using channel_t = typename std::iterator_traits<IC>::value_type; |
7c673cae | 148 | public: |
92f5a8d4 | 149 | using type = planar_pixel_iterator<typename channel_traits<channel_t>::const_pointer,C>; |
7c673cae FG |
150 | }; |
151 | ||
152 | // The default implementation when the iterator is a C pointer is to use the standard constness semantics | |
92f5a8d4 | 153 | template <typename IC, typename C> |
7c673cae FG |
154 | struct iterator_is_mutable<planar_pixel_iterator<IC,C> > : public detail::channel_iterator_is_mutable<IC> {}; |
155 | ||
156 | ///////////////////////////// | |
157 | // ColorBasedConcept | |
158 | ///////////////////////////// | |
159 | ||
92f5a8d4 TL |
160 | template <typename IC, typename C, int K> |
161 | struct kth_element_type<planar_pixel_iterator<IC, C>, K> | |
162 | { | |
163 | using type = IC; | |
7c673cae FG |
164 | }; |
165 | ||
92f5a8d4 TL |
166 | template <typename IC, typename C, int K> |
167 | struct kth_element_reference_type<planar_pixel_iterator<IC, C>, K> | |
168 | : std::add_lvalue_reference<IC> {}; | |
7c673cae | 169 | |
92f5a8d4 TL |
170 | template <typename IC, typename C, int K> |
171 | struct kth_element_const_reference_type<planar_pixel_iterator<IC, C>, K> | |
172 | : std::add_lvalue_reference<typename std::add_const<IC>::type> | |
173 | {}; | |
7c673cae FG |
174 | |
175 | ///////////////////////////// | |
176 | // HomogeneousPixelBasedConcept | |
177 | ///////////////////////////// | |
178 | ||
179 | template <typename IC, typename C> | |
92f5a8d4 TL |
180 | struct color_space_type<planar_pixel_iterator<IC,C>> |
181 | { | |
182 | using type = C; | |
7c673cae FG |
183 | }; |
184 | ||
185 | template <typename IC, typename C> | |
92f5a8d4 TL |
186 | struct channel_mapping_type<planar_pixel_iterator<IC, C>> |
187 | : channel_mapping_type<typename planar_pixel_iterator<IC,C>::value_type> | |
188 | {}; | |
7c673cae FG |
189 | |
190 | template <typename IC, typename C> | |
92f5a8d4 | 191 | struct is_planar<planar_pixel_iterator<IC, C>> : std::true_type {}; |
7c673cae FG |
192 | |
193 | template <typename IC, typename C> | |
92f5a8d4 TL |
194 | struct channel_type<planar_pixel_iterator<IC, C>> |
195 | { | |
196 | using type = typename std::iterator_traits<IC>::value_type; | |
7c673cae FG |
197 | }; |
198 | ||
199 | ///////////////////////////// | |
200 | // MemoryBasedIteratorConcept | |
201 | ///////////////////////////// | |
202 | ||
203 | template <typename IC, typename C> | |
204 | inline std::ptrdiff_t memunit_step(const planar_pixel_iterator<IC,C>&) { return sizeof(typename std::iterator_traits<IC>::value_type); } | |
205 | ||
206 | template <typename IC, typename C> | |
92f5a8d4 TL |
207 | inline std::ptrdiff_t memunit_distance(const planar_pixel_iterator<IC,C>& p1, const planar_pixel_iterator<IC,C>& p2) { |
208 | return memunit_distance(gil::at_c<0>(p1),gil::at_c<0>(p2)); | |
7c673cae FG |
209 | } |
210 | ||
211 | template <typename IC> | |
212 | struct memunit_advance_fn { | |
213 | memunit_advance_fn(std::ptrdiff_t diff) : _diff(diff) {} | |
214 | IC operator()(const IC& p) const { return memunit_advanced(p,_diff); } | |
215 | ||
216 | std::ptrdiff_t _diff; | |
217 | }; | |
218 | ||
219 | template <typename IC, typename C> | |
92f5a8d4 | 220 | inline void memunit_advance(planar_pixel_iterator<IC,C>& p, std::ptrdiff_t diff) { |
7c673cae FG |
221 | static_transform(p, p, memunit_advance_fn<IC>(diff)); |
222 | } | |
223 | ||
224 | template <typename IC, typename C> | |
225 | inline planar_pixel_iterator<IC,C> memunit_advanced(const planar_pixel_iterator<IC,C>& p, std::ptrdiff_t diff) { | |
226 | planar_pixel_iterator<IC,C> ret=p; | |
227 | memunit_advance(ret, diff); | |
228 | return ret; | |
229 | } | |
230 | ||
231 | template <typename ChannelPtr, typename ColorSpace> | |
92f5a8d4 | 232 | inline planar_pixel_reference<typename std::iterator_traits<ChannelPtr>::reference,ColorSpace> |
7c673cae FG |
233 | memunit_advanced_ref(const planar_pixel_iterator<ChannelPtr,ColorSpace>& ptr, std::ptrdiff_t diff) { |
234 | return planar_pixel_reference<typename std::iterator_traits<ChannelPtr>::reference,ColorSpace>(ptr, diff); | |
235 | } | |
236 | ||
237 | ///////////////////////////// | |
238 | // HasDynamicXStepTypeConcept | |
239 | ///////////////////////////// | |
240 | ||
241 | template <typename IC, typename C> | |
242 | struct dynamic_x_step_type<planar_pixel_iterator<IC,C> > { | |
92f5a8d4 | 243 | using type = memory_based_step_iterator<planar_pixel_iterator<IC,C>>; |
7c673cae | 244 | }; |
7c673cae FG |
245 | } } // namespace boost::gil |
246 | ||
247 | #endif |