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