Generic Image Library: channel.hpp Source File

###  | #  |

- Main Page
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

channel.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://stlab.adobe.com/gil for most recent version including documentation.
9 */
10
11 /*************************************************************************************************/
12
13 #ifndef GIL_CHANNEL_HPP
14 #define GIL_CHANNEL_HPP
15
26
27 #include <limits>
28 #include <cassert>
29 #include <cstdint>
30
31 #include <boost/config.hpp>
32 #include <boost/integer/integer_mask.hpp>
33 #include <boost/type_traits/remove_cv.hpp>
34
35 #include "gil_config.hpp"
36 #include "utilities.hpp"
37
38
39 namespace boost { namespace gil {
40
41
56
57 namespace detail {
58 template <typename T, bool is_class> struct channel_traits_impl;
59
60 // channel traits for custom class
61 template <typename T>
62 struct channel_traits_impl<T, true> {
63 typedef typename T::value_type value_type;
64 typedef typename T::reference reference;
65 typedef typename T::pointer pointer;
66 typedef typename T::const_reference const_reference;
67 typedef typename T::const_pointer const_pointer;
68 BOOST_STATIC_CONSTANT(bool, is_mutable=T::is_mutable);
69 static value_type min_value() { return T::min_value(); }
70 static value_type max_value() { return T::max_value(); }
71 };
72
73 // channel traits implementation for built-in integral or floating point channel type
74 template <typename T>
75 struct channel_traits_impl<T, false> {
76 typedef T value_type;
77 typedef T& reference;
78 typedef T* pointer;
79 typedef const T& const_reference;
80 typedef T const* const_pointer;
81 BOOST_STATIC_CONSTANT(bool, is_mutable=true);
82 static value_type min_value() { return (std::numeric_limits<T>::min)(); }
83 static value_type max_value() { return (std::numeric_limits<T>::max)(); }
84 };
85
86 // channel traits implementation for constant built-in scalar or floating point type
87 template <typename T>
88 struct channel_traits_impl<const T, false> : public channel_traits_impl<T, false> {
89 typedef const T& reference;
90 typedef const T* pointer;
91 BOOST_STATIC_CONSTANT(bool, is_mutable=false);
92 };
93 }
94
113 template <typename T>
114 struct channel_traits : public detail::channel_traits_impl<T, is_class<T>::value> {};
115
116 // Channel traits for C++ reference type - remove the reference
117 template <typename T> struct channel_traits< T&> : public channel_traits<T> {};
118
119 // Channel traits for constant C++ reference type
120 template <typename T> struct channel_traits<const T&> : public channel_traits<T> {
121 typedef typename channel_traits<T>::const_reference reference;
122 typedef typename channel_traits<T>::const_pointer pointer;
123 BOOST_STATIC_CONSTANT(bool, is_mutable=false);
124 };
125
131
152 template <typename BaseChannelValue, // base channel (models ChannelValueConcept)
155 typename MinVal, typename MaxVal> // classes with a static apply() function returning the minimum/maximum channel values
156 struct scoped_channel_value {
157 typedef scoped_channel_value value_type;
158 typedef value_type& reference;
159 typedef value_type* pointer;
160 typedef const value_type& const_reference;
161 typedef const value_type* const_pointer;
162 BOOST_STATIC_CONSTANT(bool, is_mutable=channel_traits<BaseChannelValue>::is_mutable);
163
164 typedef BaseChannelValue base_channel_t;
165
166 static value_type min_value() { return MinVal::apply(); }
167 static value_type max_value() { return MaxVal::apply(); }
168
169 scoped_channel_value() {}
170 scoped_channel_value(const scoped_channel_value& c) : _value(c._value) {}
171 scoped_channel_value(BaseChannelValue val) : _value(val) {}
172
173 scoped_channel_value& operator++() { ++_value; return *this; }
174 scoped_channel_value& operator--() { --_value; return *this; }
175
176 scoped_channel_value operator++(int) { scoped_channel_value tmp=*this; this->operator++(); return tmp; }
177 scoped_channel_value operator--(int) { scoped_channel_value tmp=*this; this->operator--(); return tmp; }
178
179 template <typename Scalar2> scoped_channel_value& operator+=(Scalar2 v) { _value+=v; return *this; }
180 template <typename Scalar2> scoped_channel_value& operator-=(Scalar2 v) { _value-=v; return *this; }
181 template <typename Scalar2> scoped_channel_value& operator*=(Scalar2 v) { _value*=v; return *this; }
182 template <typename Scalar2> scoped_channel_value& operator/=(Scalar2 v) { _value/=v; return *this; }
183
184 scoped_channel_value& operator=(BaseChannelValue v) { _value=v; return *this; }
185 operator BaseChannelValue() const { return _value; }
186 private:
187 BaseChannelValue _value;
188 };
189
190 template <typename T>
191 struct float_point_zero
192 {
193 static constexpr T apply() { return 0.0f; }
194 };
195
196 template <typename T>
197 struct float_point_one
198 {
199 static constexpr T apply() { return 1.0f; }
200 };
201
207
208 // It is necessary for packed channels to have their own value type. They cannot simply use an integral large enough to store the data. Here is why:
209 // - Any operation that requires returning the result by value will otherwise return the built-in integral type, which will have incorrect range
210 // That means that after getting the value of the channel we cannot properly do channel_convert, channel_invert, etc.
211 // - Two channels are declared compatible if they have the same value type. That means that a packed channel is incorrectly declared compatible with an integral type
212 namespace detail {
213 // returns the smallest fast unsigned integral type that has at least NumBits bits
214 template <int NumBits>
215 struct min_fast_uint : public mpl::if_c< (NumBits<=8),
216 uint_least8_t,
217 typename mpl::if_c< (NumBits<=16),
218 uint_least16_t,
219 typename mpl::if_c< (NumBits<=32),
220 uint_least32_t,
221 uintmax_t
222 >::type
223 >::type
224 > {};
225
226 template <int NumBits>
227 struct num_value_fn : public mpl::if_c< ( NumBits < 32 )
228 , uint32_t
229 , uint64_t
230 > {};
231
232 template <int NumBits>
233 struct max_value_fn : public mpl::if_c< ( NumBits <= 32 )
234 , uint32_t
235 , uint64_t
236 > {};
237 }
238
255 template <int NumBits>
258 class packed_channel_value {
259
260 public:
261 typedef typename detail::min_fast_uint<NumBits>::type integer_t;
262
263
264 typedef packed_channel_value value_type;
265 typedef value_type& reference;
266 typedef const value_type& const_reference;
267 typedef value_type* pointer;
268 typedef const value_type* const_pointer;
269
270 static value_type min_value() { return 0; }
271 static value_type max_value() { return low_bits_mask_t< NumBits >::sig_bits; }
272
273 BOOST_STATIC_CONSTANT(bool, is_mutable=true);
274
275 packed_channel_value() {}
276
277 packed_channel_value(integer_t v) { _value = static_cast< integer_t >( v & low_bits_mask_t<NumBits>::sig_bits_fast ); }
278 template <typename Scalar> packed_channel_value(Scalar v) { _value = packed_channel_value( static_cast< integer_t >( v ) ); }
279
280 static unsigned int num_bits() { return NumBits; }
281
282 operator integer_t() const { return _value; }
283 private:
284 integer_t _value;
285 };
286
287 namespace detail {
288
289 template <std::size_t K>
290 struct static_copy_bytes {
291 void operator()(const unsigned char* from, unsigned char* to) const {
292 *to = *from;
293 static_copy_bytes<K-1>()(++from,++to);
294 }
295 };
296
297 template <>
298 struct static_copy_bytes<0> {
299 void operator()(const unsigned char* , unsigned char*) const {}
300 };
301
302 template <typename Derived, typename BitField, int NumBits, bool Mutable>
303 class packed_channel_reference_base {
304 protected:
305 typedef typename mpl::if_c<Mutable,void*,const void*>::type data_ptr_t;
306 public:
307 data_ptr_t _data_ptr; // void* pointer to the first byte of the bit range
308
309 typedef packed_channel_value<NumBits> value_type;
310 typedef const Derived reference;
311 typedef value_type* pointer;
312 typedef const value_type* const_pointer;
313 BOOST_STATIC_CONSTANT(int, num_bits=NumBits);
314 BOOST_STATIC_CONSTANT(bool, is_mutable=Mutable);
315
316 static value_type min_value() { return channel_traits<value_type>::min_value(); }
317 static value_type max_value() { return channel_traits<value_type>::max_value(); }
318
319 typedef BitField bitfield_t;
320 typedef typename value_type::integer_t integer_t;
321
322 packed_channel_reference_base(data_ptr_t data_ptr) : _data_ptr(data_ptr) {}
323 packed_channel_reference_base(const packed_channel_reference_base& ref) : _data_ptr(ref._data_ptr) {}
324 const Derived& operator=(integer_t v) const { set(v); return derived(); }
325
326 const Derived& operator++() const { set(get()+1); return derived(); }
327 const Derived& operator--() const { set(get()-1); return derived(); }
328
329 Derived operator++(int) const { Derived tmp=derived(); this->operator++(); return tmp; }
330 Derived operator--(int) const { Derived tmp=derived(); this->operator--(); return tmp; }
331
332 template <typename Scalar2> const Derived& operator+=(Scalar2 v) const { set( static_cast<integer_t>( get() + v )); return derived(); }
333 template <typename Scalar2> const Derived& operator-=(Scalar2 v) const { set( static_cast<integer_t>( get() - v )); return derived(); }
334 template <typename Scalar2> const Derived& operator*=(Scalar2 v) const { set( static_cast<integer_t>( get() * v )); return derived(); }
335 template <typename Scalar2> const Derived& operator/=(Scalar2 v) const { set( static_cast<integer_t>( get() / v )); return derived(); }
336
337 operator integer_t() const { return get(); }
338 data_ptr_t operator &() const {return _data_ptr;}
339 protected:
340
341 typedef typename detail::num_value_fn< NumBits >::type num_value_t;
342 typedef typename detail::max_value_fn< NumBits >::type max_value_t;
343
344 static const num_value_t num_values = static_cast< num_value_t >( 1 ) << NumBits ;
345 static const max_value_t max_val = static_cast< max_value_t >( num_values - 1 );
346
347 #if defined(BOOST_GIL_CONFIG_HAS_UNALIGNED_ACCESS)
348 const bitfield_t& get_data() const { return *static_cast<const bitfield_t*>(_data_ptr); }
349 void set_data(const bitfield_t& val) const { *static_cast< bitfield_t*>(_data_ptr) = val; }
350 #else
351 bitfield_t get_data() const {
352 bitfield_t ret;
353 static_copy_bytes<sizeof(bitfield_t) >()(gil_reinterpret_cast_c<const unsigned char*>(_data_ptr),gil_reinterpret_cast<unsigned char*>(&ret));
354 return ret;
355 }
356 void set_data(const bitfield_t& val) const {
357 static_copy_bytes<sizeof(bitfield_t) >()(gil_reinterpret_cast_c<const unsigned char*>(&val),gil_reinterpret_cast<unsigned char*>(_data_ptr));
358 }
359 #endif
360
361 private:
362 void set(integer_t value) const { // can this be done faster??
363 this->derived().set_unsafe(((value % num_values) + num_values) % num_values);
364 }
365 integer_t get() const { return derived().get(); }
366 const Derived& derived() const { return static_cast<const Derived&>(*this); }
367 };
368 } // namespace detail
369
386 template <typename BitField, // A type that holds the bits of the pixel from which the channel is referenced. Typically an integral type, like std::uint16_t
387 int FirstBit, int NumBits,// Defines the sequence of bits in the data value that contain the channel
388 bool Mutable> // true if the reference is mutable
389 class packed_channel_reference;
390
391 template <typename BitField, // A type that holds the bits of the pixel from which the channel is referenced. Typically an integral type, like std::uint16_t
392 int NumBits, // Defines the sequence of bits in the data value that contain the channel
393 bool Mutable> // true if the reference is mutable
394 class packed_dynamic_channel_reference;
395
398 template <typename BitField, int FirstBit, int NumBits>
399 class packed_channel_reference<BitField,FirstBit,NumBits,false>
400 : public detail::packed_channel_reference_base<packed_channel_reference<BitField,FirstBit,NumBits,false>,BitField,NumBits,false> {
401 typedef detail::packed_channel_reference_base<packed_channel_reference<BitField,FirstBit,NumBits,false>,BitField,NumBits,false> parent_t;
402 friend class packed_channel_reference<BitField,FirstBit,NumBits,true>;
403
404 static const BitField channel_mask = static_cast< BitField >( parent_t::max_val ) << FirstBit;
405
406 void operator=(const packed_channel_reference&);
407 public:
408 typedef const packed_channel_reference<BitField,FirstBit,NumBits,false> const_reference;
409 typedef const packed_channel_reference<BitField,FirstBit,NumBits,true> mutable_reference;
410 typedef typename parent_t::integer_t integer_t;
411
412 explicit packed_channel_reference(const void* data_ptr) : parent_t(data_ptr) {}
413 packed_channel_reference(const packed_channel_reference& ref) : parent_t(ref._data_ptr) {}
414 packed_channel_reference(const mutable_reference& ref) : parent_t(ref._data_ptr) {}
415
416 unsigned first_bit() const { return FirstBit; }
417
418 integer_t get() const { return integer_t((this->get_data()&channel_mask) >> FirstBit); }
419 };
420
423 template <typename BitField, int FirstBit, int NumBits>
424 class packed_channel_reference<BitField,FirstBit,NumBits,true>
425 : public detail::packed_channel_reference_base<packed_channel_reference<BitField,FirstBit,NumBits,true>,BitField,NumBits,true> {
426 typedef detail::packed_channel_reference_base<packed_channel_reference<BitField,FirstBit,NumBits,true>,BitField,NumBits,true> parent_t;
427 friend class packed_channel_reference<BitField,FirstBit,NumBits,false>;
428
429 static const BitField channel_mask = static_cast< BitField >( parent_t::max_val ) << FirstBit;
430
431 public:
432 typedef const packed_channel_reference<BitField,FirstBit,NumBits,false> const_reference;
433 typedef const packed_channel_reference<BitField,FirstBit,NumBits,true> mutable_reference;
434 typedef typename parent_t::integer_t integer_t;
435
436 explicit packed_channel_reference(void* data_ptr) : parent_t(data_ptr) {}
437 packed_channel_reference(const packed_channel_reference& ref) : parent_t(ref._data_ptr) {}
438
439 const packed_channel_reference& operator=(integer_t value) const { assert(value<=parent_t::max_val); set_unsafe(value); return *this; }
440 const packed_channel_reference& operator=(const mutable_reference& ref) const { set_from_reference(ref.get_data()); return *this; }
441 const packed_channel_reference& operator=(const const_reference& ref) const { set_from_reference(ref.get_data()); return *this; }
442
443 template <bool Mutable1>
444 const packed_channel_reference& operator=(const packed_dynamic_channel_reference<BitField,NumBits,Mutable1>& ref) const { set_unsafe(ref.get()); return *this; }
445
446 unsigned first_bit() const { return FirstBit; }
447
448 integer_t get() const { return integer_t((this->get_data()&channel_mask) >> FirstBit); }
449 void set_unsafe(integer_t value) const { this->set_data((this->get_data() & ~channel_mask) | (( static_cast< BitField >( value )<<FirstBit))); }
450 private:
451 void set_from_reference(const BitField& other_bits) const { this->set_data((this->get_data() & ~channel_mask) | (other_bits & channel_mask)); }
452 };
453
454 } } // namespace boost::gil
455
456 namespace std {
457 // We are forced to define swap inside std namespace because on some platforms (Visual Studio 8) STL calls swap qualified.
458 // swap with 'left bias':
459 // - swap between proxy and anything
460 // - swap between value type and proxy
461 // - swap between proxy and proxy
462
465 template <typename BF, int FB, int NB, bool M, typename R> inline
466 void swap(const boost::gil::packed_channel_reference<BF,FB,NB,M> x, R& y) {
467 boost::gil::swap_proxy<typename boost::gil::packed_channel_reference<BF,FB,NB,M>::value_type>(x,y);
468 }
469
470
473 template <typename BF, int FB, int NB, bool M> inline
474 void swap(typename boost::gil::packed_channel_reference<BF,FB,NB,M>::value_type& x, const boost::gil::packed_channel_reference<BF,FB,NB,M> y) {
475 boost::gil::swap_proxy<typename boost::gil::packed_channel_reference<BF,FB,NB,M>::value_type>(x,y);
476 }
477
478
481 template <typename BF, int FB, int NB, bool M> inline
482 void swap(const boost::gil::packed_channel_reference<BF,FB,NB,M> x, const boost::gil::packed_channel_reference<BF,FB,NB,M> y) {
483 boost::gil::swap_proxy<typename boost::gil::packed_channel_reference<BF,FB,NB,M>::value_type>(x,y);
484 }
485 } // namespace std
486
487 namespace boost { namespace gil {
488
506 template <typename BitField, int NumBits>
510 class packed_dynamic_channel_reference<BitField,NumBits,false>
511 : public detail::packed_channel_reference_base<packed_dynamic_channel_reference<BitField,NumBits,false>,BitField,NumBits,false> {
512 typedef detail::packed_channel_reference_base<packed_dynamic_channel_reference<BitField,NumBits,false>,BitField,NumBits,false> parent_t;
513 friend class packed_dynamic_channel_reference<BitField,NumBits,true>;
514
515 unsigned _first_bit; // 0..7
516
517 void operator=(const packed_dynamic_channel_reference&);
518 public:
519 typedef const packed_dynamic_channel_reference<BitField,NumBits,false> const_reference;
520 typedef const packed_dynamic_channel_reference<BitField,NumBits,true> mutable_reference;
521 typedef typename parent_t::integer_t integer_t;
522
523 packed_dynamic_channel_reference(const void* data_ptr, unsigned first_bit) : parent_t(data_ptr), _first_bit(first_bit) {}
524 packed_dynamic_channel_reference(const const_reference& ref) : parent_t(ref._data_ptr), _first_bit(ref._first_bit) {}
525 packed_dynamic_channel_reference(const mutable_reference& ref) : parent_t(ref._data_ptr), _first_bit(ref._first_bit) {}
526
527 unsigned first_bit() const { return _first_bit; }
528
529 integer_t get() const {
530 const BitField channel_mask = static_cast< integer_t >( parent_t::max_val ) <<_first_bit;
531 return static_cast< integer_t >(( this->get_data()&channel_mask ) >> _first_bit );
532 }
533 };
534
538 template <typename BitField, int NumBits>
539 class packed_dynamic_channel_reference<BitField,NumBits,true>
540 : public detail::packed_channel_reference_base<packed_dynamic_channel_reference<BitField,NumBits,true>,BitField,NumBits,true> {
541 typedef detail::packed_channel_reference_base<packed_dynamic_channel_reference<BitField,NumBits,true>,BitField,NumBits,true> parent_t;
542 friend class packed_dynamic_channel_reference<BitField,NumBits,false>;
543
544 unsigned _first_bit;
545
546 public:
547 typedef const packed_dynamic_channel_reference<BitField,NumBits,false> const_reference;
548 typedef const packed_dynamic_channel_reference<BitField,NumBits,true> mutable_reference;
549 typedef typename parent_t::integer_t integer_t;
550
551 packed_dynamic_channel_reference(void* data_ptr, unsigned first_bit) : parent_t(data_ptr), _first_bit(first_bit) {}
552 packed_dynamic_channel_reference(const packed_dynamic_channel_reference& ref) : parent_t(ref._data_ptr), _first_bit(ref._first_bit) {}
553
554 const packed_dynamic_channel_reference& operator=(integer_t value) const { assert(value<=parent_t::max_val); set_unsafe(value); return *this; }
555 const packed_dynamic_channel_reference& operator=(const mutable_reference& ref) const { set_unsafe(ref.get()); return *this; }
556 const packed_dynamic_channel_reference& operator=(const const_reference& ref) const { set_unsafe(ref.get()); return *this; }
557
558 template <typename BitField1, int FirstBit1, bool Mutable1>
559 const packed_dynamic_channel_reference& operator=(const packed_channel_reference<BitField1, FirstBit1, NumBits, Mutable1>& ref) const
560 { set_unsafe(ref.get()); return *this; }
561
562 unsigned first_bit() const { return _first_bit; }
563
564 integer_t get() const {
565 const BitField channel_mask = static_cast< integer_t >( parent_t::max_val ) << _first_bit;
566 return static_cast< integer_t >(( this->get_data()&channel_mask ) >> _first_bit );
567 }
568
569 void set_unsafe(integer_t value) const {
570 const BitField channel_mask = static_cast< integer_t >( parent_t::max_val ) << _first_bit;
571 this->set_data((this->get_data() & ~channel_mask) | value<<_first_bit);
572 }
573 };
574 } } // namespace boost::gil
575
576 namespace std {
577 // We are forced to define swap inside std namespace because on some platforms (Visual Studio 8) STL calls swap qualified.
578 // swap with 'left bias':
579 // - swap between proxy and anything
580 // - swap between value type and proxy
581 // - swap between proxy and proxy
582
583
586 template <typename BF, int NB, bool M, typename R> inline
587 void swap(const boost::gil::packed_dynamic_channel_reference<BF,NB,M> x, R& y) {
588 boost::gil::swap_proxy<typename boost::gil::packed_dynamic_channel_reference<BF,NB,M>::value_type>(x,y);
589 }
590
591
594 template <typename BF, int NB, bool M> inline
595 void swap(typename boost::gil::packed_dynamic_channel_reference<BF,NB,M>::value_type& x, const boost::gil::packed_dynamic_channel_reference<BF,NB,M> y) {
596 boost::gil::swap_proxy<typename boost::gil::packed_dynamic_channel_reference<BF,NB,M>::value_type>(x,y);
597 }
598
599
602 template <typename BF, int NB, bool M> inline
603 void swap(const boost::gil::packed_dynamic_channel_reference<BF,NB,M> x, const boost::gil::packed_dynamic_channel_reference<BF,NB,M> y) {
604 boost::gil::swap_proxy<typename boost::gil::packed_dynamic_channel_reference<BF,NB,M>::value_type>(x,y);
605 }
606 } // namespace std
607
608 namespace boost {
609
610 template <int NumBits>
611 struct is_integral<gil::packed_channel_value<NumBits> > : public mpl::true_ {};
612
613 template <typename BitField, int FirstBit, int NumBits, bool IsMutable>
614 struct is_integral<gil::packed_channel_reference<BitField,FirstBit,NumBits,IsMutable> > : public mpl::true_ {};
615
616 template <typename BitField, int NumBits, bool IsMutable>
617 struct is_integral<gil::packed_dynamic_channel_reference<BitField,NumBits,IsMutable> > : public mpl::true_ {};
618
619 template <typename BaseChannelValue, typename MinVal, typename MaxVal>
620 struct is_integral<gil::scoped_channel_value<BaseChannelValue,MinVal,MaxVal> > : public is_integral<BaseChannelValue> {};
621
622 } // namespace boost
623
624 // \brief Determines the fundamental type which may be used, e.g., to cast from larger to smaller channel types.
625 namespace boost { namespace gil {
626 template <typename T>
627 struct base_channel_type_impl { typedef T type; };
628
629 template <int N>
630 struct base_channel_type_impl<packed_channel_value<N> >
631 { typedef typename packed_channel_value<N>::integer_t type; };
632
633 template <typename B, int F, int N, bool M>
634 struct base_channel_type_impl<packed_channel_reference<B, F, N, M> >
635 { typedef typename packed_channel_reference<B,F,N,M>::integer_t type; };
636
637 template <typename B, int N, bool M>
638 struct base_channel_type_impl<packed_dynamic_channel_reference<B, N, M> >
639 { typedef typename packed_dynamic_channel_reference<B,N,M>::integer_t type; };
640
641 template <typename ChannelValue, typename MinV, typename MaxV>
642 struct base_channel_type_impl<scoped_channel_value<ChannelValue, MinV, MaxV> >
643 { typedef ChannelValue type; };
644
645 template <typename T>
646 struct base_channel_type : base_channel_type_impl<typename remove_cv<T>::type > {};
647
648 }} //namespace boost::gil
649
650 #endif
std::swap
void swap(const boost::gil::packed_dynamic_channel_reference< BF, NB, M > x, const boost::gil::packed_dynamic_channel_reference< BF, NB, M > y)
swap for packed_dynamic_channel_reference
Definition: channel.hpp:603
boost::gil::scoped_channel_value
A channel adaptor that modifies the range of the source channel. Models: ChannelValueConcept.
Definition: channel.hpp:156
boost::gil::packed_dynamic_channel_reference< BitField, NumBits, false >
Models a constant subbyte channel reference whose bit offset is a runtime parameter. Models ChannelConcept Same as packed_channel_reference, except that the offset is a runtime parameter.
Definition: channel.hpp:510
boost::gil::channel_traits
Traits for channels. Contains the following members:
Definition: channel.hpp:114
gil_config.hpp
GIL configuration file.
boost::gil::packed_dynamic_channel_reference< BitField, NumBits, true >
Models a mutable subbyte channel reference whose bit offset is a runtime parameter. Models ChannelConcept Same as packed_channel_reference, except that the offset is a runtime parameter.
Definition: channel.hpp:539
utilities.hpp
Various utilities not specific to the image library. Some are non-standard STL extensions or generic ...