x
Yes
No
Do you want to visit DriveHQ English website?
首页
产品服务
价格
免费试用
下载客户端
关于我们
云文件服务
|
云备份服务
|
FTP服务
|
企业邮箱服务
|
网站托管
|
客户端软件
云文件服务
云备份服务
FTP服务
企业级邮箱服务
网站托管
客户端软件
channel_algorithm.hpp - Hosted on DriveHQ Cloud IT Platform
返回上层目录
上传
下载
共享
发布
新建文件夹
新建文件
复制
剪切
删除
粘贴
评论
升级服务
路径: \\game3dprogramming\materials\GameFactory\GameFactoryDemo\references\boost_1_35_0\boost\gil\channel_algorithm.hpp
旋转
特效
属性
历史版本
/* 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_ALGORITHM_HPP #define GIL_CHANNEL_ALGORITHM_HPP //////////////////////////////////////////////////////////////////////////////////////// /// \file /// \brief Channel algorithms /// \author Lubomir Bourdev and Hailin Jin \n /// Adobe Systems Incorporated /// \date 2005-2007 \n Last updated on May 6, 2007 /// /// Definitions of standard GIL 8-bit, 16-bit, 32-bit channels /// //////////////////////////////////////////////////////////////////////////////////////// #include "gil_config.hpp" #include "channel.hpp" #include
#include
#include
#include
namespace boost { namespace gil { //#ifdef _MSC_VER //#pragma warning(push) //#pragma warning(disable: 4309) // disable truncation of constant value warning (using -1 to get the max value of an integral) //#endif namespace detail { // some forward declarations template
struct channel_converter_unsigned_impl; template
struct channel_converter_unsigned_integral; template
struct channel_converter_unsigned_integral_impl; template
struct channel_converter_unsigned_integral_nondivisible; ////////////////////////////////////// //// unsigned_integral_max_value - given an unsigned integral channel type, returns its maximum value as an MPL integral constant ////////////////////////////////////// template
struct unsigned_integral_max_value : public mpl::integral_c
{}; template <> struct unsigned_integral_max_value
: public mpl::integral_c
{}; template <> struct unsigned_integral_max_value
: public mpl::integral_c
{}; template <> struct unsigned_integral_max_value
: public mpl::integral_c
{}; template
struct unsigned_integral_max_value
> : public mpl::integral_c
::integer_t, (1<
{}; ////////////////////////////////////// //// unsigned_integral_num_bits - given an unsigned integral channel type, returns the minimum number of bits needed to represent it ////////////////////////////////////// template
struct unsigned_integral_num_bits : public mpl::int_
{}; template
struct unsigned_integral_num_bits
> : public mpl::int_
{}; } // namespace detail /** \defgroup ChannelConvertAlgorithm channel_convert \brief Converting from one channel type to another \ingroup ChannelAlgorithm Conversion is done as a simple linear mapping of one channel range to the other, such that the minimum/maximum value of the source maps to the minimum/maximum value of the destination. One implication of this is that the value 0 of signed channels may not be preserved! When creating new channel models, it is often a good idea to provide specializations for the channel conversion algorithms, for example, for performance optimizations. If the new model is an integral type that can be signed, it is easier to define the conversion only for the unsigned type (\p channel_converter_unsigned) and provide specializations of \p detail::channel_convert_to_unsigned and \p detail::channel_convert_from_unsigned to convert between the signed and unsigned type. Example: \code // bits32f is a floating point channel with range [0.0f ... 1.0f] bits32f src_channel = channel_traits
::max_value(); assert(src_channel == 1); // bits8 is 8-bit unsigned integral channel (typedef-ed from unsigned char) bits8 dst_channel = channel_convert
(src_channel); assert(dst_channel == 255); // max value goes to max value \endcode */ /** \defgroup ChannelConvertUnsignedAlgorithm channel_converter_unsigned \ingroup ChannelConvertAlgorithm \brief Convert one unsigned/floating point channel to another. Converts both the channel type and range @{ */ ////////////////////////////////////// //// channel_converter_unsigned ////////////////////////////////////// template
// Model ChannelValueConcept struct channel_converter_unsigned : public detail::channel_converter_unsigned_impl
::value,is_integral
::value> {}; /// \brief Converting a channel to itself - identity operation template
struct channel_converter_unsigned
: public detail::identity
{}; namespace detail { ////////////////////////////////////// //// channel_converter_unsigned_impl ////////////////////////////////////// /// \brief This is the default implementation. Performance specializatons are provided template
struct channel_converter_unsigned_impl : public std::unary_function
{ DstChannelV operator()(SrcChannelV src) const { return DstChannelV(channel_traits
::min_value() + (src - channel_traits
::min_value()) / channel_range
() * channel_range
()); } private: template
static double channel_range() { return double(channel_traits
::max_value()) - double(channel_traits
::min_value()); } }; // When both the source and the destination are integral channels, perform a faster conversion template
struct channel_converter_unsigned_impl
: public channel_converter_unsigned_integral
,unsigned_integral_max_value
>::value > {}; ////////////////////////////////////// //// channel_converter_unsigned_integral ////////////////////////////////////// template
struct channel_converter_unsigned_integral
: public channel_converter_unsigned_integral_impl
::value % unsigned_integral_max_value
::value) > {}; template
struct channel_converter_unsigned_integral
: public channel_converter_unsigned_integral_impl
::value % unsigned_integral_max_value
::value) > {}; ////////////////////////////////////// //// channel_converter_unsigned_integral_impl ////////////////////////////////////// // Both source and destination are unsigned integral channels, // the src max value is less than the dst max value, // and the dst max value is divisible by the src max value template
struct channel_converter_unsigned_integral_impl
{ DstChannelV operator()(SrcChannelV src) const { typedef typename unsigned_integral_max_value
::value_type integer_t; static const integer_t mul = unsigned_integral_max_value
::value / unsigned_integral_max_value
::value; return DstChannelV(src * mul); } }; // Both source and destination are unsigned integral channels, // the dst max value is less than (or equal to) the src max value, // and the src max value is divisible by the dst max value template
struct channel_converter_unsigned_integral_impl
{ DstChannelV operator()(SrcChannelV src) const { typedef typename unsigned_integral_max_value
::value_type integer_t; static const integer_t div = unsigned_integral_max_value
::value / unsigned_integral_max_value
::value; static const integer_t div2 = div/2; return DstChannelV((src + div2) / div); } }; // Prevent overflow for the largest integral type template
struct channel_converter_unsigned_integral_impl
{ DstChannelV operator()(uintmax_t src) const { static const uintmax_t div = unsigned_integral_max_value
::value / unsigned_integral_max_value
::value; static const uintmax_t div2 = div/2; if (src > unsigned_integral_max_value
::value - div2) return unsigned_integral_max_value
::value; return DstChannelV((src + div2) / div); } }; // Both source and destination are unsigned integral channels, // and the dst max value is not divisible by the src max value // See if you can represent the expression (src * dst_max) / src_max in integral form template
struct channel_converter_unsigned_integral_impl
: public channel_converter_unsigned_integral_nondivisible
,unsigned_integral_num_bits
>, unsigned_integral_num_bits
>::value> {}; // Both source and destination are unsigned integral channels, // the src max value is less than the dst max value, // and the dst max value is not divisible by the src max value // The expression (src * dst_max) / src_max fits in an integer template
struct channel_converter_unsigned_integral_nondivisible
{ DstChannelV operator()(SrcChannelV src) const { typedef typename detail::min_fast_uint
::value+unsigned_integral_num_bits
::value>::type integer_t; return DstChannelV(integer_t(src * unsigned_integral_max_value
::value) / unsigned_integral_max_value
::value); } }; // Both source and destination are unsigned integral channels, // the src max value is less than the dst max value, // and the dst max value is not divisible by the src max value // The expression (src * dst_max) / src_max cannot fit in an integer (overflows). Use a double template
struct channel_converter_unsigned_integral_nondivisible
{ DstChannelV operator()(SrcChannelV src) const { static const double mul = unsigned_integral_max_value
::value / double(unsigned_integral_max_value
::value); return DstChannelV(src * mul); } }; // Both source and destination are unsigned integral channels, // the dst max value is less than (or equal to) the src max value, // and the src max value is not divisible by the dst max value template
struct channel_converter_unsigned_integral_nondivisible
{ DstChannelV operator()(SrcChannelV src) const { typedef typename unsigned_integral_max_value
::value_type integer_t; static const double div = unsigned_integral_max_value
::value / double(unsigned_integral_max_value
::value); static const integer_t div2 = integer_t(div/2); return DstChannelV((src + div2) / div); } }; } // namespace detail ///////////////////////////////////////////////////// /// bits32f conversion ///////////////////////////////////////////////////// template
struct channel_converter_unsigned
: public std::unary_function
{ DstChannelV operator()(bits32f x) const { return DstChannelV(x*channel_traits
::max_value()+0.5f); } }; template
struct channel_converter_unsigned
: public std::unary_function
{ bits32f operator()(SrcChannelV x) const { return bits32f(x/float(channel_traits
::max_value())); } }; template <> struct channel_converter_unsigned
: public std::unary_function
{ bits32f operator()(bits32f x) const { return x; } }; /// \brief 32 bit <-> float channel conversion template <> struct channel_converter_unsigned
: public std::unary_function
{ bits32f operator()(bits32 x) const { // unfortunately without an explicit check it is possible to get a round-off error. We must ensure that max_value of bits32 matches max_value of bits32f if (x>=channel_traits
::max_value()) return channel_traits
::max_value(); return float(x) / float(channel_traits
::max_value()); } }; /// \brief 32 bit <-> float channel conversion template <> struct channel_converter_unsigned
: public std::unary_function
{ bits32 operator()(bits32f x) const { // unfortunately without an explicit check it is possible to get a round-off error. We must ensure that max_value of bits32 matches max_value of bits32f if (x>=channel_traits
::max_value()) return channel_traits
::max_value(); return bits32(x * channel_traits
::max_value() + 0.5f); } }; /// @} namespace detail { // Converting from signed to unsigned integral channel. // It is both a unary function, and a metafunction (thus requires the 'type' nested typedef, which equals result_type) template
// Model ChannelValueConcept struct channel_convert_to_unsigned : public detail::identity
{ typedef ChannelValue type; }; template <> struct channel_convert_to_unsigned
: public std::unary_function
{ typedef bits8 type; type operator()(bits8s val) const { return val+128; } }; template <> struct channel_convert_to_unsigned
: public std::unary_function
{ typedef bits16 type; type operator()(bits16s val) const { return val+32768; } }; template <> struct channel_convert_to_unsigned
: public std::unary_function
{ typedef bits32 type; type operator()(bits32s x) const { return static_cast
(x+(1<<31)); } }; // Converting from unsigned to signed integral channel // It is both a unary function, and a metafunction (thus requires the 'type' nested typedef, which equals result_type) template
// Model ChannelValueConcept struct channel_convert_from_unsigned : public detail::identity
{ typedef ChannelValue type; }; template <> struct channel_convert_from_unsigned
: public std::unary_function
{ typedef bits8s type; type operator()(bits8 val) const { return val-128; } }; template <> struct channel_convert_from_unsigned
: public std::unary_function
{ typedef bits16s type; type operator()(bits16 val) const { return val-32768; } }; template <> struct channel_convert_from_unsigned
: public std::unary_function
{ typedef bits32s type; type operator()(bits32 x) const { return static_cast
(x-(1<<31)); } }; } // namespace detail /// \ingroup ChannelConvertAlgorithm /// \brief A unary function object converting between channel types template
// Model ChannelValueConcept struct channel_converter : public std::unary_function
{ DstChannelV operator()(SrcChannelV src) const { typedef detail::channel_convert_to_unsigned
to_unsigned; typedef detail::channel_convert_from_unsigned
from_unsigned; typedef channel_converter_unsigned
converter_unsigned; return from_unsigned()(converter_unsigned()(to_unsigned()(src))); } }; /// \ingroup ChannelConvertAlgorithm /// \brief Converting from one channel type to another. template
// Model ChannelConcept (could be channel references) inline typename channel_traits
::value_type channel_convert(SrcChannel src) { return channel_converter
::value_type, typename channel_traits
::value_type>()(src); } /// \ingroup ChannelConvertAlgorithm /// \brief Same as channel_converter, except it takes the destination channel by reference, which allows /// us to move the templates from the class level to the method level. This is important when invoking it /// on heterogeneous pixels. struct default_channel_converter { template
void operator()(const Ch1& src, Ch2& dst) const { dst=channel_convert
(src); } }; namespace detail { // fast integer division by 255 inline uint32_t div255(uint32_t in) { uint32_t tmp=in+128; return (tmp + (tmp>>8))>>8; } // fast integer divison by 32768 inline uint32_t div32768(uint32_t in) { return (in+16384)>>15; } } /** \defgroup ChannelMultiplyAlgorithm channel_multiply \ingroup ChannelAlgorithm \brief Multiplying unsigned channel values of the same type. Performs scaled multiplication result = a * b / max_value Example: \code bits8 x=128; bits8 y=128; bits8 mul = channel_multiply(x,y); assert(mul == 64); // 64 = 128 * 128 / 255 \endcode */ /// @{ /// \brief This is the default implementation. Performance specializatons are provided template
struct channel_multiplier_unsigned : public std::binary_function
{ ChannelValue operator()(ChannelValue a, ChannelValue b) const { return ChannelValue(a / double(channel_traits
::max_value()) * b); } }; /// \brief Specialization of channel_multiply for 8-bit unsigned channels template<> struct channel_multiplier_unsigned
: public std::binary_function
{ bits8 operator()(bits8 a, bits8 b) const { return bits8(detail::div255(uint32_t(a) * uint32_t(b))); } }; /// \brief Specialization of channel_multiply for 16-bit unsigned channels template<> struct channel_multiplier_unsigned
: public std::binary_function
{ bits16 operator()(bits16 a, bits16 b) const { return bits16((uint32_t(a) * uint32_t(b))/65535); } }; /// \brief Specialization of channel_multiply for float 0..1 channels template<> struct channel_multiplier_unsigned
: public std::binary_function
{ bits32f operator()(bits32f a, bits32f b) const { return a*b; } }; /// \brief A function object to multiply two channels. result = a * b / max_value template
struct channel_multiplier : public std::binary_function
{ ChannelValue operator()(ChannelValue a, ChannelValue b) const { typedef detail::channel_convert_to_unsigned
to_unsigned; typedef detail::channel_convert_from_unsigned
from_unsigned; typedef channel_multiplier_unsigned
multiplier_unsigned; return from_unsigned()(multiplier_unsigned()(to_unsigned()(a), to_unsigned()(b))); } }; /// \brief A function multiplying two channels. result = a * b / max_value template
// Models ChannelConcept (could be a channel reference) inline typename channel_traits
::value_type channel_multiply(Channel a, Channel b) { return channel_multiplier
::value_type>()(a,b); } /// @} /** \defgroup ChannelInvertAlgorithm channel_invert \ingroup ChannelAlgorithm \brief Returns the inverse of a channel. result = max_value - x + min_value Example: \code // bits8 == uint8_t == unsigned char bits8 x=255; bits8 inv = channel_invert(x); assert(inv == 0); \endcode */ /// \brief Default implementation. Provide overloads for performance /// \ingroup ChannelInvertAlgorithm channel_invert template
// Models ChannelConcept (could be a channel reference) inline typename channel_traits
::value_type channel_invert(Channel x) { return channel_traits
::max_value()-x + channel_traits
::min_value(); } //#ifdef _MSC_VER //#pragma warning(pop) //#endif } } // namespace boost::gil #endif
channel_algorithm.hpp
网页地址
文件地址
上一页
5/34
下一页
下载
( 21 KB )
Comments
Total ratings:
0
Average rating:
无评论
of 10
Would you like to comment?
Join now
, or
Logon
if you are already a member.