channel.hpp Go to the documentation of this file. /* Copyright 2005-2007 Adobe Systems Incorporated Use, modification and distribution are subject to the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt). See http://opensource.adobe.com/gil for most recent version including documentation. */ /*************************************************************************************************/ #ifndef GIL_CHANNEL_HPP #define GIL_CHANNEL_HPP #include <limits> #include <cassert> #include <boost/cstdint.hpp> #include "gil_config.hpp" #include "utilities.hpp" namespace boost { namespace gil { namespace detail { template <typename T, bool is_class> struct channel_traits_impl; // channel traits for custom class template <typename T> struct channel_traits_impl<T, true> { typedef typename T::value_type value_type; typedef typename T::reference reference; typedef typename T::pointer pointer; typedef typename T::const_reference const_reference; typedef typename T::const_pointer const_pointer; BOOST_STATIC_CONSTANT(bool, is_mutable=T::is_mutable); static value_type min_value() { return T::min_value(); } static value_type max_value() { return T::max_value(); } }; // channel traits implementation for built-in integral or floating point channel type template <typename T> struct channel_traits_impl<T, false> { typedef T value_type; typedef T& reference; typedef T* pointer; typedef const T& const_reference; typedef T const* const_pointer; BOOST_STATIC_CONSTANT(bool, is_mutable=true); static value_type min_value() { return (std::numeric_limits<T>::min)(); } static value_type max_value() { return (std::numeric_limits<T>::max)(); } }; // channel traits implementation for constant built-in scalar or floating point type template <typename T> struct channel_traits_impl<const T, false> : public channel_traits_impl<T, false> { typedef const T& reference; typedef const T* pointer; BOOST_STATIC_CONSTANT(bool, is_mutable=false); }; } template <typename T> struct channel_traits : public detail::channel_traits_impl<T, is_class<T>::value> {}; // Channel traits for C++ reference type - remove the reference template <typename T> struct channel_traits< T&> : public channel_traits<T> {}; // Channel traits for constant C++ reference type template <typename T> struct channel_traits<const T&> : public channel_traits<T> { typedef typename channel_traits<T>::const_reference reference; typedef typename channel_traits<T>::const_pointer pointer; BOOST_STATIC_CONSTANT(bool, is_mutable=false); }; template <typename BaseChannelValue, // base channel (models ChannelValueConcept) typename MinVal, typename MaxVal> // classes with a static apply() function returning the minimum/maximum channel values struct scoped_channel_value { typedef scoped_channel_value value_type; typedef value_type& reference; typedef value_type* pointer; typedef const value_type& const_reference; typedef const value_type* const_pointer; BOOST_STATIC_CONSTANT(bool, is_mutable=channel_traits<BaseChannelValue>::is_mutable); static value_type min_value() { return MinVal::apply(); } static value_type max_value() { return MaxVal::apply(); } scoped_channel_value() {} scoped_channel_value(const scoped_channel_value& c) : _value(c._value) {} scoped_channel_value(BaseChannelValue val) : _value(val) {} scoped_channel_value& operator++() { ++_value; return *this; } scoped_channel_value& operator--() { --_value; return *this; } scoped_channel_value operator++(int) { scoped_channel_value tmp=*this; this->operator++(); return tmp; } scoped_channel_value operator--(int) { scoped_channel_value tmp=*this; this->operator--(); return tmp; } template <typename Scalar2> scoped_channel_value& operator+=(Scalar2 v) { _value+=v; return *this; } template <typename Scalar2> scoped_channel_value& operator-=(Scalar2 v) { _value-=v; return *this; } template <typename Scalar2> scoped_channel_value& operator*=(Scalar2 v) { _value*=v; return *this; } template <typename Scalar2> scoped_channel_value& operator/=(Scalar2 v) { _value/=v; return *this; } scoped_channel_value& operator=(BaseChannelValue v) { _value=v; return *this; } operator BaseChannelValue() const { return _value; } private: BaseChannelValue _value; }; struct float_zero { static float apply() { return 0.0f; } }; struct float_one { static float apply() { return 1.0f; } }; // 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: // - Any operation that requires returning the result by value will otherwise return the built-in integral type, which will have incorrect range // That means that after getting the value of the channel we cannot properly do channel_convert, channel_invert, etc. // - 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 namespace detail { // returns the smallest fast unsigned integral type that has at least NumBits bits template <int NumBits> struct min_fast_uint : public mpl::if_c< (NumBits<=8), uint_least8_t, typename mpl::if_c< (NumBits<=16), uint_least16_t, typename mpl::if_c< (NumBits<=32), uint_least32_t, uintmax_t >::type >::type > {}; } template <int NumBits> class packed_channel_value { static const std::size_t num_values = 1<<NumBits; public: typedef typename detail::min_fast_uint<NumBits>::type integer_t; typedef packed_channel_value value_type; typedef value_type& reference; typedef const value_type& const_reference; typedef value_type* pointer; typedef const value_type* const_pointer; static value_type min_value() { return value_type(0); } static value_type max_value() { return value_type(num_values-1); } BOOST_STATIC_CONSTANT(bool, is_mutable=true); packed_channel_value() {} packed_channel_value(integer_t v) : _value(v % num_values) {} packed_channel_value(const packed_channel_value& v) : _value(v._value) {} template <typename Scalar> packed_channel_value(Scalar v) : _value(integer_t(v) % num_values) {} // suppress GCC implicit conversion warnings in channel regression file operator integer_t() const { return _value; } private: integer_t _value; }; namespace detail { template <typename Derived, typename BitField, int NumBits, bool Mutable> class packed_channel_reference_base { protected: typedef typename mpl::if_c<Mutable,void*,const void*>::type data_ptr_t; public: data_ptr_t _data_ptr; // void* pointer to the first byte of the bit range typedef packed_channel_value<NumBits> value_type; typedef const Derived reference; typedef value_type* pointer; typedef const value_type* const_pointer; BOOST_STATIC_CONSTANT(int, num_bits=NumBits); BOOST_STATIC_CONSTANT(bool, is_mutable=Mutable); static value_type min_value() { return channel_traits<value_type>::min_value(); } static value_type max_value() { return channel_traits<value_type>::max_value(); } typedef BitField bitfield_t; typedef typename value_type::integer_t integer_t; packed_channel_reference_base(data_ptr_t data_ptr) : _data_ptr(data_ptr) {} packed_channel_reference_base(const packed_channel_reference_base& ref) : _data_ptr(ref._data_ptr) {} const Derived& operator=(integer_t v) const { set(v); return derived(); } const Derived& operator++() const { set(get()+1); return derived(); } const Derived& operator--() const { set(get()-1); return derived(); } Derived operator++(int) const { Derived tmp=derived(); this->operator++(); return tmp; } Derived operator--(int) const { Derived tmp=derived(); this->operator--(); return tmp; } template <typename Scalar2> const Derived& operator+=(Scalar2 v) const { set(get()+v); return derived(); } template <typename Scalar2> const Derived& operator-=(Scalar2 v) const { set(get()-v); return derived(); } template <typename Scalar2> const Derived& operator*=(Scalar2 v) const { set(get()*v); return derived(); } template <typename Scalar2> const Derived& operator/=(Scalar2 v) const { set(get()/v); return derived(); } operator integer_t() const { return get(); } data_ptr_t operator &() const {return _data_ptr;} protected: static const integer_t max_val = (1<<NumBits) - 1; const bitfield_t& const_data() const { return *static_cast<const bitfield_t*>(_data_ptr); } bitfield_t& data() const { return *static_cast< bitfield_t*>(_data_ptr); } private: void set(integer_t value) const { // can this be done faster?? const integer_t num_values = max_val+1; this->derived().set_unsafe(((value % num_values) + num_values) % num_values); } integer_t get() const { return derived().get(); } const Derived& derived() const { return static_cast<const Derived&>(*this); } }; } // namespace detail 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 int FirstBit, int NumBits,// Defines the sequence of bits in the data value that contain the channel bool Mutable> // true if the reference is mutable class packed_channel_reference; 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 int NumBits, // Defines the sequence of bits in the data value that contain the channel bool Mutable> // true if the reference is mutable class packed_dynamic_channel_reference; template <typename BitField, int FirstBit, int NumBits> class packed_channel_reference<BitField,FirstBit,NumBits,false> : public detail::packed_channel_reference_base<packed_channel_reference<BitField,FirstBit,NumBits,false>,BitField,NumBits,false> { typedef detail::packed_channel_reference_base<packed_channel_reference<BitField,FirstBit,NumBits,false>,BitField,NumBits,false> parent_t; friend class packed_channel_reference<BitField,FirstBit,NumBits,true>; static const BitField channel_mask = parent_t::max_val<<FirstBit; void operator=(const packed_channel_reference&); public: typedef const packed_channel_reference<BitField,FirstBit,NumBits,false> const_reference; typedef const packed_channel_reference<BitField,FirstBit,NumBits,true> mutable_reference; typedef typename parent_t::integer_t integer_t; explicit packed_channel_reference(const void* data_ptr) : parent_t(data_ptr) {} packed_channel_reference(const packed_channel_reference& ref) : parent_t(ref._data_ptr) {} packed_channel_reference(const mutable_reference& ref) : parent_t(ref._data_ptr) {} unsigned first_bit() const { return FirstBit; } integer_t get() const { return integer_t((this->const_data()&channel_mask) >> FirstBit); } }; template <typename BitField, int FirstBit, int NumBits> class packed_channel_reference<BitField,FirstBit,NumBits,true> : public detail::packed_channel_reference_base<packed_channel_reference<BitField,FirstBit,NumBits,true>,BitField,NumBits,true> { typedef detail::packed_channel_reference_base<packed_channel_reference<BitField,FirstBit,NumBits,true>,BitField,NumBits,true> parent_t; friend class packed_channel_reference<BitField,FirstBit,NumBits,false>; static const BitField channel_mask = parent_t::max_val<<FirstBit; public: typedef const packed_channel_reference<BitField,FirstBit,NumBits,false> const_reference; typedef const packed_channel_reference<BitField,FirstBit,NumBits,true> mutable_reference; typedef typename parent_t::integer_t integer_t; explicit packed_channel_reference(void* data_ptr) : parent_t(data_ptr) {} packed_channel_reference(const packed_channel_reference& ref) : parent_t(ref._data_ptr) {} const packed_channel_reference& operator=(integer_t value) const { assert(value<=parent_t::max_val); set_unsafe(value); return *this; } const packed_channel_reference& operator=(const mutable_reference& ref) const { set_from_reference(ref.data()); return *this; } const packed_channel_reference& operator=(const const_reference& ref) const { set_from_reference(ref.const_data()); return *this; } template <bool Mutable1> const packed_channel_reference& operator=(const packed_dynamic_channel_reference<BitField,NumBits,Mutable1>& ref) const { set_unsafe(ref.get()); return *this; } unsigned first_bit() const { return FirstBit; } integer_t get() const { return integer_t((this->const_data()&channel_mask) >> FirstBit); } void set_unsafe(integer_t value) const { this->data() = (this->const_data() & ~channel_mask) | (value<<FirstBit); } private: void set_from_reference(const BitField& other_bits) const { this->data() = (this->const_data() & ~channel_mask) | (other_bits & channel_mask); } }; } } // namespace boost::gil namespace std { // We are forced to define swap inside std namespace because on some platforms (Visual Studio 8) STL calls swap qualified. // swap with 'left bias': // - swap between proxy and anything // - swap between value type and proxy // - swap between proxy and proxy template <typename BF, int FB, int NB, bool M, typename R> inline void swap(boost::gil::packed_channel_reference<BF,FB,NB,M> x, R& y) { boost::gil::swap_proxy<typename boost::gil::packed_channel_reference<BF,FB,NB,M>::value_type>(x,y); } template <typename BF, int FB, int NB, bool M> inline void swap(typename boost::gil::packed_channel_reference<BF,FB,NB,M>::value_type& x, boost::gil::packed_channel_reference<BF,FB,NB,M> y) { boost::gil::swap_proxy<typename boost::gil::packed_channel_reference<BF,FB,NB,M>::value_type>(x,y); } template <typename BF, int FB, int NB, bool M> inline void swap(boost::gil::packed_channel_reference<BF,FB,NB,M> x, boost::gil::packed_channel_reference<BF,FB,NB,M> y) { boost::gil::swap_proxy<typename boost::gil::packed_channel_reference<BF,FB,NB,M>::value_type>(x,y); } } // namespace std namespace boost { namespace gil { template <typename BitField, int NumBits> class packed_dynamic_channel_reference<BitField,NumBits,false> : public detail::packed_channel_reference_base<packed_dynamic_channel_reference<BitField,NumBits,false>,BitField,NumBits,false> { typedef detail::packed_channel_reference_base<packed_dynamic_channel_reference<BitField,NumBits,false>,BitField,NumBits,false> parent_t; friend class packed_dynamic_channel_reference<BitField,NumBits,true>; unsigned _first_bit; // 0..7 void operator=(const packed_dynamic_channel_reference&); public: typedef const packed_dynamic_channel_reference<BitField,NumBits,false> const_reference; typedef const packed_dynamic_channel_reference<BitField,NumBits,true> mutable_reference; typedef typename parent_t::integer_t integer_t; packed_dynamic_channel_reference(const void* data_ptr, unsigned first_bit) : parent_t(data_ptr), _first_bit(first_bit) {} packed_dynamic_channel_reference(const const_reference& ref) : parent_t(ref._data_ptr), _first_bit(ref._first_bit) {} packed_dynamic_channel_reference(const mutable_reference& ref) : parent_t(ref._data_ptr), _first_bit(ref._first_bit) {} unsigned first_bit() const { return _first_bit; } integer_t get() const { const BitField channel_mask = parent_t::max_val<<_first_bit; return (this->const_data()&channel_mask) >> _first_bit; } }; template <typename BitField, int NumBits> class packed_dynamic_channel_reference<BitField,NumBits,true> : public detail::packed_channel_reference_base<packed_dynamic_channel_reference<BitField,NumBits,true>,BitField,NumBits,true> { typedef detail::packed_channel_reference_base<packed_dynamic_channel_reference<BitField,NumBits,true>,BitField,NumBits,true> parent_t; friend class packed_dynamic_channel_reference<BitField,NumBits,false>; unsigned _first_bit; public: typedef const packed_dynamic_channel_reference<BitField,NumBits,false> const_reference; typedef const packed_dynamic_channel_reference<BitField,NumBits,true> mutable_reference; typedef typename parent_t::integer_t integer_t; packed_dynamic_channel_reference(void* data_ptr, unsigned first_bit) : parent_t((((char*)data_ptr)+first_bit/8)), _first_bit(first_bit%8) {} packed_dynamic_channel_reference(const packed_dynamic_channel_reference& ref) : parent_t(ref._data_ptr), _first_bit(ref._first_bit) {} const packed_dynamic_channel_reference& operator=(integer_t value) const { assert(value<=parent_t::max_val); set_unsafe(value); return *this; } const packed_dynamic_channel_reference& operator=(const mutable_reference& ref) const { set_unsafe(ref.get()); return *this; } const packed_dynamic_channel_reference& operator=(const const_reference& ref) const { set_unsafe(ref.get()); return *this; } template <typename BitField1, int FirstBit1, bool Mutable1> const packed_dynamic_channel_reference& operator=(const packed_channel_reference<BitField1, FirstBit1, NumBits, Mutable1>& ref) const { set_unsafe(ref.get()); return *this; } unsigned first_bit() const { return _first_bit; } integer_t get() const { const BitField channel_mask = parent_t::max_val<<_first_bit; return (this->const_data()&channel_mask) >> _first_bit; } void set_unsafe(integer_t value) const { const BitField channel_mask = parent_t::max_val<<_first_bit; this->data() = (this->const_data() & ~channel_mask) | value<<_first_bit; } }; } } // namespace boost::gil namespace std { // We are forced to define swap inside std namespace because on some platforms (Visual Studio 8) STL calls swap qualified. // swap with 'left bias': // - swap between proxy and anything // - swap between value type and proxy // - swap between proxy and proxy template <typename BF, int NB, bool M, typename R> inline void swap(boost::gil::packed_dynamic_channel_reference<BF,NB,M> x, R& y) { boost::gil::swap_proxy<typename boost::gil::packed_dynamic_channel_reference<BF,NB,M>::value_type>(x,y); } template <typename BF, int NB, bool M> inline void swap(typename boost::gil::packed_dynamic_channel_reference<BF,NB,M>::value_type& x, boost::gil::packed_dynamic_channel_reference<BF,NB,M> y) { boost::gil::swap_proxy<typename boost::gil::packed_dynamic_channel_reference<BF,NB,M>::value_type>(x,y); } template <typename BF, int NB, bool M> inline void swap(boost::gil::packed_dynamic_channel_reference<BF,NB,M> x, boost::gil::packed_dynamic_channel_reference<BF,NB,M> y) { boost::gil::swap_proxy<typename boost::gil::packed_dynamic_channel_reference<BF,NB,M>::value_type>(x,y); } } // namespace std namespace boost { namespace gil { typedef uint8_t bits8; typedef uint16_t bits16; typedef uint32_t bits32; typedef int8_t bits8s; typedef int16_t bits16s; typedef int32_t bits32s; typedef scoped_channel_value<float,float_zero,float_one> bits32f; } } // namespace boost::gil namespace boost { template <int NumBits> struct is_integral<gil::packed_channel_value<NumBits> > : public mpl::true_ {}; template <typename BitField, int FirstBit, int NumBits, bool IsMutable> struct is_integral<gil::packed_channel_reference<BitField,FirstBit,NumBits,IsMutable> > : public mpl::true_ {}; template <typename BitField, int NumBits, bool IsMutable> struct is_integral<gil::packed_dynamic_channel_reference<BitField,NumBits,IsMutable> > : public mpl::true_ {}; template <typename BaseChannelValue, typename MinVal, typename MaxVal> struct is_integral<gil::scoped_channel_value<BaseChannelValue,MinVal,MaxVal> > : public is_integral<BaseChannelValue> {}; } #endif

• Company | 
• Online Privacy Policy | 
• Terms of Use | 
• Contact Us | 
• Accessibility | 
• Report Piracy | 
• Permissions & Trademarks | 
• Product License Agreements | 
• Send Feedback

Copyright © 2006-2007 Adobe Systems Incorporated.

Use of this website signifies your agreement to the Terms of Use and Online Privacy Policy.

Search powered by Google