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 | |
16 | //////////////////////////////////////////////////////////////////////////////////////// |
17 | /// \file |
18 | /// \brief Channel utilities |
19 | /// \author Lubomir Bourdev and Hailin Jin \n |
20 | /// Adobe Systems Incorporated |
21 | /// \date 2005-2007 \n Last updated on May 6, 2007 |
22 | /// |
23 | /// Definitions of standard GIL channel models |
24 | /// |
25 | //////////////////////////////////////////////////////////////////////////////////////// |
26 | |
27 | #include <limits> |
28 | #include <cassert> |
29 | #include <boost/cstdint.hpp> |
30 | #include "gil_config.hpp" |
31 | #include "utilities.hpp" |
32 | |
33 | namespace boost { namespace gil { |
34 | |
35 | |
36 | /////////////////////////////////////////// |
37 | //// channel_traits |
38 | //// |
39 | //// \ingroup ChannelModel |
40 | //// \class channel_traits |
41 | //// \brief defines properties of channels, such as their range and associated types |
42 | //// |
43 | //// The channel traits must be defined for every model of ChannelConcept |
44 | //// Default traits are provided. For built-in types the default traits use |
45 | //// built-in pointer and reference and the channel range is the physical |
46 | //// range of the type. For classes, the default traits forward the associated types |
47 | //// and range to the class. |
48 | //// |
49 | /////////////////////////////////////////// |
50 | |
51 | namespace detail { |
52 | template <typename T, bool is_class> struct channel_traits_impl; |
53 | |
54 | // channel traits for custom class |
55 | template <typename T> |
56 | struct channel_traits_impl<T, true> { |
57 | typedef typename T::value_type value_type; |
58 | typedef typename T::reference reference; |
59 | typedef typename T::pointer pointer; |
60 | typedef typename T::const_reference const_reference; |
61 | typedef typename T::const_pointer const_pointer; |
62 | BOOST_STATIC_CONSTANT(bool, is_mutable=T::is_mutable); |
63 | static value_type min_value() { return T::min_value(); } |
64 | static value_type max_value() { return T::max_value(); } |
65 | }; |
66 | |
67 | // channel traits implementation for built-in integral or floating point channel type |
68 | template <typename T> |
69 | struct channel_traits_impl<T, false> { |
70 | typedef T value_type; |
71 | typedef T& reference; |
72 | typedef T* pointer; |
73 | typedef const T& const_reference; |
74 | typedef T const* const_pointer; |
75 | BOOST_STATIC_CONSTANT(bool, is_mutable=true); |
76 | static value_type min_value() { return (std::numeric_limits<T>::min)(); } |
77 | static value_type max_value() { return (std::numeric_limits<T>::max)(); } |
78 | }; |
79 | |
80 | // channel traits implementation for constant built-in scalar or floating point type |
81 | template <typename T> |
82 | struct channel_traits_impl<const T, false> : public channel_traits_impl<T, false> { |
83 | typedef const T& reference; |
84 | typedef const T* pointer; |
85 | BOOST_STATIC_CONSTANT(bool, is_mutable=false); |
86 | }; |
87 | } |
88 | |
89 | /** |
90 | \ingroup ChannelModel |
91 | \brief Traits for channels. Contains the following members: |
92 | \code |
93 | template <typename Channel> |
94 | struct channel_traits { |
95 | typedef ... value_type; |
96 | typedef ... reference; |
97 | typedef ... pointer; |
98 | typedef ... const_reference; |
99 | typedef ... const_pointer; |
100 | |
101 | static const bool is_mutable; |
102 | static value_type min_value(); |
103 | static value_type max_value(); |
104 | }; |
105 | \endcode |
106 | */ |
107 | template <typename T> |
108 | struct channel_traits : public detail::channel_traits_impl<T, is_class<T>::value> {}; |
109 | |
110 | // Channel traits for C++ reference type - remove the reference |
111 | template <typename T> struct channel_traits< T&> : public channel_traits<T> {}; |
112 | |
113 | // Channel traits for constant C++ reference type |
114 | template <typename T> struct channel_traits<const T&> : public channel_traits<T> { |
115 | typedef typename channel_traits<T>::const_reference reference; |
116 | typedef typename channel_traits<T>::const_pointer pointer; |
117 | BOOST_STATIC_CONSTANT(bool, is_mutable=false); |
118 | }; |
119 | |
120 | /////////////////////////////////////////// |
121 | //// |
122 | //// scoped_channel_value |
123 | //// |
124 | /////////////////////////////////////////// |
125 | |
126 | /** |
127 | \defgroup ScopedChannelValue scoped_channel_value |
128 | \ingroup ChannelModel |
129 | \brief A channel adaptor that modifies the range of the source channel. Models: ChannelValueConcept |
130 | |
131 | Example: |
132 | \code |
133 | // Create a double channel with range [-0.5 .. 0.5] |
134 | struct double_minus_half { static double apply() { return -0.5; } }; |
135 | struct double_plus_half { static double apply() { return 0.5; } }; |
136 | typedef scoped_channel_value<double, double_minus_half, double_plus_half> bits64custom_t; |
137 | |
138 | // channel_convert its maximum should map to the maximum |
139 | bits64custom_t x = channel_traits<bits64custom_t>::max_value(); |
140 | assert(x == 0.5); |
141 | bits16 y = channel_convert<bits16>(x); |
142 | assert(y == 65535); |
143 | \endcode |
144 | */ |
145 | |
146 | /// \ingroup ScopedChannelValue |
147 | /// \brief A channel adaptor that modifies the range of the source channel. Models: ChannelValueConcept |
148 | template <typename BaseChannelValue, // base channel (models ChannelValueConcept) |
149 | typename MinVal, typename MaxVal> // classes with a static apply() function returning the minimum/maximum channel values |
150 | struct scoped_channel_value { |
151 | typedef scoped_channel_value value_type; |
152 | typedef value_type& reference; |
153 | typedef value_type* pointer; |
154 | typedef const value_type& const_reference; |
155 | typedef const value_type* const_pointer; |
156 | BOOST_STATIC_CONSTANT(bool, is_mutable=channel_traits<BaseChannelValue>::is_mutable); |
157 | |
158 | typedef BaseChannelValue base_channel_t; |
159 | |
160 | static value_type min_value() { return MinVal::apply(); } |
161 | static value_type max_value() { return MaxVal::apply(); } |
162 | |
163 | scoped_channel_value() {} |
164 | scoped_channel_value(const scoped_channel_value& c) : _value(c._value) {} |
165 | scoped_channel_value(BaseChannelValue val) : _value(val) {} |
166 | |
167 | scoped_channel_value& operator++() { ++_value; return *this; } |
168 | scoped_channel_value& operator--() { --_value; return *this; } |
169 | |
170 | scoped_channel_value operator++(int) { scoped_channel_value tmp=*this; this->operator++(); return tmp; } |
171 | scoped_channel_value operator--(int) { scoped_channel_value tmp=*this; this->operator--(); return tmp; } |
172 | |
173 | template <typename Scalar2> scoped_channel_value& operator+=(Scalar2 v) { _value+=v; return *this; } |
174 | template <typename Scalar2> scoped_channel_value& operator-=(Scalar2 v) { _value-=v; return *this; } |
175 | template <typename Scalar2> scoped_channel_value& operator*=(Scalar2 v) { _value*=v; return *this; } |
176 | template <typename Scalar2> scoped_channel_value& operator/=(Scalar2 v) { _value/=v; return *this; } |
177 | |
178 | scoped_channel_value& operator=(BaseChannelValue v) { _value=v; return *this; } |
179 | operator BaseChannelValue() const { return _value; } |
180 | private: |
181 | BaseChannelValue _value; |
182 | }; |
183 | |
184 | struct float_zero { static float apply() { return 0.0f; } }; |
185 | struct float_one { static float apply() { return 1.0f; } }; |
186 | |
187 | |
188 | /////////////////////////////////////////// |
189 | //// |
190 | //// Support for sub-byte channels. These are integral channels whose value is contained in a range of bits inside an integral type |
191 | //// |
192 | /////////////////////////////////////////// |
193 | |
194 | // 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: |
195 | // - Any operation that requires returning the result by value will otherwise return the built-in integral type, which will have incorrect range |
196 | // That means that after getting the value of the channel we cannot properly do channel_convert, channel_invert, etc. |
197 | // - 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 |
198 | namespace detail { |
199 | // returns the smallest fast unsigned integral type that has at least NumBits bits |
200 | template <int NumBits> |
201 | struct min_fast_uint : public mpl::if_c< (NumBits<=8), |
202 | uint_least8_t, |
203 | typename mpl::if_c< (NumBits<=16), |
204 | uint_least16_t, |
205 | typename mpl::if_c< (NumBits<=32), |
206 | uint_least32_t, |
207 | uintmax_t |
208 | >::type |
209 | >::type |
210 | > {}; |
211 | |
212 | template <int NumBits> |
213 | struct num_value_fn : public mpl::if_c< ( NumBits < 32 ) |
214 | , uint32_t |
215 | , uint64_t |
216 | > {}; |
217 | |
218 | template <int NumBits> |
219 | struct max_value_fn : public mpl::if_c< ( NumBits <= 32 ) |
220 | , uint32_t |
221 | , uint64_t |
222 | > {}; |
223 | } |
224 | |
225 | /** |
226 | \defgroup PackedChannelValueModel packed_channel_value |
227 | \ingroup ChannelModel |
228 | \brief Represents the value of an unsigned integral channel operating over a bit range. Models: ChannelValueConcept |
229 | Example: |
230 | \code |
231 | // A 4-bit unsigned integral channel. |
232 | typedef packed_channel_value<4> bits4; |
233 | |
234 | assert(channel_traits<bits4>::min_value()==0); |
235 | assert(channel_traits<bits4>::max_value()==15); |
236 | assert(sizeof(bits4)==1); |
237 | BOOST_STATIC_ASSERT((boost::is_integral<bits4>::value)); |
238 | \endcode |
239 | */ |
240 | |
241 | /// \ingroup PackedChannelValueModel |
242 | /// \brief The value of a subbyte channel. Models: ChannelValueConcept |
243 | template <int NumBits> |
244 | class packed_channel_value { |
245 | |
246 | typedef typename detail::num_value_fn< NumBits >::type num_value_t; |
247 | static const num_value_t num_values = static_cast< num_value_t >( 1 ) << NumBits ; |
248 | |
249 | public: |
250 | typedef typename detail::min_fast_uint<NumBits>::type integer_t; |
251 | |
252 | |
253 | typedef packed_channel_value value_type; |
254 | typedef value_type& reference; |
255 | typedef const value_type& const_reference; |
256 | typedef value_type* pointer; |
257 | typedef const value_type* const_pointer; |
258 | |
259 | static value_type min_value() { return value_type(0); } |
260 | static value_type max_value() { return value_type(num_values-1); } |
261 | BOOST_STATIC_CONSTANT(bool, is_mutable=true); |
262 | |
263 | packed_channel_value() {} |
264 | packed_channel_value(integer_t v) { _value = static_cast< integer_t >( v % num_values ); } |
265 | packed_channel_value(const packed_channel_value& v) : _value(v._value) {} |
266 | template <typename Scalar> packed_channel_value(Scalar v) { _value = static_cast< integer_t >( v ) % num_values; } |
267 | |
268 | static unsigned int num_bits() { return NumBits; } |
269 | |
270 | |
271 | operator integer_t() const { return _value; } |
272 | private: |
273 | integer_t _value; |
274 | }; |
275 | |
276 | namespace detail { |
277 | |
278 | template <std::size_t K> |
279 | struct static_copy_bytes { |
280 | void operator()(const unsigned char* from, unsigned char* to) const { |
281 | *to = *from; |
282 | static_copy_bytes<K-1>()(++from,++to); |
283 | } |
284 | }; |
285 | |
286 | template <> |
287 | struct static_copy_bytes<0> { |
288 | void operator()(const unsigned char* , unsigned char*) const {} |
289 | }; |
290 | |
291 | template <typename Derived, typename BitField, int NumBits, bool Mutable> |
292 | class packed_channel_reference_base { |
293 | protected: |
294 | typedef typename mpl::if_c<Mutable,void*,const void*>::type data_ptr_t; |
295 | public: |
296 | data_ptr_t _data_ptr; // void* pointer to the first byte of the bit range |
297 | |
298 | typedef packed_channel_value<NumBits> value_type; |
299 | typedef const Derived reference; |
300 | typedef value_type* pointer; |
301 | typedef const value_type* const_pointer; |
302 | BOOST_STATIC_CONSTANT(int, num_bits=NumBits); |
303 | BOOST_STATIC_CONSTANT(bool, is_mutable=Mutable); |
304 | |
305 | static value_type min_value() { return channel_traits<value_type>::min_value(); } |
306 | static value_type max_value() { return channel_traits<value_type>::max_value(); } |
307 | |
308 | typedef BitField bitfield_t; |
309 | typedef typename value_type::integer_t integer_t; |
310 | |
311 | packed_channel_reference_base(data_ptr_t data_ptr) : _data_ptr(data_ptr) {} |
312 | packed_channel_reference_base(const packed_channel_reference_base& ref) : _data_ptr(ref._data_ptr) {} |
313 | const Derived& operator=(integer_t v) const { set(v); return derived(); } |
314 | |
315 | const Derived& operator++() const { set(get()+1); return derived(); } |
316 | const Derived& operator--() const { set(get()-1); return derived(); } |
317 | |
318 | Derived operator++(int) const { Derived tmp=derived(); this->operator++(); return tmp; } |
319 | Derived operator--(int) const { Derived tmp=derived(); this->operator--(); return tmp; } |
320 | |
321 | template <typename Scalar2> const Derived& operator+=(Scalar2 v) const { set(get()+v); return derived(); } |
322 | template <typename Scalar2> const Derived& operator-=(Scalar2 v) const { set(get()-v); return derived(); } |
323 | template <typename Scalar2> const Derived& operator*=(Scalar2 v) const { set(get()*v); return derived(); } |
324 | template <typename Scalar2> const Derived& operator/=(Scalar2 v) const { set(get()/v); return derived(); } |
325 | |
326 | operator integer_t() const { return get(); } |
327 | data_ptr_t operator &() const {return _data_ptr;} |
328 | protected: |
329 | |
330 | typedef typename detail::num_value_fn< NumBits >::type num_value_t; |
331 | typedef typename detail::max_value_fn< NumBits >::type max_value_t; |
332 | |
333 | static const num_value_t num_values = static_cast< num_value_t >( 1 ) << NumBits ; |
334 | static const max_value_t max_val = static_cast< max_value_t >( num_values - 1 ); |
335 | |
336 | #ifdef GIL_NONWORD_POINTER_ALIGNMENT_SUPPORTED |
337 | const bitfield_t& get_data() const { return *static_cast<const bitfield_t*>(_data_ptr); } |
338 | void set_data(const bitfield_t& val) const { *static_cast< bitfield_t*>(_data_ptr) = val; } |
339 | #else |
340 | bitfield_t get_data() const { |
341 | bitfield_t ret; |
342 | static_copy_bytes<sizeof(bitfield_t) >()(gil_reinterpret_cast_c<const unsigned char*>(_data_ptr),gil_reinterpret_cast<unsigned char*>(&ret)); |
343 | return ret; |
344 | } |
345 | void set_data(const bitfield_t& val) const { |
346 | static_copy_bytes<sizeof(bitfield_t) >()(gil_reinterpret_cast_c<const unsigned char*>(&val),gil_reinterpret_cast<unsigned char*>(_data_ptr)); |
347 | } |
348 | #endif |
349 | |
350 | private: |
351 | void set(integer_t value) const { // can this be done faster?? |
352 | const integer_t num_values = max_val+1; |
353 | this->derived().set_unsafe(((value % num_values) + num_values) % num_values); |
354 | } |
355 | integer_t get() const { return derived().get(); } |
356 | const Derived& derived() const { return static_cast<const Derived&>(*this); } |
357 | }; |
358 | } // namespace detail |
359 | |
360 | /** |
361 | \defgroup PackedChannelReferenceModel packed_channel_reference |
362 | \ingroup ChannelModel |
363 | \brief Represents a reference proxy to a channel operating over a bit range whose offset is fixed at compile time. Models ChannelConcept |
364 | Example: |
365 | \code |
366 | // Reference to a 2-bit channel starting at bit 1 (i.e. the second bit) |
367 | typedef const packed_channel_reference<uint16_t,1,2,true> bits2_1_ref_t; |
368 | |
369 | uint16_t data=0; |
370 | bits2_1_ref_t channel_ref(&data); |
371 | channel_ref = channel_traits<bits2_1_ref_t>::max_value(); // == 3 |
372 | assert(data == 6); // == 3<<1 == 6 |
373 | \endcode |
374 | */ |
375 | |
376 | template <typename BitField, // A type that holds the bits of the pixel from which the channel is referenced. Typically an integral type, like boost::uint16_t |
377 | int FirstBit, int NumBits,// Defines the sequence of bits in the data value that contain the channel |
378 | bool Mutable> // true if the reference is mutable |
379 | class packed_channel_reference; |
380 | |
381 | template <typename BitField, // A type that holds the bits of the pixel from which the channel is referenced. Typically an integral type, like boost::uint16_t |
382 | int NumBits, // Defines the sequence of bits in the data value that contain the channel |
383 | bool Mutable> // true if the reference is mutable |
384 | class packed_dynamic_channel_reference; |
385 | |
386 | /// \ingroup PackedChannelReferenceModel |
387 | /// \brief A constant subbyte channel reference whose bit offset is fixed at compile time. Models ChannelConcept |
388 | template <typename BitField, int FirstBit, int NumBits> |
389 | class packed_channel_reference<BitField,FirstBit,NumBits,false> |
390 | : public detail::packed_channel_reference_base<packed_channel_reference<BitField,FirstBit,NumBits,false>,BitField,NumBits,false> { |
391 | typedef detail::packed_channel_reference_base<packed_channel_reference<BitField,FirstBit,NumBits,false>,BitField,NumBits,false> parent_t; |
392 | friend class packed_channel_reference<BitField,FirstBit,NumBits,true>; |
393 | |
394 | static const BitField channel_mask = static_cast< BitField >( parent_t::max_val ) << FirstBit; |
395 | |
396 | void operator=(const packed_channel_reference&); |
397 | public: |
398 | typedef const packed_channel_reference<BitField,FirstBit,NumBits,false> const_reference; |
399 | typedef const packed_channel_reference<BitField,FirstBit,NumBits,true> mutable_reference; |
400 | typedef typename parent_t::integer_t integer_t; |
401 | |
402 | explicit packed_channel_reference(const void* data_ptr) : parent_t(data_ptr) {} |
403 | packed_channel_reference(const packed_channel_reference& ref) : parent_t(ref._data_ptr) {} |
404 | packed_channel_reference(const mutable_reference& ref) : parent_t(ref._data_ptr) {} |
405 | |
406 | unsigned first_bit() const { return FirstBit; } |
407 | |
408 | integer_t get() const { return integer_t((this->get_data()&channel_mask) >> FirstBit); } |
409 | }; |
410 | |
411 | /// \ingroup PackedChannelReferenceModel |
412 | /// \brief A mutable subbyte channel reference whose bit offset is fixed at compile time. Models ChannelConcept |
413 | template <typename BitField, int FirstBit, int NumBits> |
414 | class packed_channel_reference<BitField,FirstBit,NumBits,true> |
415 | : public detail::packed_channel_reference_base<packed_channel_reference<BitField,FirstBit,NumBits,true>,BitField,NumBits,true> { |
416 | typedef detail::packed_channel_reference_base<packed_channel_reference<BitField,FirstBit,NumBits,true>,BitField,NumBits,true> parent_t; |
417 | friend class packed_channel_reference<BitField,FirstBit,NumBits,false>; |
418 | |
419 | static const BitField channel_mask = static_cast< BitField >( parent_t::max_val ) << FirstBit; |
420 | |
421 | public: |
422 | typedef const packed_channel_reference<BitField,FirstBit,NumBits,false> const_reference; |
423 | typedef const packed_channel_reference<BitField,FirstBit,NumBits,true> mutable_reference; |
424 | typedef typename parent_t::integer_t integer_t; |
425 | |
426 | explicit packed_channel_reference(void* data_ptr) : parent_t(data_ptr) {} |
427 | packed_channel_reference(const packed_channel_reference& ref) : parent_t(ref._data_ptr) {} |
428 | |
429 | const packed_channel_reference& operator=(integer_t value) const { assert(value<=parent_t::max_val); set_unsafe(value); return *this; } |
430 | const packed_channel_reference& operator=(const mutable_reference& ref) const { set_from_reference(ref.get_data()); return *this; } |
431 | const packed_channel_reference& operator=(const const_reference& ref) const { set_from_reference(ref.get_data()); return *this; } |
432 | |
433 | template <bool Mutable1> |
434 | const packed_channel_reference& operator=(const packed_dynamic_channel_reference<BitField,NumBits,Mutable1>& ref) const { set_unsafe(ref.get()); return *this; } |
435 | |
436 | unsigned first_bit() const { return FirstBit; } |
437 | |
438 | integer_t get() const { return integer_t((this->get_data()&channel_mask) >> FirstBit); } |
439 | void set_unsafe(integer_t value) const { this->set_data((this->get_data() & ~channel_mask) | (( static_cast< BitField >( value )<<FirstBit))); } |
440 | private: |
441 | void set_from_reference(const BitField& other_bits) const { this->set_data((this->get_data() & ~channel_mask) | (other_bits & channel_mask)); } |
442 | }; |
443 | |
444 | } } // namespace boost::gil |
445 | |
446 | namespace std { |
447 | // We are forced to define swap inside std namespace because on some platforms (Visual Studio 8) STL calls swap qualified. |
448 | // swap with 'left bias': |
449 | // - swap between proxy and anything |
450 | // - swap between value type and proxy |
451 | // - swap between proxy and proxy |
452 | |
453 | /// \ingroup PackedChannelReferenceModel |
454 | /// \brief swap for packed_channel_reference |
455 | template <typename BF, int FB, int NB, bool M, typename R> inline |
456 | void swap(const boost::gil::packed_channel_reference<BF,FB,NB,M> x, R& y) { |
457 | boost::gil::swap_proxy<typename boost::gil::packed_channel_reference<BF,FB,NB,M>::value_type>(x,y); |
458 | } |
459 | |
460 | |
461 | /// \ingroup PackedChannelReferenceModel |
462 | /// \brief swap for packed_channel_reference |
463 | template <typename BF, int FB, int NB, bool M> inline |
464 | 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) { |
465 | boost::gil::swap_proxy<typename boost::gil::packed_channel_reference<BF,FB,NB,M>::value_type>(x,y); |
466 | } |
467 | |
468 | |
469 | /// \ingroup PackedChannelReferenceModel |
470 | /// \brief swap for packed_channel_reference |
471 | template <typename BF, int FB, int NB, bool M> inline |
472 | void swap(const boost::gil::packed_channel_reference<BF,FB,NB,M> x, const boost::gil::packed_channel_reference<BF,FB,NB,M> y) { |
473 | boost::gil::swap_proxy<typename boost::gil::packed_channel_reference<BF,FB,NB,M>::value_type>(x,y); |
474 | } |
475 | } // namespace std |
476 | |
477 | namespace boost { namespace gil { |
478 | |
479 | /** |
480 | \defgroup PackedChannelDynamicReferenceModel packed_dynamic_channel_reference |
481 | \ingroup ChannelModel |
482 | \brief Represents a reference proxy to a channel operating over a bit range whose offset is specified at run time. Models ChannelConcept |
483 | |
484 | Example: |
485 | \code |
486 | // Reference to a 2-bit channel whose offset is specified at construction time |
487 | typedef const packed_dynamic_channel_reference<uint8_t,2,true> bits2_dynamic_ref_t; |
488 | |
489 | uint16_t data=0; |
490 | bits2_dynamic_ref_t channel_ref(&data,1); |
491 | channel_ref = channel_traits<bits2_dynamic_ref_t>::max_value(); // == 3 |
492 | assert(data == 6); // == (3<<1) == 6 |
493 | \endcode |
494 | */ |
495 | |
496 | /// \brief Models a constant subbyte channel reference whose bit offset is a runtime parameter. Models ChannelConcept |
497 | /// Same as packed_channel_reference, except that the offset is a runtime parameter |
498 | /// \ingroup PackedChannelDynamicReferenceModel |
499 | template <typename BitField, int NumBits> |
500 | class packed_dynamic_channel_reference<BitField,NumBits,false> |
501 | : public detail::packed_channel_reference_base<packed_dynamic_channel_reference<BitField,NumBits,false>,BitField,NumBits,false> { |
502 | typedef detail::packed_channel_reference_base<packed_dynamic_channel_reference<BitField,NumBits,false>,BitField,NumBits,false> parent_t; |
503 | friend class packed_dynamic_channel_reference<BitField,NumBits,true>; |
504 | |
505 | unsigned _first_bit; // 0..7 |
506 | |
507 | void operator=(const packed_dynamic_channel_reference&); |
508 | public: |
509 | typedef const packed_dynamic_channel_reference<BitField,NumBits,false> const_reference; |
510 | typedef const packed_dynamic_channel_reference<BitField,NumBits,true> mutable_reference; |
511 | typedef typename parent_t::integer_t integer_t; |
512 | |
513 | packed_dynamic_channel_reference(const void* data_ptr, unsigned first_bit) : parent_t(data_ptr), _first_bit(first_bit) {} |
514 | packed_dynamic_channel_reference(const const_reference& ref) : parent_t(ref._data_ptr), _first_bit(ref._first_bit) {} |
515 | packed_dynamic_channel_reference(const mutable_reference& ref) : parent_t(ref._data_ptr), _first_bit(ref._first_bit) {} |
516 | |
517 | unsigned first_bit() const { return _first_bit; } |
518 | |
519 | integer_t get() const { |
520 | const BitField channel_mask = static_cast< integer_t >( parent_t::max_val ) <<_first_bit; |
521 | return static_cast< integer_t >(( this->get_data()&channel_mask ) >> _first_bit ); |
522 | } |
523 | }; |
524 | |
525 | /// \brief Models a mutable subbyte channel reference whose bit offset is a runtime parameter. Models ChannelConcept |
526 | /// Same as packed_channel_reference, except that the offset is a runtime parameter |
527 | /// \ingroup PackedChannelDynamicReferenceModel |
528 | template <typename BitField, int NumBits> |
529 | class packed_dynamic_channel_reference<BitField,NumBits,true> |
530 | : public detail::packed_channel_reference_base<packed_dynamic_channel_reference<BitField,NumBits,true>,BitField,NumBits,true> { |
531 | typedef detail::packed_channel_reference_base<packed_dynamic_channel_reference<BitField,NumBits,true>,BitField,NumBits,true> parent_t; |
532 | friend class packed_dynamic_channel_reference<BitField,NumBits,false>; |
533 | |
534 | unsigned _first_bit; |
535 | |
536 | public: |
537 | typedef const packed_dynamic_channel_reference<BitField,NumBits,false> const_reference; |
538 | typedef const packed_dynamic_channel_reference<BitField,NumBits,true> mutable_reference; |
539 | typedef typename parent_t::integer_t integer_t; |
540 | |
541 | packed_dynamic_channel_reference(void* data_ptr, unsigned first_bit) : parent_t(data_ptr), _first_bit(first_bit) {} |
542 | packed_dynamic_channel_reference(const packed_dynamic_channel_reference& ref) : parent_t(ref._data_ptr), _first_bit(ref._first_bit) {} |
543 | |
544 | const packed_dynamic_channel_reference& operator=(integer_t value) const { assert(value<=parent_t::max_val); set_unsafe(value); return *this; } |
545 | const packed_dynamic_channel_reference& operator=(const mutable_reference& ref) const { set_unsafe(ref.get()); return *this; } |
546 | const packed_dynamic_channel_reference& operator=(const const_reference& ref) const { set_unsafe(ref.get()); return *this; } |
547 | |
548 | template <typename BitField1, int FirstBit1, bool Mutable1> |
549 | const packed_dynamic_channel_reference& operator=(const packed_channel_reference<BitField1, FirstBit1, NumBits, Mutable1>& ref) const |
550 | { set_unsafe(ref.get()); return *this; } |
551 | |
552 | unsigned first_bit() const { return _first_bit; } |
553 | |
554 | integer_t get() const { |
555 | const BitField channel_mask = static_cast< integer_t >( parent_t::max_val ) << _first_bit; |
556 | return static_cast< integer_t >(( this->get_data()&channel_mask ) >> _first_bit ); |
557 | } |
558 | |
559 | void set_unsafe(integer_t value) const { |
560 | const BitField channel_mask = static_cast< integer_t >( parent_t::max_val ) << _first_bit; |
561 | this->set_data((this->get_data() & ~channel_mask) | value<<_first_bit); |
562 | } |
563 | }; |
564 | } } // namespace boost::gil |
565 | |
566 | namespace std { |
567 | // We are forced to define swap inside std namespace because on some platforms (Visual Studio 8) STL calls swap qualified. |
568 | // swap with 'left bias': |
569 | // - swap between proxy and anything |
570 | // - swap between value type and proxy |
571 | // - swap between proxy and proxy |
572 | |
573 | |
574 | /// \ingroup PackedChannelDynamicReferenceModel |
575 | /// \brief swap for packed_dynamic_channel_reference |
576 | template <typename BF, int NB, bool M, typename R> inline |
577 | void swap(const boost::gil::packed_dynamic_channel_reference<BF,NB,M> x, R& y) { |
578 | boost::gil::swap_proxy<typename boost::gil::packed_dynamic_channel_reference<BF,NB,M>::value_type>(x,y); |
579 | } |
580 | |
581 | |
582 | /// \ingroup PackedChannelDynamicReferenceModel |
583 | /// \brief swap for packed_dynamic_channel_reference |
584 | template <typename BF, int NB, bool M> inline |
585 | 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) { |
586 | boost::gil::swap_proxy<typename boost::gil::packed_dynamic_channel_reference<BF,NB,M>::value_type>(x,y); |
587 | } |
588 | |
589 | |
590 | /// \ingroup PackedChannelDynamicReferenceModel |
591 | /// \brief swap for packed_dynamic_channel_reference |
592 | template <typename BF, int NB, bool M> inline |
593 | void swap(const boost::gil::packed_dynamic_channel_reference<BF,NB,M> x, const boost::gil::packed_dynamic_channel_reference<BF,NB,M> y) { |
594 | boost::gil::swap_proxy<typename boost::gil::packed_dynamic_channel_reference<BF,NB,M>::value_type>(x,y); |
595 | } |
596 | } // namespace std |
597 | |
598 | namespace boost { namespace gil { |
599 | /////////////////////////////////////////// |
600 | //// |
601 | //// Built-in channel models |
602 | //// |
603 | /////////////////////////////////////////// |
604 | |
605 | /// \defgroup bits8 bits8 |
606 | /// \ingroup ChannelModel |
607 | /// \brief 8-bit unsigned integral channel type (typedef from uint8_t). Models ChannelValueConcept |
608 | |
609 | /// \ingroup bits8 |
610 | typedef uint8_t bits8; |
611 | |
612 | /// \defgroup bits16 bits16 |
613 | /// \ingroup ChannelModel |
614 | /// \brief 16-bit unsigned integral channel type (typedef from uint16_t). Models ChannelValueConcept |
615 | |
616 | /// \ingroup bits16 |
617 | typedef uint16_t bits16; |
618 | |
619 | /// \defgroup bits32 bits32 |
620 | /// \ingroup ChannelModel |
621 | /// \brief 32-bit unsigned integral channel type (typedef from uint32_t). Models ChannelValueConcept |
622 | |
623 | /// \ingroup bits32 |
624 | typedef uint32_t bits32; |
625 | |
626 | /// \defgroup bits8s bits8s |
627 | /// \ingroup ChannelModel |
628 | /// \brief 8-bit signed integral channel type (typedef from int8_t). Models ChannelValueConcept |
629 | |
630 | /// \ingroup bits8s |
631 | typedef int8_t bits8s; |
632 | |
633 | /// \defgroup bits16s bits16s |
634 | /// \ingroup ChannelModel |
635 | /// \brief 16-bit signed integral channel type (typedef from int16_t). Models ChannelValueConcept |
636 | |
637 | /// \ingroup bits16s |
638 | typedef int16_t bits16s; |
639 | |
640 | /// \defgroup bits32s bits32s |
641 | /// \ingroup ChannelModel |
642 | /// \brief 32-bit signed integral channel type (typedef from int32_t). Models ChannelValueConcept |
643 | |
644 | /// \ingroup bits32s |
645 | typedef int32_t bits32s; |
646 | |
647 | /// \defgroup bits32f bits32f |
648 | /// \ingroup ChannelModel |
649 | /// \brief 32-bit floating point channel type with range [0.0f ... 1.0f]. Models ChannelValueConcept |
650 | |
651 | /// \ingroup bits32f |
652 | typedef scoped_channel_value<float,float_zero,float_one> bits32f; |
653 | |
654 | } } // namespace boost::gil |
655 | |
656 | namespace boost { |
657 | |
658 | template <int NumBits> |
659 | struct is_integral<gil::packed_channel_value<NumBits> > : public mpl::true_ {}; |
660 | |
661 | template <typename BitField, int FirstBit, int NumBits, bool IsMutable> |
662 | struct is_integral<gil::packed_channel_reference<BitField,FirstBit,NumBits,IsMutable> > : public mpl::true_ {}; |
663 | |
664 | template <typename BitField, int NumBits, bool IsMutable> |
665 | struct is_integral<gil::packed_dynamic_channel_reference<BitField,NumBits,IsMutable> > : public mpl::true_ {}; |
666 | |
667 | template <typename BaseChannelValue, typename MinVal, typename MaxVal> |
668 | struct is_integral<gil::scoped_channel_value<BaseChannelValue,MinVal,MaxVal> > : public is_integral<BaseChannelValue> {}; |
669 | |
670 | } |
671 | |
672 | #endif |
673 | |