1 | /* |
2 | Copyright 2005-2007 Adobe Systems Incorporated |
3 | |
4 | Use, modification and distribution are subject to the Boost Software License, |
5 | Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at |
6 | http://www.boost.org/LICENSE_1_0.txt). |
7 | |
8 | See http://opensource.adobe.com/gil for most recent version including documentation. |
9 | */ |
10 | |
11 | /*************************************************************************************************/ |
12 | |
13 | #ifndef GIL_METAFUNCTIONS_HPP |
14 | #define GIL_METAFUNCTIONS_HPP |
15 | |
16 | //////////////////////////////////////////////////////////////////////////////////////// |
17 | /// \file |
18 | /// \brief metafunctions that construct types or return type properties |
19 | /// \author Lubomir Bourdev and Hailin Jin \n |
20 | /// Adobe Systems Incorporated |
21 | /// |
22 | /// \date 2005-2007 \n Last updated on February 6, 2007 |
23 | /// |
24 | //////////////////////////////////////////////////////////////////////////////////////// |
25 | |
26 | #include <iterator> |
27 | #include <boost/mpl/accumulate.hpp> |
28 | #include <boost/mpl/back.hpp> |
29 | #include <boost/mpl/bool.hpp> |
30 | #include <boost/mpl/if.hpp> |
31 | #include <boost/mpl/pop_back.hpp> |
32 | #include <boost/mpl/push_back.hpp> |
33 | #include <boost/mpl/transform.hpp> |
34 | #include <boost/mpl/vector.hpp> |
35 | #include <boost/type_traits.hpp> |
36 | #include "gil_config.hpp" |
37 | #include "gil_concept.hpp" |
38 | #include "channel.hpp" |
39 | |
40 | namespace boost { namespace gil { |
41 | |
42 | // forward declarations |
43 | template <typename T, typename L> struct pixel; |
44 | template <typename BitField,typename ChannelRefVec,typename Layout> struct packed_pixel; |
45 | template <typename T, typename C> struct planar_pixel_reference; |
46 | template <typename IC, typename C> struct planar_pixel_iterator; |
47 | template <typename I> class memory_based_step_iterator; |
48 | template <typename I> class memory_based_2d_locator; |
49 | template <typename L> class image_view; |
50 | template <typename Pixel, bool IsPlanar, typename Alloc> class image; |
51 | template <typename T> struct channel_type; |
52 | template <typename T> struct color_space_type; |
53 | template <typename T> struct channel_mapping_type; |
54 | template <typename It> struct is_iterator_adaptor; |
55 | template <typename It> struct iterator_adaptor_get_base; |
56 | template <typename BitField, typename ChannelBitSizes, typename Layout, bool IsMutable> struct bit_aligned_pixel_reference; |
57 | |
58 | ////////////////////////////////////////////////// |
59 | /// |
60 | /// TYPE ANALYSIS METAFUNCTIONS |
61 | /// Predicate metafunctions determining properties of GIL types |
62 | /// |
63 | ////////////////////////////////////////////////// |
64 | |
65 | |
66 | /// \defgroup GILIsBasic xxx_is_basic |
67 | /// \ingroup TypeAnalysis |
68 | /// \brief Determines if GIL constructs are basic. |
69 | /// Basic constructs are the ones that can be generated with the type |
70 | /// factory methods pixel_reference_type, iterator_type, locator_type, view_type and image_type |
71 | /// They can be mutable/immutable, planar/interleaved, step/nonstep. They must use GIL-provided models. |
72 | |
73 | /// \brief Determines if a given pixel reference is basic |
74 | /// Basic references must use gil::pixel& (if interleaved), gil::planar_pixel_reference (if planar). They must use the standard constness rules. |
75 | /// \ingroup GILIsBasic |
76 | template <typename PixelRef> struct pixel_reference_is_basic : public mpl::false_ {}; |
77 | template <typename T, typename L> struct pixel_reference_is_basic< pixel<T,L>&> : public mpl::true_ {}; |
78 | template <typename T, typename L> struct pixel_reference_is_basic<const pixel<T,L>&> : public mpl::true_ {}; |
79 | template <typename TR, typename Cs> struct pixel_reference_is_basic<planar_pixel_reference<TR,Cs> > : public mpl::true_ {}; |
80 | template <typename TR, typename Cs> struct pixel_reference_is_basic<const planar_pixel_reference<TR,Cs> > : public mpl::true_ {}; |
81 | |
82 | |
83 | /// \brief Determines if a given pixel iterator is basic |
84 | /// Basic iterators must use gil::pixel (if interleaved), gil::planar_pixel_iterator (if planar) and gil::memory_based_step_iterator (if step). They must use the standard constness rules. |
85 | /// \ingroup GILIsBasic |
86 | template <typename Iterator> |
87 | struct iterator_is_basic : public mpl::false_ {}; |
88 | template <typename T, typename L> // mutable interleaved |
89 | struct iterator_is_basic< pixel<T,L>* > : public mpl::true_ {}; |
90 | template <typename T, typename L> // immutable interleaved |
91 | struct iterator_is_basic<const pixel<T,L>* > : public mpl::true_ {}; |
92 | template <typename T, typename Cs> // mutable planar |
93 | struct iterator_is_basic<planar_pixel_iterator< T*,Cs> > : public mpl::true_ {}; |
94 | template <typename T, typename Cs> // immutable planar |
95 | struct iterator_is_basic<planar_pixel_iterator<const T*,Cs> > : public mpl::true_ {}; |
96 | template <typename T, typename L> // mutable interleaved step |
97 | struct iterator_is_basic<memory_based_step_iterator< pixel<T,L>*> > : public mpl::true_ {}; |
98 | template <typename T, typename L> // immutable interleaved step |
99 | struct iterator_is_basic<memory_based_step_iterator<const pixel<T,L>*> > : public mpl::true_ {}; |
100 | template <typename T, typename Cs> // mutable planar step |
101 | struct iterator_is_basic<memory_based_step_iterator<planar_pixel_iterator< T*,Cs> > > : public mpl::true_ {}; |
102 | template <typename T, typename Cs> // immutable planar step |
103 | struct iterator_is_basic<memory_based_step_iterator<planar_pixel_iterator<const T*,Cs> > > : public mpl::true_ {}; |
104 | |
105 | |
106 | /// \ingroup GILIsBasic |
107 | /// \brief Determines if a given locator is basic. A basic locator is memory-based and has basic x_iterator and y_iterator |
108 | template <typename Loc> struct locator_is_basic : public mpl::false_ {}; |
109 | template <typename Iterator> struct locator_is_basic<memory_based_2d_locator<memory_based_step_iterator<Iterator> > > : public iterator_is_basic<Iterator> {}; |
110 | |
111 | /// \ingroup GILIsBasic |
112 | /// \brief Basic views must be over basic locators |
113 | template <typename View> struct view_is_basic : public mpl::false_ {}; |
114 | template <typename Loc> struct view_is_basic<image_view<Loc> > : public locator_is_basic<Loc> {}; |
115 | |
116 | /// \ingroup GILIsBasic |
117 | /// \brief Basic images must use basic views and std::allocator of char |
118 | template <typename Img> struct image_is_basic : public mpl::false_ {}; |
119 | template <typename Pixel, bool IsPlanar, typename Alloc> struct image_is_basic<image<Pixel,IsPlanar,Alloc> > : public mpl::true_ {}; |
120 | |
121 | |
122 | /// \defgroup GILIsStep xxx_is_step |
123 | /// \ingroup TypeAnalysis |
124 | /// \brief Determines if the given iterator/locator/view has a step that could be set dynamically |
125 | |
126 | template <typename I> struct iterator_is_step; |
127 | namespace detail { |
128 | template <typename It, bool IsBase, bool EqualsStepType> struct iterator_is_step_impl; |
129 | // iterator that has the same type as its dynamic_x_step_type must be a step iterator |
130 | template <typename It, bool IsBase> struct iterator_is_step_impl<It,IsBase,true> : public mpl::true_{}; |
131 | |
132 | // base iterator can never be a step iterator |
133 | template <typename It> struct iterator_is_step_impl<It,true,false> : public mpl::false_{}; |
134 | |
135 | // for an iterator adaptor, see if its base is step |
136 | template <typename It> struct iterator_is_step_impl<It,false,false> |
137 | : public iterator_is_step<typename iterator_adaptor_get_base<It>::type>{}; |
138 | } |
139 | |
140 | /// \ingroup GILIsStep |
141 | /// \brief Determines if the given iterator has a step that could be set dynamically |
142 | template <typename I> struct iterator_is_step |
143 | : public detail::iterator_is_step_impl<I, |
144 | !is_iterator_adaptor<I>::type::value, |
145 | is_same<I,typename dynamic_x_step_type<I>::type>::value >{}; |
146 | |
147 | /// \ingroup GILIsStep |
148 | /// \brief Determines if the given locator has a horizontal step that could be set dynamically |
149 | template <typename L> struct locator_is_step_in_x : public iterator_is_step<typename L::x_iterator> {}; |
150 | |
151 | /// \ingroup GILIsStep |
152 | /// \brief Determines if the given locator has a vertical step that could be set dynamically |
153 | template <typename L> struct locator_is_step_in_y : public iterator_is_step<typename L::y_iterator> {}; |
154 | |
155 | /// \ingroup GILIsStep |
156 | /// \brief Determines if the given view has a horizontal step that could be set dynamically |
157 | template <typename V> struct view_is_step_in_x : public locator_is_step_in_x<typename V::xy_locator> {}; |
158 | |
159 | /// \ingroup GILIsStep |
160 | /// \brief Determines if the given view has a vertical step that could be set dynamically |
161 | template <typename V> struct view_is_step_in_y : public locator_is_step_in_y<typename V::xy_locator> {}; |
162 | |
163 | /// \brief Determines whether the given pixel reference is a proxy class or a native C++ reference |
164 | /// \ingroup TypeAnalysis |
165 | template <typename PixelReference> |
166 | struct pixel_reference_is_proxy |
167 | : public mpl::not_<is_same<typename remove_const_and_reference<PixelReference>::type, |
168 | typename remove_const_and_reference<PixelReference>::type::value_type> > {}; |
169 | |
170 | /// \brief Given a model of a pixel, determines whether the model represents a pixel reference (as opposed to pixel value) |
171 | /// \ingroup TypeAnalysis |
172 | template <typename Pixel> |
173 | struct pixel_is_reference : public mpl::or_<is_reference<Pixel>, pixel_reference_is_proxy<Pixel> > {}; |
174 | |
175 | /// \defgroup GILIsMutable xxx_is_mutable |
176 | /// \ingroup TypeAnalysis |
177 | /// \brief Determines if the given pixel reference/iterator/locator/view is mutable (i.e. its pixels can be changed) |
178 | |
179 | /// \ingroup GILIsMutable |
180 | /// \brief Determines if the given pixel reference is mutable (i.e. its channels can be changed) |
181 | /// |
182 | /// Note that built-in C++ references obey the const qualifier but reference proxy classes do not. |
183 | template <typename R> struct pixel_reference_is_mutable : public mpl::bool_<remove_reference<R>::type::is_mutable> {}; |
184 | template <typename R> struct pixel_reference_is_mutable<const R&> |
185 | : public mpl::and_<pixel_reference_is_proxy<R>, pixel_reference_is_mutable<R> > {}; |
186 | |
187 | /// \ingroup GILIsMutable |
188 | /// \brief Determines if the given locator is mutable (i.e. its pixels can be changed) |
189 | template <typename L> struct locator_is_mutable : public iterator_is_mutable<typename L::x_iterator> {}; |
190 | /// \ingroup GILIsMutable |
191 | /// \brief Determines if the given view is mutable (i.e. its pixels can be changed) |
192 | template <typename V> struct view_is_mutable : public iterator_is_mutable<typename V::x_iterator> {}; |
193 | |
194 | |
195 | ////////////////////////////////////////////////// |
196 | /// |
197 | /// TYPE FACTORY METAFUNCTIONS |
198 | /// Metafunctions returning GIL types from other GIL types |
199 | /// |
200 | ////////////////////////////////////////////////// |
201 | |
202 | /// \defgroup TypeFactoryFromElements xxx_type |
203 | /// \ingroup TypeFactory |
204 | /// \brief Returns the type of a homogeneous GIL construct given its elements (channel, layout, whether it is planar, step, mutable, etc.) |
205 | |
206 | /// \defgroup TypeFactoryFromPixel xxx_type_from_pixel |
207 | /// \ingroup TypeFactory |
208 | /// \brief Returns the type of a GIL construct given its pixel type, whether it is planar, step, mutable, etc. |
209 | |
210 | /// \defgroup TypeFactoryDerived derived_xxx_type |
211 | /// \ingroup TypeFactory |
212 | /// \brief Returns the type of a homogeneous GIL construct given a related construct by changing some of its properties |
213 | |
214 | /// \ingroup TypeFactoryFromElements |
215 | /// \brief Returns the type of a homogeneous pixel reference given the channel type, layout, whether it operates on planar data and whether it is mutable |
216 | template <typename T, typename L, bool IsPlanar=false, bool IsMutable=true> struct pixel_reference_type{}; |
217 | template <typename T, typename L> struct pixel_reference_type<T,L,false,true > { typedef pixel<T,L>& type; }; |
218 | template <typename T, typename L> struct pixel_reference_type<T,L,false,false> { typedef const pixel<T,L>& type; }; |
219 | template <typename T, typename L> struct pixel_reference_type<T,L,true,true> { typedef const planar_pixel_reference<typename channel_traits<T>::reference,typename color_space_type<L>::type> type; }; // TODO: Assert M=identity |
220 | template <typename T, typename L> struct pixel_reference_type<T,L,true,false> { typedef const planar_pixel_reference<typename channel_traits<T>::const_reference,typename color_space_type<L>::type> type; };// TODO: Assert M=identity |
221 | |
222 | /// \ingroup TypeFactoryFromPixel |
223 | /// \brief Returns the type of a pixel iterator given the pixel type, whether it operates on planar data, whether it is a step iterator, and whether it is mutable |
224 | template <typename Pixel, bool IsPlanar=false, bool IsStep=false, bool IsMutable=true> struct iterator_type_from_pixel{}; |
225 | template <typename Pixel> struct iterator_type_from_pixel<Pixel,false,false,true > { typedef Pixel* type; }; |
226 | template <typename Pixel> struct iterator_type_from_pixel<Pixel,false,false,false> { typedef const Pixel* type; }; |
227 | template <typename Pixel> struct iterator_type_from_pixel<Pixel,true,false,true> { |
228 | typedef planar_pixel_iterator<typename channel_traits<typename channel_type<Pixel>::type>::pointer,typename color_space_type<Pixel>::type> type; |
229 | }; |
230 | template <typename Pixel> struct iterator_type_from_pixel<Pixel,true,false,false> { |
231 | typedef planar_pixel_iterator<typename channel_traits<typename channel_type<Pixel>::type>::const_pointer,typename color_space_type<Pixel>::type> type; |
232 | }; |
233 | template <typename Pixel, bool IsPlanar, bool IsMutable> struct iterator_type_from_pixel<Pixel,IsPlanar,true,IsMutable> { |
234 | typedef memory_based_step_iterator<typename iterator_type_from_pixel<Pixel,IsPlanar,false,IsMutable>::type> type; |
235 | }; |
236 | |
237 | /// \ingroup TypeFactoryFromElements |
238 | /// \brief Returns the type of a homogeneous iterator given the channel type, layout, whether it operates on planar data, whether it is a step iterator, and whether it is mutable |
239 | template <typename T, typename L, bool IsPlanar=false, bool IsStep=false, bool IsMutable=true> struct iterator_type{}; |
240 | template <typename T, typename L> struct iterator_type<T,L,false,false,true > { typedef pixel<T,L>* type; }; |
241 | template <typename T, typename L> struct iterator_type<T,L,false,false,false> { typedef const pixel<T,L>* type; }; |
242 | template <typename T, typename L> struct iterator_type<T,L,true,false,true> { typedef planar_pixel_iterator<T*,typename L::color_space_t> type; }; // TODO: Assert M=identity |
243 | template <typename T, typename L> struct iterator_type<T,L,true,false,false> { typedef planar_pixel_iterator<const T*,typename L::color_space_t> type; }; // TODO: Assert M=identity |
244 | template <typename T, typename L, bool IsPlanar, bool IsMutable> struct iterator_type<T,L,IsPlanar,true,IsMutable> { |
245 | typedef memory_based_step_iterator<typename iterator_type<T,L,IsPlanar,false,IsMutable>::type> type; |
246 | }; |
247 | |
248 | /// \brief Given a pixel iterator defining access to pixels along a row, returns the types of the corresponding built-in step_iterator, xy_locator, image_view |
249 | /// \ingroup TypeFactory |
250 | template <typename XIterator> |
251 | struct type_from_x_iterator { |
252 | typedef memory_based_step_iterator<XIterator> step_iterator_t; |
253 | typedef memory_based_2d_locator<step_iterator_t> xy_locator_t; |
254 | typedef image_view<xy_locator_t> view_t; |
255 | }; |
256 | |
257 | namespace detail { |
258 | template <typename BitField, typename FirstBit, typename NumBits> |
259 | struct packed_channel_reference_type { |
260 | typedef const packed_channel_reference<BitField,FirstBit::value,NumBits::value,true> type; |
261 | }; |
262 | |
263 | template <typename BitField, typename ChannelBitSizesVector> |
264 | class packed_channel_references_vector_type { |
265 | // If ChannelBitSizesVector is mpl::vector<int,7,7,2> |
266 | // Then first_bits_vector will be mpl::vector<int,0,7,14,16> |
267 | typedef typename mpl::accumulate<ChannelBitSizesVector, mpl::vector1<mpl::int_<0> >, |
268 | mpl::push_back<mpl::_1, mpl::plus<mpl::back<mpl::_1>, mpl::_2> > >::type first_bits_vector; |
269 | public: |
270 | typedef typename mpl::transform<typename mpl::pop_back<first_bits_vector>::type, ChannelBitSizesVector, |
271 | packed_channel_reference_type<BitField, mpl::_1,mpl::_2> >::type type; |
272 | }; |
273 | |
274 | } |
275 | |
276 | /// \ingroup TypeFactoryFromElements |
277 | /// \brief Returns the type of a packed pixel given its bitfield type, the bit size of its channels and its layout. |
278 | /// |
279 | /// A packed pixel has channels that cover bit ranges but itself is byte aligned. RGB565 pixel is an example. |
280 | /// |
281 | /// The size of ChannelBitSizeVector must equal the number of channels in the given layout |
282 | /// The sum of bit sizes for all channels must be less than or equal to the number of bits in BitField (and cannot exceed 64). |
283 | /// If it is less than the number of bits in BitField, the last bits will be unused. |
284 | template <typename BitField, typename ChannelBitSizeVector, typename Layout> |
285 | struct packed_pixel_type { |
286 | typedef packed_pixel<BitField, typename detail::packed_channel_references_vector_type<BitField,ChannelBitSizeVector>::type, Layout> type; |
287 | }; |
288 | |
289 | /// \defgroup TypeFactoryPacked packed_image_type,bit_aligned_image_type |
290 | /// \ingroup TypeFactoryFromElements |
291 | /// \brief Returns the type of an image whose channels are not byte-aligned. |
292 | /// |
293 | /// A packed image is an image whose pixels are byte aligned, such as "rgb565". <br> |
294 | /// A bit-aligned image is an image whose pixels are not byte aligned, such as "rgb222". <br> |
295 | /// |
296 | /// The sum of the bit sizes of all channels cannot exceed 64. |
297 | |
298 | /// \ingroup TypeFactoryPacked |
299 | /// \brief Returns the type of an interleaved packed image: an image whose channels may not be byte-aligned, but whose pixels are byte aligned. |
300 | template <typename BitField, typename ChannelBitSizeVector, typename Layout, typename Alloc=std::allocator<unsigned char> > |
301 | struct packed_image_type { |
302 | typedef image<typename packed_pixel_type<BitField,ChannelBitSizeVector,Layout>::type,false,Alloc> type; |
303 | }; |
304 | |
305 | /// \ingroup TypeFactoryPacked |
306 | /// \brief Returns the type of a single-channel image given its bitfield type, the bit size of its channel and its layout |
307 | template <typename BitField, unsigned Size1, typename Layout, typename Alloc=std::allocator<unsigned char> > |
308 | struct packed_image1_type : public packed_image_type<BitField, mpl::vector1_c<unsigned, Size1>, Layout, Alloc> {}; |
309 | |
310 | /// \ingroup TypeFactoryPacked |
311 | /// \brief Returns the type of a two channel image given its bitfield type, the bit size of its channels and its layout |
312 | template <typename BitField, unsigned Size1, unsigned Size2, typename Layout, typename Alloc=std::allocator<unsigned char> > |
313 | struct packed_image2_type : public packed_image_type<BitField, mpl::vector2_c<unsigned, Size1, Size2>, Layout, Alloc> {}; |
314 | |
315 | /// \ingroup TypeFactoryPacked |
316 | /// \brief Returns the type of a three channel image given its bitfield type, the bit size of its channels and its layout |
317 | template <typename BitField, unsigned Size1, unsigned Size2, unsigned Size3, typename Layout, typename Alloc=std::allocator<unsigned char> > |
318 | struct packed_image3_type : public packed_image_type<BitField, mpl::vector3_c<unsigned, Size1, Size2, Size3>, Layout, Alloc> {}; |
319 | |
320 | /// \ingroup TypeFactoryPacked |
321 | /// \brief Returns the type of a four channel image given its bitfield type, the bit size of its channels and its layout |
322 | template <typename BitField, unsigned Size1, unsigned Size2, unsigned Size3, unsigned Size4, typename Layout, typename Alloc=std::allocator<unsigned char> > |
323 | struct packed_image4_type : public packed_image_type<BitField, mpl::vector4_c<unsigned, Size1, Size2, Size3, Size4>, Layout, Alloc> {}; |
324 | |
325 | /// \ingroup TypeFactoryPacked |
326 | /// \brief Returns the type of a five channel image given its bitfield type, the bit size of its channels and its layout |
327 | template <typename BitField, unsigned Size1, unsigned Size2, unsigned Size3, unsigned Size4, unsigned Size5, typename Layout, typename Alloc=std::allocator<unsigned char> > |
328 | struct packed_image5_type : public packed_image_type<BitField, mpl::vector5_c<unsigned, Size1, Size2, Size3, Size4, Size5>, Layout, Alloc> {}; |
329 | |
330 | |
331 | /// \ingroup TypeFactoryPacked |
332 | /// \brief Returns the type of a packed image whose pixels may not be byte aligned. For example, an "rgb222" image is bit-aligned because its pixel spans six bits. |
333 | /// |
334 | /// Note that the alignment parameter in the constructor of bit-aligned images is in bit units. For example, if you want to construct a bit-aligned |
335 | /// image whose rows are byte-aligned, use 8 as the alignment parameter, not 1. |
336 | |
337 | template <typename ChannelBitSizeVector, typename Layout, typename Alloc=std::allocator<unsigned char> > |
338 | struct bit_aligned_image_type { |
339 | private: |
340 | BOOST_STATIC_CONSTANT(int, bit_size = (mpl::accumulate<ChannelBitSizeVector, mpl::int_<0>, mpl::plus<mpl::_1, mpl::_2> >::type::value)); |
341 | typedef typename detail::min_fast_uint<bit_size+7>::type bitfield_t; |
342 | typedef const bit_aligned_pixel_reference<bitfield_t, ChannelBitSizeVector, Layout, true> bit_alignedref_t; |
343 | public: |
344 | typedef image<bit_alignedref_t,false,Alloc> type; |
345 | }; |
346 | |
347 | /// \ingroup TypeFactoryPacked |
348 | /// \brief Returns the type of a single-channel bit-aligned image given the bit size of its channel and its layout |
349 | template <unsigned Size1, typename Layout, typename Alloc=std::allocator<unsigned char> > |
350 | struct bit_aligned_image1_type : public bit_aligned_image_type<mpl::vector1_c<unsigned, Size1>, Layout, Alloc> {}; |
351 | |
352 | /// \ingroup TypeFactoryPacked |
353 | /// \brief Returns the type of a two channel bit-aligned image given the bit size of its channels and its layout |
354 | template <unsigned Size1, unsigned Size2, typename Layout, typename Alloc=std::allocator<unsigned char> > |
355 | struct bit_aligned_image2_type : public bit_aligned_image_type<mpl::vector2_c<unsigned, Size1, Size2>, Layout, Alloc> {}; |
356 | |
357 | /// \ingroup TypeFactoryPacked |
358 | /// \brief Returns the type of a three channel bit-aligned image given the bit size of its channels and its layout |
359 | template <unsigned Size1, unsigned Size2, unsigned Size3, typename Layout, typename Alloc=std::allocator<unsigned char> > |
360 | struct bit_aligned_image3_type : public bit_aligned_image_type<mpl::vector3_c<unsigned, Size1, Size2, Size3>, Layout, Alloc> {}; |
361 | |
362 | /// \ingroup TypeFactoryPacked |
363 | /// \brief Returns the type of a four channel bit-aligned image given the bit size of its channels and its layout |
364 | template <unsigned Size1, unsigned Size2, unsigned Size3, unsigned Size4, typename Layout, typename Alloc=std::allocator<unsigned char> > |
365 | struct bit_aligned_image4_type : public bit_aligned_image_type<mpl::vector4_c<unsigned, Size1, Size2, Size3, Size4>, Layout, Alloc> {}; |
366 | |
367 | /// \ingroup TypeFactoryPacked |
368 | /// \brief Returns the type of a five channel bit-aligned image given the bit size of its channels and its layout |
369 | template <unsigned Size1, unsigned Size2, unsigned Size3, unsigned Size4, unsigned Size5, typename Layout, typename Alloc=std::allocator<unsigned char> > |
370 | struct bit_aligned_image5_type : public bit_aligned_image_type<mpl::vector5_c<unsigned, Size1, Size2, Size3, Size4, Size5>, Layout, Alloc> {}; |
371 | |
372 | |
373 | |
374 | /// \ingroup TypeFactoryFromElements |
375 | /// \brief Returns the type of a homogeneous pixel given the channel type and layout |
376 | template <typename Channel, typename Layout> |
377 | struct pixel_value_type { |
378 | typedef pixel<Channel,Layout> type; // by default use gil::pixel. Specializations are provided for |
379 | }; |
380 | |
381 | // Specializations for packed channels |
382 | template <typename BitField, int NumBits, bool IsMutable, typename Layout> |
383 | struct pixel_value_type< packed_dynamic_channel_reference<BitField,NumBits,IsMutable>,Layout> : |
384 | public packed_pixel_type<BitField, mpl::vector1_c<unsigned,NumBits>, Layout> {}; |
385 | template <typename BitField, int NumBits, bool IsMutable, typename Layout> |
386 | struct pixel_value_type<const packed_dynamic_channel_reference<BitField,NumBits,IsMutable>,Layout> : |
387 | public packed_pixel_type<BitField, mpl::vector1_c<unsigned,NumBits>, Layout> {}; |
388 | |
389 | template <typename BitField, int FirstBit, int NumBits, bool IsMutable, typename Layout> |
390 | struct pixel_value_type< packed_channel_reference<BitField,FirstBit,NumBits,IsMutable>,Layout> : |
391 | public packed_pixel_type<BitField, mpl::vector1_c<unsigned,NumBits>, Layout> {}; |
392 | template <typename BitField, int FirstBit, int NumBits, bool IsMutable, typename Layout> |
393 | struct pixel_value_type<const packed_channel_reference<BitField,FirstBit,NumBits,IsMutable>,Layout> : |
394 | public packed_pixel_type<BitField, mpl::vector1_c<unsigned,NumBits>, Layout> {}; |
395 | |
396 | template <int NumBits, typename Layout> |
397 | struct pixel_value_type<packed_channel_value<NumBits>,Layout> : |
398 | public packed_pixel_type<typename detail::min_fast_uint<NumBits>::type, mpl::vector1_c<unsigned,NumBits>, Layout> {}; |
399 | |
400 | |
401 | /// \ingroup TypeFactoryFromElements |
402 | /// \brief Returns the type of a homogeneous locator given the channel type, layout, whether it operates on planar data and whether it has a step horizontally |
403 | template <typename T, typename L, bool IsPlanar=false, bool IsStepX=false, bool IsMutable=true> |
404 | struct locator_type { |
405 | typedef typename type_from_x_iterator<typename iterator_type<T,L,IsPlanar,IsStepX,IsMutable>::type>::xy_locator_type type; |
406 | }; |
407 | |
408 | /// \ingroup TypeFactoryFromElements |
409 | /// \brief Returns the type of a homogeneous view given the channel type, layout, whether it operates on planar data and whether it has a step horizontally |
410 | template <typename T, typename L, bool IsPlanar=false, bool IsStepX=false, bool IsMutable=true> |
411 | struct view_type { |
412 | typedef typename type_from_x_iterator<typename iterator_type<T,L,IsPlanar,IsStepX,IsMutable>::type>::view_t type; |
413 | }; |
414 | |
415 | /// \ingroup TypeFactoryFromElements |
416 | /// \brief Returns the type of a homogeneous image given the channel type, layout, and whether it operates on planar data |
417 | template <typename T, typename L, bool IsPlanar=false, typename Alloc=std::allocator<unsigned char> > |
418 | struct image_type { |
419 | typedef image<pixel<T,L>, IsPlanar, Alloc> type; |
420 | }; |
421 | |
422 | /// \ingroup TypeFactoryFromPixel |
423 | /// \brief Returns the type of a view the pixel type, whether it operates on planar data and whether it has a step horizontally |
424 | template <typename Pixel, bool IsPlanar=false, bool IsStepX=false, bool IsMutable=true> |
425 | struct view_type_from_pixel { |
426 | typedef typename type_from_x_iterator<typename iterator_type_from_pixel<Pixel,IsPlanar,IsStepX,IsMutable>::type>::view_t type; |
427 | }; |
428 | |
429 | |
430 | /// \brief Constructs a pixel reference type from a source pixel reference type by changing some of the properties. |
431 | /// \ingroup TypeFactoryDerived |
432 | /// Use use_default for the properties of the source view that you want to keep |
433 | template <typename Ref, typename T=use_default, typename L=use_default, typename IsPlanar=use_default, typename IsMutable=use_default> |
434 | class derived_pixel_reference_type { |
435 | typedef typename remove_reference<Ref>::type pixel_t; |
436 | typedef typename mpl::if_<is_same<T, use_default>, typename channel_type<pixel_t>::type, T >::type channel_t; |
437 | typedef typename mpl::if_<is_same<L, use_default>, |
438 | layout<typename color_space_type<pixel_t>::type, typename channel_mapping_type<pixel_t>::type>, L>::type layout_t; |
439 | static const bool mut =mpl::if_<is_same<IsMutable,use_default>, pixel_reference_is_mutable<Ref>, IsMutable>::type::value; |
440 | static const bool planar=mpl::if_<is_same<IsPlanar,use_default>, is_planar<pixel_t>, IsPlanar>::type::value; |
441 | public: |
442 | typedef typename pixel_reference_type<channel_t, layout_t, planar, mut>::type type; |
443 | }; |
444 | |
445 | /// \brief Constructs a pixel iterator type from a source pixel iterator type by changing some of the properties. |
446 | /// \ingroup TypeFactoryDerived |
447 | /// Use use_default for the properties of the source view that you want to keep |
448 | template <typename Iterator, typename T=use_default, typename L=use_default, typename IsPlanar=use_default, typename IsStep=use_default, typename IsMutable=use_default> |
449 | class derived_iterator_type { |
450 | typedef typename mpl::if_<is_same<T ,use_default>, typename channel_type<Iterator>::type, T >::type channel_t; |
451 | typedef typename mpl::if_<is_same<L,use_default>, |
452 | layout<typename color_space_type<Iterator>::type, typename channel_mapping_type<Iterator>::type>, L>::type layout_t; |
453 | |
454 | static const bool mut =mpl::if_<is_same<IsMutable,use_default>, iterator_is_mutable<Iterator>, IsMutable>::type::value; |
455 | static const bool planar=mpl::if_<is_same<IsPlanar,use_default>, is_planar<Iterator>, IsPlanar>::type::value; |
456 | static const bool step =mpl::if_<is_same<IsStep ,use_default>, iterator_is_step<Iterator>, IsStep>::type::value; |
457 | public: |
458 | typedef typename iterator_type<channel_t, layout_t, planar, step, mut>::type type; |
459 | }; |
460 | |
461 | /// \brief Constructs an image view type from a source view type by changing some of the properties. |
462 | /// \ingroup TypeFactoryDerived |
463 | /// Use use_default for the properties of the source view that you want to keep |
464 | template <typename View, typename T=use_default, typename L=use_default, typename IsPlanar=use_default, typename StepX=use_default, typename IsMutable=use_default> |
465 | class derived_view_type { |
466 | typedef typename mpl::if_<is_same<T ,use_default>, typename channel_type<View>::type, T>::type channel_t; |
467 | typedef typename mpl::if_<is_same<L,use_default>, |
468 | layout<typename color_space_type<View>::type, typename channel_mapping_type<View>::type>, L>::type layout_t; |
469 | static const bool mut =mpl::if_<is_same<IsMutable,use_default>, view_is_mutable<View>, IsMutable>::type::value; |
470 | static const bool planar=mpl::if_<is_same<IsPlanar,use_default>, is_planar<View>, IsPlanar>::type::value; |
471 | static const bool step =mpl::if_<is_same<StepX ,use_default>, view_is_step_in_x<View>,StepX>::type::value; |
472 | public: |
473 | typedef typename view_type<channel_t, layout_t, planar, step, mut>::type type; |
474 | }; |
475 | |
476 | /// \brief Constructs a homogeneous image type from a source image type by changing some of the properties. |
477 | /// \ingroup TypeFactoryDerived |
478 | /// Use use_default for the properties of the source image that you want to keep |
479 | template <typename Image, typename T=use_default, typename L=use_default, typename IsPlanar=use_default> |
480 | class derived_image_type { |
481 | typedef typename mpl::if_<is_same<T ,use_default>, typename channel_type<Image>::type, T >::type channel_t; |
482 | typedef typename mpl::if_<is_same<L,use_default>, |
483 | layout<typename color_space_type<Image>::type, typename channel_mapping_type<Image>::type>, L>::type layout_t; |
484 | static const bool planar=mpl::if_<is_same<IsPlanar,use_default>, is_planar<Image>, IsPlanar>::type::value; |
485 | public: |
486 | typedef typename image_type<channel_t, layout_t, planar>::type type; |
487 | }; |
488 | |
489 | |
490 | |
491 | |
492 | } } // namespace boost::gil |
493 | |
494 | #endif |
495 | |