Boost GIL

Modules | Alphabetical List | Class List
metafunctions.hpp
Go to the documentation of this file.
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 
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/mpl/vector_c.hpp>
36 #include <boost/type_traits.hpp>
37 #include "gil_config.hpp"
38 #include "gil_concept.hpp"
39 #include "channel.hpp"
40 
41 namespace boost { namespace gil {
42 
43 // forward declarations
44 template <typename T, typename L> struct pixel;
45 template <typename BitField,typename ChannelRefVec,typename Layout> struct packed_pixel;
46 template <typename T, typename C> struct planar_pixel_reference;
47 template <typename IC, typename C> struct planar_pixel_iterator;
48 template <typename I> class memory_based_step_iterator;
49 template <typename I> class memory_based_2d_locator;
50 template <typename L> class image_view;
51 template <typename Pixel, bool IsPlanar, typename Alloc> class image;
52 template <typename T> struct channel_type;
53 template <typename T> struct color_space_type;
54 template <typename T> struct channel_mapping_type;
55 template <typename It> struct is_iterator_adaptor;
56 template <typename It> struct iterator_adaptor_get_base;
57 template <typename BitField, typename ChannelBitSizes, typename Layout, bool IsMutable> struct bit_aligned_pixel_reference;
58 
65 
66 
73 
77 template <typename PixelRef> struct pixel_reference_is_basic : public mpl::false_ {};
78 template <typename T, typename L> struct pixel_reference_is_basic< pixel<T,L>&> : public mpl::true_ {};
79 template <typename T, typename L> struct pixel_reference_is_basic<const pixel<T,L>&> : public mpl::true_ {};
80 template <typename TR, typename Cs> struct pixel_reference_is_basic<planar_pixel_reference<TR,Cs> > : public mpl::true_ {};
81 template <typename TR, typename Cs> struct pixel_reference_is_basic<const planar_pixel_reference<TR,Cs> > : public mpl::true_ {};
82 
83 
87 template <typename Iterator>
88 struct iterator_is_basic : public mpl::false_ {};
89 template <typename T, typename L> // mutable interleaved
90 struct iterator_is_basic< pixel<T,L>* > : public mpl::true_ {};
91 template <typename T, typename L> // immutable interleaved
92 struct iterator_is_basic<const pixel<T,L>* > : public mpl::true_ {};
93 template <typename T, typename Cs> // mutable planar
94 struct iterator_is_basic<planar_pixel_iterator< T*,Cs> > : public mpl::true_ {};
95 template <typename T, typename Cs> // immutable planar
96 struct iterator_is_basic<planar_pixel_iterator<const T*,Cs> > : public mpl::true_ {};
97 template <typename T, typename L> // mutable interleaved step
98 struct iterator_is_basic<memory_based_step_iterator< pixel<T,L>*> > : public mpl::true_ {};
99 template <typename T, typename L> // immutable interleaved step
100 struct iterator_is_basic<memory_based_step_iterator<const pixel<T,L>*> > : public mpl::true_ {};
101 template <typename T, typename Cs> // mutable planar step
102 struct iterator_is_basic<memory_based_step_iterator<planar_pixel_iterator< T*,Cs> > > : public mpl::true_ {};
103 template <typename T, typename Cs> // immutable planar step
104 struct iterator_is_basic<memory_based_step_iterator<planar_pixel_iterator<const T*,Cs> > > : public mpl::true_ {};
105 
106 
109 template <typename Loc> struct locator_is_basic : public mpl::false_ {};
110 template <typename Iterator> struct locator_is_basic<memory_based_2d_locator<memory_based_step_iterator<Iterator> > > : public iterator_is_basic<Iterator> {};
111 
114 template <typename View> struct view_is_basic : public mpl::false_ {};
115 template <typename Loc> struct view_is_basic<image_view<Loc> > : public locator_is_basic<Loc> {};
116 
119 template <typename Img> struct image_is_basic : public mpl::false_ {};
120 template <typename Pixel, bool IsPlanar, typename Alloc> struct image_is_basic<image<Pixel,IsPlanar,Alloc> > : public mpl::true_ {};
121 
122 
126 
127 template <typename I> struct iterator_is_step;
128 namespace detail {
129  template <typename It, bool IsBase, bool EqualsStepType> struct iterator_is_step_impl;
130  // iterator that has the same type as its dynamic_x_step_type must be a step iterator
131  template <typename It, bool IsBase> struct iterator_is_step_impl<It,IsBase,true> : public mpl::true_{};
132 
133  // base iterator can never be a step iterator
134  template <typename It> struct iterator_is_step_impl<It,true,false> : public mpl::false_{};
135 
136  // for an iterator adaptor, see if its base is step
137  template <typename It> struct iterator_is_step_impl<It,false,false>
138  : public iterator_is_step<typename iterator_adaptor_get_base<It>::type>{};
139 }
140 
143 template <typename I> struct iterator_is_step
144  : public detail::iterator_is_step_impl<I,
145  !is_iterator_adaptor<I>::type::value,
146  is_same<I,typename dynamic_x_step_type<I>::type>::value >{};
147 
150 template <typename L> struct locator_is_step_in_x : public iterator_is_step<typename L::x_iterator> {};
151 
154 template <typename L> struct locator_is_step_in_y : public iterator_is_step<typename L::y_iterator> {};
155 
158 template <typename V> struct view_is_step_in_x : public locator_is_step_in_x<typename V::xy_locator> {};
159 
162 template <typename V> struct view_is_step_in_y : public locator_is_step_in_y<typename V::xy_locator> {};
163 
166 template <typename PixelReference>
167 struct pixel_reference_is_proxy
168  : public mpl::not_<is_same<typename remove_const_and_reference<PixelReference>::type,
169  typename remove_const_and_reference<PixelReference>::type::value_type> > {};
170 
173 template <typename Pixel>
174 struct pixel_is_reference : public mpl::or_<is_reference<Pixel>, pixel_reference_is_proxy<Pixel> > {};
175 
179 
184 template <typename R> struct pixel_reference_is_mutable : public mpl::bool_<remove_reference<R>::type::is_mutable> {};
185 template <typename R> struct pixel_reference_is_mutable<const R&>
186  : public mpl::and_<pixel_reference_is_proxy<R>, pixel_reference_is_mutable<R> > {};
187 
190 template <typename L> struct locator_is_mutable : public iterator_is_mutable<typename L::x_iterator> {};
193 template <typename V> struct view_is_mutable : public iterator_is_mutable<typename V::x_iterator> {};
194 
195 
202 
206 
210 
214 
217 template <typename T, typename L, bool IsPlanar=false, bool IsMutable=true> struct pixel_reference_type{};
218 template <typename T, typename L> struct pixel_reference_type<T,L,false,true > { typedef pixel<T,L>& type; };
219 template <typename T, typename L> struct pixel_reference_type<T,L,false,false> { typedef const pixel<T,L>& type; };
220 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
221 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
222 
225 template <typename Pixel, bool IsPlanar=false, bool IsStep=false, bool IsMutable=true> struct iterator_type_from_pixel{};
226 template <typename Pixel> struct iterator_type_from_pixel<Pixel,false,false,true > { typedef Pixel* type; };
227 template <typename Pixel> struct iterator_type_from_pixel<Pixel,false,false,false> { typedef const Pixel* type; };
228 template <typename Pixel> struct iterator_type_from_pixel<Pixel,true,false,true> {
229  typedef planar_pixel_iterator<typename channel_traits<typename channel_type<Pixel>::type>::pointer,typename color_space_type<Pixel>::type> type;
230 };
231 template <typename Pixel> struct iterator_type_from_pixel<Pixel,true,false,false> {
232  typedef planar_pixel_iterator<typename channel_traits<typename channel_type<Pixel>::type>::const_pointer,typename color_space_type<Pixel>::type> type;
233 };
234 template <typename Pixel, bool IsPlanar, bool IsMutable> struct iterator_type_from_pixel<Pixel,IsPlanar,true,IsMutable> {
235  typedef memory_based_step_iterator<typename iterator_type_from_pixel<Pixel,IsPlanar,false,IsMutable>::type> type;
236 };
237 
240 template <typename T, typename L, bool IsPlanar=false, bool IsStep=false, bool IsMutable=true> struct iterator_type{};
241 template <typename T, typename L> struct iterator_type<T,L,false,false,true > { typedef pixel<T,L>* type; };
242 template <typename T, typename L> struct iterator_type<T,L,false,false,false> { typedef const pixel<T,L>* type; };
243 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
244 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
245 template <typename T, typename L, bool IsPlanar, bool IsMutable> struct iterator_type<T,L,IsPlanar,true,IsMutable> {
246  typedef memory_based_step_iterator<typename iterator_type<T,L,IsPlanar,false,IsMutable>::type> type;
247 };
248 
251 template <typename XIterator>
252 struct type_from_x_iterator {
253  typedef memory_based_step_iterator<XIterator> step_iterator_t;
254  typedef memory_based_2d_locator<step_iterator_t> xy_locator_t;
255  typedef image_view<xy_locator_t> view_t;
256 };
257 
258 namespace detail {
259  template <typename BitField, typename FirstBit, typename NumBits>
260  struct packed_channel_reference_type {
261  typedef const packed_channel_reference<BitField,FirstBit::value,NumBits::value,true> type;
262  };
263 
264  template <typename BitField, typename ChannelBitSizesVector>
265  class packed_channel_references_vector_type {
266  // If ChannelBitSizesVector is mpl::vector<int,7,7,2>
267  // Then first_bits_vector will be mpl::vector<int,0,7,14,16>
268  typedef typename mpl::accumulate<ChannelBitSizesVector, mpl::vector1<mpl::int_<0> >,
269  mpl::push_back<mpl::_1, mpl::plus<mpl::back<mpl::_1>, mpl::_2> > >::type first_bits_vector;
270  public:
271  typedef typename mpl::transform<typename mpl::pop_back<first_bits_vector>::type, ChannelBitSizesVector,
272  packed_channel_reference_type<BitField, mpl::_1,mpl::_2> >::type type;
273  };
274 
275 }
276 
285 template <typename BitField, typename ChannelBitSizeVector, typename Layout>
286 struct packed_pixel_type {
287  typedef packed_pixel<BitField, typename detail::packed_channel_references_vector_type<BitField,ChannelBitSizeVector>::type, Layout> type;
288 };
289 
298 
301 template <typename BitField, typename ChannelBitSizeVector, typename Layout, typename Alloc=std::allocator<unsigned char> >
302 struct packed_image_type {
303  typedef image<typename packed_pixel_type<BitField,ChannelBitSizeVector,Layout>::type,false,Alloc> type;
304 };
305 
308 template <typename BitField, unsigned Size1, typename Layout, typename Alloc=std::allocator<unsigned char> >
309 struct packed_image1_type : public packed_image_type<BitField, mpl::vector1_c<unsigned, Size1>, Layout, Alloc> {};
310 
313 template <typename BitField, unsigned Size1, unsigned Size2, typename Layout, typename Alloc=std::allocator<unsigned char> >
314 struct packed_image2_type : public packed_image_type<BitField, mpl::vector2_c<unsigned, Size1, Size2>, Layout, Alloc> {};
315 
318 template <typename BitField, unsigned Size1, unsigned Size2, unsigned Size3, typename Layout, typename Alloc=std::allocator<unsigned char> >
319 struct packed_image3_type : public packed_image_type<BitField, mpl::vector3_c<unsigned, Size1, Size2, Size3>, Layout, Alloc> {};
320 
323 template <typename BitField, unsigned Size1, unsigned Size2, unsigned Size3, unsigned Size4, typename Layout, typename Alloc=std::allocator<unsigned char> >
324 struct packed_image4_type : public packed_image_type<BitField, mpl::vector4_c<unsigned, Size1, Size2, Size3, Size4>, Layout, Alloc> {};
325 
328 template <typename BitField, unsigned Size1, unsigned Size2, unsigned Size3, unsigned Size4, unsigned Size5, typename Layout, typename Alloc=std::allocator<unsigned char> >
329 struct packed_image5_type : public packed_image_type<BitField, mpl::vector5_c<unsigned, Size1, Size2, Size3, Size4, Size5>, Layout, Alloc> {};
330 
331 
337 
338 template <typename ChannelBitSizeVector, typename Layout, typename Alloc=std::allocator<unsigned char> >
339 struct bit_aligned_image_type {
340 private:
341  BOOST_STATIC_CONSTANT(int, bit_size = (mpl::accumulate<ChannelBitSizeVector, mpl::int_<0>, mpl::plus<mpl::_1, mpl::_2> >::type::value));
342  typedef typename detail::min_fast_uint<bit_size+7>::type bitfield_t;
343  typedef const bit_aligned_pixel_reference<bitfield_t, ChannelBitSizeVector, Layout, true> bit_alignedref_t;
344 public:
345  typedef image<bit_alignedref_t,false,Alloc> type;
346 };
347 
350 template <unsigned Size1, typename Layout, typename Alloc=std::allocator<unsigned char> >
351 struct bit_aligned_image1_type : public bit_aligned_image_type<mpl::vector1_c<unsigned, Size1>, Layout, Alloc> {};
352 
355 template <unsigned Size1, unsigned Size2, typename Layout, typename Alloc=std::allocator<unsigned char> >
356 struct bit_aligned_image2_type : public bit_aligned_image_type<mpl::vector2_c<unsigned, Size1, Size2>, Layout, Alloc> {};
357 
360 template <unsigned Size1, unsigned Size2, unsigned Size3, typename Layout, typename Alloc=std::allocator<unsigned char> >
361 struct bit_aligned_image3_type : public bit_aligned_image_type<mpl::vector3_c<unsigned, Size1, Size2, Size3>, Layout, Alloc> {};
362 
365 template <unsigned Size1, unsigned Size2, unsigned Size3, unsigned Size4, typename Layout, typename Alloc=std::allocator<unsigned char> >
366 struct bit_aligned_image4_type : public bit_aligned_image_type<mpl::vector4_c<unsigned, Size1, Size2, Size3, Size4>, Layout, Alloc> {};
367 
370 template <unsigned Size1, unsigned Size2, unsigned Size3, unsigned Size4, unsigned Size5, typename Layout, typename Alloc=std::allocator<unsigned char> >
371 struct bit_aligned_image5_type : public bit_aligned_image_type<mpl::vector5_c<unsigned, Size1, Size2, Size3, Size4, Size5>, Layout, Alloc> {};
372 
373 
374 
377 template <typename Channel, typename Layout>
378 struct pixel_value_type {
379  typedef pixel<Channel,Layout> type; // by default use gil::pixel. Specializations are provided for
380 };
381 
382 // Specializations for packed channels
383 template <typename BitField, int NumBits, bool IsMutable, typename Layout>
384 struct pixel_value_type< packed_dynamic_channel_reference<BitField,NumBits,IsMutable>,Layout> :
385  public packed_pixel_type<BitField, mpl::vector1_c<unsigned,NumBits>, Layout> {};
386 template <typename BitField, int NumBits, bool IsMutable, typename Layout>
387 struct pixel_value_type<const packed_dynamic_channel_reference<BitField,NumBits,IsMutable>,Layout> :
388  public packed_pixel_type<BitField, mpl::vector1_c<unsigned,NumBits>, Layout> {};
389 
390 template <typename BitField, int FirstBit, int NumBits, bool IsMutable, typename Layout>
391 struct pixel_value_type< packed_channel_reference<BitField,FirstBit,NumBits,IsMutable>,Layout> :
392  public packed_pixel_type<BitField, mpl::vector1_c<unsigned,NumBits>, Layout> {};
393 template <typename BitField, int FirstBit, int NumBits, bool IsMutable, typename Layout>
394 struct pixel_value_type<const packed_channel_reference<BitField,FirstBit,NumBits,IsMutable>,Layout> :
395  public packed_pixel_type<BitField, mpl::vector1_c<unsigned,NumBits>, Layout> {};
396 
397 template <int NumBits, typename Layout>
398 struct pixel_value_type<packed_channel_value<NumBits>,Layout> :
399  public packed_pixel_type<typename detail::min_fast_uint<NumBits>::type, mpl::vector1_c<unsigned,NumBits>, Layout> {};
400 
401 
404 template <typename T, typename L, bool IsPlanar=false, bool IsStepX=false, bool IsMutable=true>
405 struct locator_type {
406  typedef typename type_from_x_iterator<typename iterator_type<T,L,IsPlanar,IsStepX,IsMutable>::type>::xy_locator_type type;
407 };
408 
411 template <typename T, typename L, bool IsPlanar=false, bool IsStepX=false, bool IsMutable=true>
412 struct view_type {
413  typedef typename type_from_x_iterator<typename iterator_type<T,L,IsPlanar,IsStepX,IsMutable>::type>::view_t type;
414 };
415 
418 template <typename T, typename L, bool IsPlanar=false, typename Alloc=std::allocator<unsigned char> >
419 struct image_type {
420  typedef image<pixel<T,L>, IsPlanar, Alloc> type;
421 };
422 
425 template <typename Pixel, bool IsPlanar=false, bool IsStepX=false, bool IsMutable=true>
426 struct view_type_from_pixel {
427  typedef typename type_from_x_iterator<typename iterator_type_from_pixel<Pixel,IsPlanar,IsStepX,IsMutable>::type>::view_t type;
428 };
429 
430 
434 template <typename Ref, typename T=use_default, typename L=use_default, typename IsPlanar=use_default, typename IsMutable=use_default>
435 class derived_pixel_reference_type {
436  typedef typename remove_reference<Ref>::type pixel_t;
437  typedef typename mpl::if_<is_same<T, use_default>, typename channel_type<pixel_t>::type, T >::type channel_t;
438  typedef typename mpl::if_<is_same<L, use_default>,
439  layout<typename color_space_type<pixel_t>::type, typename channel_mapping_type<pixel_t>::type>, L>::type layout_t;
440  static const bool mut =mpl::if_<is_same<IsMutable,use_default>, pixel_reference_is_mutable<Ref>, IsMutable>::type::value;
441  static const bool planar=mpl::if_<is_same<IsPlanar,use_default>, is_planar<pixel_t>, IsPlanar>::type::value;
442 public:
443  typedef typename pixel_reference_type<channel_t, layout_t, planar, mut>::type type;
444 };
445 
449 template <typename Iterator, typename T=use_default, typename L=use_default, typename IsPlanar=use_default, typename IsStep=use_default, typename IsMutable=use_default>
450 class derived_iterator_type {
451  typedef typename mpl::if_<is_same<T ,use_default>, typename channel_type<Iterator>::type, T >::type channel_t;
452  typedef typename mpl::if_<is_same<L,use_default>,
453  layout<typename color_space_type<Iterator>::type, typename channel_mapping_type<Iterator>::type>, L>::type layout_t;
454 
455  static const bool mut =mpl::if_<is_same<IsMutable,use_default>, iterator_is_mutable<Iterator>, IsMutable>::type::value;
456  static const bool planar=mpl::if_<is_same<IsPlanar,use_default>, is_planar<Iterator>, IsPlanar>::type::value;
457  static const bool step =mpl::if_<is_same<IsStep ,use_default>, iterator_is_step<Iterator>, IsStep>::type::value;
458 public:
459  typedef typename iterator_type<channel_t, layout_t, planar, step, mut>::type type;
460 };
461 
465 template <typename View, typename T=use_default, typename L=use_default, typename IsPlanar=use_default, typename StepX=use_default, typename IsMutable=use_default>
466 class derived_view_type {
467  typedef typename mpl::if_<is_same<T ,use_default>, typename channel_type<View>::type, T>::type channel_t;
468  typedef typename mpl::if_<is_same<L,use_default>,
469  layout<typename color_space_type<View>::type, typename channel_mapping_type<View>::type>, L>::type layout_t;
470  static const bool mut =mpl::if_<is_same<IsMutable,use_default>, view_is_mutable<View>, IsMutable>::type::value;
471  static const bool planar=mpl::if_<is_same<IsPlanar,use_default>, is_planar<View>, IsPlanar>::type::value;
472  static const bool step =mpl::if_<is_same<StepX ,use_default>, view_is_step_in_x<View>,StepX>::type::value;
473 public:
474  typedef typename view_type<channel_t, layout_t, planar, step, mut>::type type;
475 };
476 
480 template <typename Image, typename T=use_default, typename L=use_default, typename IsPlanar=use_default>
481 class derived_image_type {
482  typedef typename mpl::if_<is_same<T ,use_default>, typename channel_type<Image>::type, T >::type channel_t;
483  typedef typename mpl::if_<is_same<L,use_default>,
484  layout<typename color_space_type<Image>::type, typename channel_mapping_type<Image>::type>, L>::type layout_t;
485  static const bool planar=mpl::if_<is_same<IsPlanar,use_default>, is_planar<Image>, IsPlanar>::type::value;
486 public:
487  typedef typename image_type<channel_t, layout_t, planar>::type type;
488 };
489 
490 
491 
492 
493 } } // namespace boost::gil
494 
495 #endif
boost::gil::is_iterator_adaptor
metafunction predicate determining whether the given iterator is a plain one or an adaptor over anoth...
Definition: gil_concept.hpp:65
boost::gil::packed_image_type
Returns the type of an interleaved packed image: an image whose channels may not be byte-aligned...
Definition: metafunctions.hpp:302
boost::gil::pixel_reference_is_proxy
Determines whether the given pixel reference is a proxy class or a native C++ reference.
Definition: metafunctions.hpp:167
boost::gil::planar_pixel_reference
A reference proxy to a planar pixel. Models: HomogeneousColorBaseConcept, HomogeneousPixelConcept.
Definition: metafunctions.hpp:46
boost::gil::image_type
Returns the type of a homogeneous image given the channel type, layout, and whether it operates on pl...
Definition: metafunctions.hpp:419
boost::gil::locator_is_step_in_x
Determines if the given locator has a horizontal step that could be set dynamically.
Definition: metafunctions.hpp:150
boost::gil::view_type
Returns the type of a homogeneous view given the channel type, layout, whether it operates on planar ...
Definition: metafunctions.hpp:412
boost::gil::image_view
A lightweight object that interprets memory as a 2D array of pixels. Models ImageViewConcept,PixelBasedConcept,HasDynamicXStepTypeConcept,HasDynamicYStepTypeConcept,HasTransposedTypeConcept.
Definition: image_view.hpp:68
boost::gil::iterator_adaptor_get_base
returns the base iterator for a given iterator adaptor. Provide an specialization when introducing ne...
Definition: gil_concept.hpp:67
boost::gil::packed_image1_type
Returns the type of a single-channel image given its bitfield type, the bit size of its channel and i...
Definition: metafunctions.hpp:309
boost::gil::pixel
Represents a pixel value (a container of channels). Models: HomogeneousColorBaseValueConcept, PixelValueConcept, HomogeneousPixelBasedConcept.
Definition: metafunctions.hpp:44
boost::gil::iterator_type
Returns the type of a homogeneous iterator given the channel type, layout, whether it operates on pla...
Definition: metafunctions.hpp:240
boost::gil::packed_image4_type
Returns the type of a four channel image given its bitfield type, the bit size of its channels and it...
Definition: metafunctions.hpp:324
boost::gil::packed_image2_type
Returns the type of a two channel image given its bitfield type, the bit size of its channels and its...
Definition: metafunctions.hpp:314
channel.hpp
Channel utilities.
boost::gil::bit_aligned_image5_type
Returns the type of a five channel bit-aligned image given the bit size of its channels and its layou...
Definition: metafunctions.hpp:371
boost::gil::bit_aligned_pixel_reference
Heterogeneous pixel reference corresponding to non-byte-aligned bit range. Models ColorBaseConcept...
Definition: bit_aligned_pixel_reference.hpp:125
boost::gil::derived_iterator_type
Constructs a pixel iterator type from a source pixel iterator type by changing some of the properties...
Definition: metafunctions.hpp:450
boost::gil::planar_pixel_iterator
An iterator over planar pixels. Models HomogeneousColorBaseConcept, PixelIteratorConcept, HomogeneousPixelBasedConcept, MemoryBasedIteratorConcept, HasDynamicXStepTypeConcept.
Definition: algorithm.hpp:53
boost::gil::iterator_is_basic
Determines if a given pixel iterator is basic Basic iterators must use gil::pixel (if interleaved)...
Definition: metafunctions.hpp:88
gil_concept.hpp
Concept check classes for GIL concepts.
boost::gil::derived_pixel_reference_type
Constructs a pixel reference type from a source pixel reference type by changing some of the properti...
Definition: metafunctions.hpp:435
boost::gil::bit_aligned_image4_type
Returns the type of a four channel bit-aligned image given the bit size of its channels and its layou...
Definition: metafunctions.hpp:366
boost::gil::memory_based_2d_locator
Memory-based pixel locator. Models: PixelLocatorConcept,HasDynamicXStepTypeConcept,HasDynamicYStepTypeConcept,HasTransposedTypeConceptThe class takes a step iterator as a parameter. The step iterator provides navigation along the vertical axis while its base iterator provides horizontal navigation.
Definition: algorithm.hpp:57
boost::gil::type_from_x_iterator
Given a pixel iterator defining access to pixels along a row, returns the types of the corresponding ...
Definition: metafunctions.hpp:252
boost::gil::image_is_basic
Basic images must use basic views and std::allocator of char.
Definition: metafunctions.hpp:119
boost::gil::pixel_reference_is_mutable
Determines if the given pixel reference is mutable (i.e. its channels can be changed) ...
Definition: metafunctions.hpp:184
boost::gil::locator_is_mutable
Determines if the given locator is mutable (i.e. its pixels can be changed)
Definition: metafunctions.hpp:190
boost::gil::derived_image_type
Constructs a homogeneous image type from a source image type by changing some of the properties...
Definition: metafunctions.hpp:481
boost::gil::layout
Represents a color space and ordering of channels in memory.
Definition: utilities.hpp:306
boost::gil::image
container interface over image view. Models ImageConcept, PixelBasedConcept
Definition: image.hpp:59
boost::gil::locator_is_basic
Determines if a given locator is basic. A basic locator is memory-based and has basic x_iterator and ...
Definition: metafunctions.hpp:109
boost::gil::pixel_reference_type
Returns the type of a homogeneous pixel reference given the channel type, layout, whether it operates...
Definition: metafunctions.hpp:217
boost::gil::bit_aligned_image_type
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.
Definition: metafunctions.hpp:339
boost::gil::view_is_step_in_y
Determines if the given view has a vertical step that could be set dynamically.
Definition: metafunctions.hpp:162
boost::gil::view_is_mutable
Determines if the given view is mutable (i.e. its pixels can be changed)
Definition: metafunctions.hpp:193
boost::gil::pixel_value_type
Returns the type of a homogeneous pixel given the channel type and layout.
Definition: metafunctions.hpp:378
boost::gil::locator_type
Returns the type of a homogeneous locator given the channel type, layout, whether it operates on plan...
Definition: metafunctions.hpp:405
gil_config.hpp
GIL configuration file.
boost::gil::iterator_is_mutable
Metafunction predicate returning whether the given iterator allows for changing its values...
Definition: gil_concept.hpp:64
boost::gil::derived_view_type
Constructs an image view type from a source view type by changing some of the properties.Use use_default for the properties of the source view that you want to keep.
Definition: metafunctions.hpp:466
boost::gil::packed_pixel_type
Returns the type of a packed pixel given its bitfield type, the bit size of its channels and its layo...
Definition: metafunctions.hpp:286
boost::gil::packed_pixel
Heterogeneous pixel value whose channel references can be constructed from the pixel bitfield and the...
Definition: gil_concept.hpp:79
boost::gil::pixel_is_reference
Given a model of a pixel, determines whether the model represents a pixel reference (as opposed to pi...
Definition: metafunctions.hpp:174
boost::gil::bit_aligned_image1_type
Returns the type of a single-channel bit-aligned image given the bit size of its channel and its layo...
Definition: metafunctions.hpp:351
boost::gil::pixel_reference_is_basic
Determines if a given pixel reference is basic Basic references must use gil::pixel& (if interleaved)...
Definition: metafunctions.hpp:77
boost::gil::packed_image3_type
Returns the type of a three channel image given its bitfield type, the bit size of its channels and i...
Definition: metafunctions.hpp:319
boost::gil::locator_is_step_in_y
Determines if the given locator has a vertical step that could be set dynamically.
Definition: metafunctions.hpp:154
boost::gil::view_is_basic
Basic views must be over basic locators.
Definition: metafunctions.hpp:114
boost::gil::iterator_is_step
Determines if the given iterator has a step that could be set dynamically.
Definition: metafunctions.hpp:127
boost::gil::bit_aligned_image2_type
Returns the type of a two channel bit-aligned image given the bit size of its channels and its layout...
Definition: metafunctions.hpp:356
boost::gil::iterator_type_from_pixel
Returns the type of a pixel iterator given the pixel type, whether it operates on planar data...
Definition: metafunctions.hpp:225
boost::gil::view_type_from_pixel
Returns the type of a view the pixel type, whether it operates on planar data and whether it has a st...
Definition: metafunctions.hpp:426
boost::gil::memory_based_step_iterator
MEMORY-BASED STEP ITERATOR.
Definition: algorithm.hpp:55
boost::gil::bit_aligned_image3_type
Returns the type of a three channel bit-aligned image given the bit size of its channels and its layo...
Definition: metafunctions.hpp:361
boost::gil::view_is_step_in_x
Determines if the given view has a horizontal step that could be set dynamically. ...
Definition: metafunctions.hpp:158
boost::gil::packed_image5_type
Returns the type of a five channel image given its bitfield type, the bit size of its channels and it...
Definition: metafunctions.hpp:329
Generated on Mon Mar 26 2018 16:26:15 for Generic Image Library by   doxygen 1.8.6