agg::gray8T< Colorspace > Struct Template Reference

#include <src/agg/agg_color_gray.h>

Public Types
enum	base_scale_e { base_shift = 8 , base_scale = 1 << base_shift , base_mask = base_scale - 1 , base_MSB = 1 << (base_shift - 1) }
typedef int8u	value_type
typedef int32u	calc_type
typedef int32	long_type
typedef gray8T	self_type

Public Member Functions
	gray8T ()
	gray8T (unsigned v_, unsigned a_=base_mask)
	gray8T (const self_type &c, unsigned a_)
	gray8T (const rgba &c)
template<class T >
	gray8T (const gray8T< T > &c)
template<class T >
	gray8T (const rgba8T< T > &c)
template<class T >
T	convert_from_sRGB () const
template<class T >
T	convert_to_sRGB () const
rgba8	make_rgba8 (const linear &) const
rgba8	make_rgba8 (const sRGB &) const
	operator rgba8 () const
srgba8	make_srgba8 (const linear &) const
srgba8	make_srgba8 (const sRGB &) const
	operator srgba8 () const
rgba16	make_rgba16 (const linear &) const
rgba16	make_rgba16 (const sRGB &) const
	operator rgba16 () const
rgba32	make_rgba32 (const linear &) const
rgba32	make_rgba32 (const sRGB &) const
	operator rgba32 () const
AGG_INLINE bool	is_transparent () const
AGG_INLINE bool	is_opaque () const
self_type &	clear ()
self_type &	transparent ()
self_type &	opacity (double a_)
double	opacity () const
self_type &	premultiply ()
self_type &	demultiply ()
self_type	gradient (self_type c, double k) const
AGG_INLINE void	add (const self_type &c, unsigned cover)

Static Public Member Functions
static value_type	luminance (const rgba &c)
static value_type	luminance (const rgba8 &c)
static void	convert (gray8T< linear > &dst, const gray8T< sRGB > &src)
static void	convert (gray8T< sRGB > &dst, const gray8T< linear > &src)
static void	convert (gray8T< linear > &dst, const rgba8 &src)
static void	convert (gray8T< linear > &dst, const srgba8 &src)
static void	convert (gray8T< sRGB > &dst, const rgba8 &src)
static void	convert (gray8T< sRGB > &dst, const srgba8 &src)
static AGG_INLINE double	to_double (value_type a)
static AGG_INLINE value_type	from_double (double a)
static AGG_INLINE value_type	empty_value ()
static AGG_INLINE value_type	full_value ()
static AGG_INLINE value_type	multiply (value_type a, value_type b)
static AGG_INLINE value_type	demultiply (value_type a, value_type b)
template<typename T >
static AGG_INLINE T	downscale (T a)
template<typename T >
static AGG_INLINE T	downshift (T a, unsigned n)
static AGG_INLINE value_type	mult_cover (value_type a, value_type b)
static AGG_INLINE cover_type	scale_cover (cover_type a, value_type b)
static AGG_INLINE value_type	prelerp (value_type p, value_type q, value_type a)
static AGG_INLINE value_type	lerp (value_type p, value_type q, value_type a)
static self_type	no_color ()

Public Attributes
value_type	v
value_type	a

Detailed Description

template<class Colorspace>
struct agg::gray8T< Colorspace >

Member Typedef Documentation

calc_type

template<class Colorspace >

typedef int32u agg::gray8T< Colorspace >::calc_type

long_type

template<class Colorspace >

typedef int32 agg::gray8T< Colorspace >::long_type

self_type

template<class Colorspace >

typedef gray8T agg::gray8T< Colorspace >::self_type

value_type

template<class Colorspace >

typedef int8u agg::gray8T< Colorspace >::value_type

Member Enumeration Documentation

base_scale_e

template<class Colorspace >

enum agg::gray8T::base_scale_e

Enumerator
base_shift
base_scale
base_mask
base_MSB

        {
            base_shift = 8,
            base_scale = 1 << base_shift,
            base_mask  = base_scale - 1,
            base_MSB = 1 << (base_shift - 1)
        };

Constructor & Destructor Documentation

gray8T() [1/6]

template<class Colorspace >

agg::gray8T< Colorspace >::gray8T ( )

inline

{}

gray8T() [2/6]

template<class Colorspace >

agg::gray8T< Colorspace >::gray8T ( unsigned  v_, unsigned  a_ = base_mask  )

inlineexplicit

                                                              :
            v(int8u(v_)), a(int8u(a_)) {}

gray8T() [3/6]

template<class Colorspace >

agg::gray8T< Colorspace >::gray8T ( const self_type &  c, unsigned  a_  )

inline

                                                :
            v(c.v), a(value_type(a_)) {}

gray8T() [4/6]

template<class Colorspace >

agg::gray8T< Colorspace >::gray8T ( const rgba &  c )

inline

                              :
            v(luminance(c)),
            a(value_type(uround(c.a * base_mask))) {}

gray8T() [5/6]

template<class Colorspace >

template<class T >

agg::gray8T< Colorspace >::gray8T ( const gray8T< T > &  c )

inline

        {
            convert(*this, c);
        }

References agg::gray8T< Colorspace >::convert().

Here is the call graph for this function:

gray8T() [6/6]

template<class Colorspace >

template<class T >

agg::gray8T< Colorspace >::gray8T ( const rgba8T< T > &  c )

inline

        {
            convert(*this, c);
        }

References agg::gray8T< Colorspace >::convert().

Here is the call graph for this function:

Member Function Documentation

add()

template<class Colorspace >

AGG_INLINE void agg::gray8T< Colorspace >::add ( const self_type &  c, unsigned  cover  )

inline

        {
            calc_type cv, ca;
            if (cover == cover_mask)
            {
                if (c.a == base_mask) 
                {
                    *this = c;
                    return;
                }
                else
                {
                    cv = v + c.v; 
                    ca = a + c.a; 
                }
            }
            else
            {
                cv = v + mult_cover(c.v, cover);
                ca = a + mult_cover(c.a, cover);
            }
            v = (value_type)((cv > calc_type(base_mask)) ? calc_type(base_mask) : cv);
            a = (value_type)((ca > calc_type(base_mask)) ? calc_type(base_mask) : ca);
        }

References agg::gray8T< Colorspace >::a, agg::gray8T< Colorspace >::base_mask, agg::cover_mask, agg::gray8T< Colorspace >::mult_cover(), and agg::gray8T< Colorspace >::v.

Here is the call graph for this function:

clear()

template<class Colorspace >

self_type & agg::gray8T< Colorspace >::clear ( )

inline

        {
            v = a = 0;
      return *this;
        }

References agg::gray8T< Colorspace >::a, and agg::gray8T< Colorspace >::v.

convert() [1/6]

template<class Colorspace >

static void agg::gray8T< Colorspace >::convert ( gray8T< linear > &  dst, const gray8T< sRGB > &  src  )

inlinestatic

        {
            dst.v = sRGB_conv<value_type>::rgb_from_sRGB(src.v);
            dst.a = src.a;
        }

References agg::gray8T< Colorspace >::a, and agg::gray8T< Colorspace >::v.

Referenced by agg::gray8T< Colorspace >::gray8T(), agg::gray8T< Colorspace >::gray8T(), agg::gray8T< Colorspace >::convert(), and agg::gray8T< Colorspace >::convert().

Here is the caller graph for this function:

convert() [2/6]

template<class Colorspace >

static void agg::gray8T< Colorspace >::convert ( gray8T< linear > &  dst, const rgba8 &  src  )

inlinestatic

        {
            dst.v = luminance(src);
            dst.a = src.a;
        }

References agg::gray8T< Colorspace >::a, agg::rgba8T< Colorspace >::a, agg::gray8T< Colorspace >::luminance(), and agg::gray8T< Colorspace >::v.

Here is the call graph for this function:

convert() [3/6]

template<class Colorspace >

static void agg::gray8T< Colorspace >::convert ( gray8T< linear > &  dst, const srgba8 &  src  )

inlinestatic

        {
            // The RGB weights are only valid for linear values.
            convert(dst, rgba8(src));
        }

References agg::gray8T< Colorspace >::convert().

Here is the call graph for this function:

convert() [4/6]

template<class Colorspace >

static void agg::gray8T< Colorspace >::convert ( gray8T< sRGB > &  dst, const gray8T< linear > &  src  )

inlinestatic

        {
            dst.v = sRGB_conv<value_type>::rgb_to_sRGB(src.v);
            dst.a = src.a;
        }

References agg::gray8T< Colorspace >::a, and agg::gray8T< Colorspace >::v.

convert() [5/6]

template<class Colorspace >

static void agg::gray8T< Colorspace >::convert ( gray8T< sRGB > &  dst, const rgba8 &  src  )

inlinestatic

        {
            dst.v = sRGB_conv<value_type>::rgb_to_sRGB(luminance(src));
            dst.a = src.a;
        }

References agg::gray8T< Colorspace >::a, agg::rgba8T< Colorspace >::a, agg::gray8T< Colorspace >::luminance(), and agg::gray8T< Colorspace >::v.

Here is the call graph for this function:

convert() [6/6]

template<class Colorspace >

static void agg::gray8T< Colorspace >::convert ( gray8T< sRGB > &  dst, const srgba8 &  src  )

inlinestatic

        {
            // The RGB weights are only valid for linear values.
            convert(dst, rgba8(src));
        }

References agg::gray8T< Colorspace >::convert().

Here is the call graph for this function:

convert_from_sRGB()

template<class Colorspace >

template<class T >

T agg::gray8T< Colorspace >::convert_from_sRGB ( ) const

inline

        {
            typename T::value_type y = sRGB_conv<typename T::value_type>::rgb_from_sRGB(v);
            return T(y, y, y, sRGB_conv<typename T::value_type>::alpha_from_sRGB(a));
        }

References agg::gray8T< Colorspace >::a, and agg::gray8T< Colorspace >::v.

convert_to_sRGB()

template<class Colorspace >

template<class T >

T agg::gray8T< Colorspace >::convert_to_sRGB ( ) const

inline

        {
            typename T::value_type y = sRGB_conv<typename T::value_type>::rgb_to_sRGB(v);
            return T(y, y, y, sRGB_conv<typename T::value_type>::alpha_to_sRGB(a));
        }

References agg::gray8T< Colorspace >::a, and agg::gray8T< Colorspace >::v.

demultiply() [1/2]

template<class Colorspace >

self_type & agg::gray8T< Colorspace >::demultiply ( )

inline

        {
            if (a < base_mask)
            {
                if (a == 0)
                {
                    v = 0;
                }
                else
                {
                    calc_type v_ = (calc_type(v) * base_mask) / a;
                    v = value_type((v_ > base_mask) ? (value_type)base_mask : v_);
                }
            }
            return *this;
        }

References agg::gray8T< Colorspace >::a, agg::gray8T< Colorspace >::base_mask, and agg::gray8T< Colorspace >::v.

demultiply() [2/2]

template<class Colorspace >

static AGG_INLINE value_type agg::gray8T< Colorspace >::demultiply ( value_type  a, value_type  b  )

inlinestatic

        {
            if (a * b == 0)
            {
                return 0;
            }
            else if (a >= b)
            {
                return base_mask;
            }
            else return value_type((a * base_mask + (b >> 1)) / b); 
        }

References agg::gray8T< Colorspace >::a, and agg::gray8T< Colorspace >::base_mask.

downscale()

template<class Colorspace >

template<typename T >

static AGG_INLINE T agg::gray8T< Colorspace >::downscale ( T  a )

inlinestatic

        {
            return a >> base_shift;
        }

References agg::gray8T< Colorspace >::a, and agg::gray8T< Colorspace >::base_shift.

downshift()

template<class Colorspace >

template<typename T >

static AGG_INLINE T agg::gray8T< Colorspace >::downshift ( T  a, unsigned  n  )

inlinestatic

        {
            return a >> n;
        }

References agg::gray8T< Colorspace >::a.

empty_value()

template<class Colorspace >

static AGG_INLINE value_type agg::gray8T< Colorspace >::empty_value ( )

inlinestatic

        {
            return 0;
        }

from_double()

template<class Colorspace >

static AGG_INLINE value_type agg::gray8T< Colorspace >::from_double ( double  a )

inlinestatic

        {
            return value_type(uround(a * base_mask));
        }

References agg::gray8T< Colorspace >::a, agg::gray8T< Colorspace >::base_mask, and agg::uround().

Here is the call graph for this function:

full_value()

template<class Colorspace >

static AGG_INLINE value_type agg::gray8T< Colorspace >::full_value ( )

inlinestatic

        {
            return base_mask;
        }

References agg::gray8T< Colorspace >::base_mask.

gradient()

template<class Colorspace >

self_type agg::gray8T< Colorspace >::gradient ( self_type  c, double  k  ) const

inline

        {
            self_type ret;
            calc_type ik = uround(k * base_scale);
            ret.v = lerp(v, c.v, ik);
            ret.a = lerp(a, c.a, ik);
            return ret;
        }

References agg::gray8T< Colorspace >::a, agg::gray8T< Colorspace >::base_scale, agg::gray8T< Colorspace >::lerp(), agg::uround(), and agg::gray8T< Colorspace >::v.

Here is the call graph for this function:

is_opaque()

template<class Colorspace >

AGG_INLINE bool agg::gray8T< Colorspace >::is_opaque ( ) const

inline

        {
            return a == base_mask;
        }

References agg::gray8T< Colorspace >::a, and agg::gray8T< Colorspace >::base_mask.

is_transparent()

template<class Colorspace >

AGG_INLINE bool agg::gray8T< Colorspace >::is_transparent ( ) const

inline

        {
            return a == 0;
        }

References agg::gray8T< Colorspace >::a.

lerp()

template<class Colorspace >

static AGG_INLINE value_type agg::gray8T< Colorspace >::lerp ( value_type  p, value_type  q, value_type  a  )

inlinestatic

        {
            int t = (q - p) * a + base_MSB - (p > q);
            return value_type(p + (((t >> base_shift) + t) >> base_shift));
        }

References agg::gray8T< Colorspace >::a, agg::gray8T< Colorspace >::base_MSB, and agg::gray8T< Colorspace >::base_shift.

Referenced by agg::gray8T< Colorspace >::gradient().

Here is the caller graph for this function:

luminance() [1/2]

template<class Colorspace >

static value_type agg::gray8T< Colorspace >::luminance ( const rgba &  c )

inlinestatic

        {
            // Calculate grayscale value as per ITU-R BT.709.
            return value_type(uround((0.2126 * c.r + 0.7152 * c.g + 0.0722 * c.b) * base_mask));
        }

References agg::gray8T< Colorspace >::base_mask, and agg::uround().

Referenced by agg::gray8T< Colorspace >::convert(), and agg::gray8T< Colorspace >::convert().

Here is the call graph for this function:

Here is the caller graph for this function:

luminance() [2/2]

template<class Colorspace >

static value_type agg::gray8T< Colorspace >::luminance ( const rgba8 &  c )

inlinestatic

        {
            // Calculate grayscale value as per ITU-R BT.709.
            return value_type((55u * c.r + 184u * c.g + 18u * c.b) >> 8);
        }

make_rgba16() [1/2]

template<class Colorspace >

rgba16 agg::gray8T< Colorspace >::make_rgba16 ( const linear &  ) const

inline

        {
            rgba16::value_type rgb = (v << 8) | v;
            return rgba16(rgb, rgb, rgb, (a << 8) | a);
        }

References agg::gray8T< Colorspace >::a, and agg::gray8T< Colorspace >::v.

Referenced by agg::gray8T< Colorspace >::operator rgba16().

Here is the caller graph for this function:

make_rgba16() [2/2]

template<class Colorspace >

rgba16 agg::gray8T< Colorspace >::make_rgba16 ( const sRGB &  ) const

inline

        {
            return convert_from_sRGB<rgba16>();
        }

make_rgba32() [1/2]

template<class Colorspace >

rgba32 agg::gray8T< Colorspace >::make_rgba32 ( const linear &  ) const

inline

        {
            rgba32::value_type v32 = v / 255.0f;
            return rgba32(v32, v32, v32, a / 255.0f);
        }

References agg::gray8T< Colorspace >::a, and agg::gray8T< Colorspace >::v.

Referenced by agg::gray8T< Colorspace >::operator rgba32().

Here is the caller graph for this function:

make_rgba32() [2/2]

template<class Colorspace >

rgba32 agg::gray8T< Colorspace >::make_rgba32 ( const sRGB &  ) const

inline

        {
            return convert_from_sRGB<rgba32>();
        }

make_rgba8() [1/2]

template<class Colorspace >

rgba8 agg::gray8T< Colorspace >::make_rgba8 ( const linear &  ) const

inline

        {
            return rgba8(v, v, v, a);
        }

References agg::gray8T< Colorspace >::a, and agg::gray8T< Colorspace >::v.

Referenced by agg::gray8T< Colorspace >::operator rgba8(), and agg::gray8T< Colorspace >::operator srgba8().

Here is the caller graph for this function:

make_rgba8() [2/2]

template<class Colorspace >

rgba8 agg::gray8T< Colorspace >::make_rgba8 ( const sRGB &  ) const

inline

        {
            return convert_from_sRGB<srgba8>();
        }

make_srgba8() [1/2]

template<class Colorspace >

srgba8 agg::gray8T< Colorspace >::make_srgba8 ( const linear &  ) const

inline

        {
            return convert_to_sRGB<rgba8>();
        }

make_srgba8() [2/2]

template<class Colorspace >

srgba8 agg::gray8T< Colorspace >::make_srgba8 ( const sRGB &  ) const

inline

        {
            return srgba8(v, v, v, a);
        }

References agg::gray8T< Colorspace >::a, and agg::gray8T< Colorspace >::v.

mult_cover()

template<class Colorspace >

static AGG_INLINE value_type agg::gray8T< Colorspace >::mult_cover ( value_type  a, value_type  b  )

inlinestatic

        {
            return multiply(a, b);
        }

References agg::gray8T< Colorspace >::a, and agg::gray8T< Colorspace >::multiply().

Referenced by agg::gray8T< Colorspace >::add().

Here is the call graph for this function:

Here is the caller graph for this function:

multiply()

template<class Colorspace >

static AGG_INLINE value_type agg::gray8T< Colorspace >::multiply ( value_type  a, value_type  b  )

inlinestatic

        {
            calc_type t = a * b + base_MSB;
            return value_type(((t >> base_shift) + t) >> base_shift);
        }

References agg::gray8T< Colorspace >::a, agg::gray8T< Colorspace >::base_MSB, and agg::gray8T< Colorspace >::base_shift.

Referenced by agg::gray8T< Colorspace >::mult_cover(), agg::gray8T< Colorspace >::prelerp(), agg::gray8T< Colorspace >::premultiply(), and agg::gray8T< Colorspace >::scale_cover().

Here is the caller graph for this function:

no_color()

template<class Colorspace >

static self_type agg::gray8T< Colorspace >::no_color ( )

inlinestatic

{ return self_type(0,0); }

opacity() [1/2]

template<class Colorspace >

double agg::gray8T< Colorspace >::opacity ( ) const

inline

        {
            return double(a) / double(base_mask);
        }

References agg::gray8T< Colorspace >::a, and agg::gray8T< Colorspace >::base_mask.

opacity() [2/2]

template<class Colorspace >

self_type & agg::gray8T< Colorspace >::opacity ( double  a_ )

inline

        {
            if (a_ < 0) a = 0;
            else if (a_ > 1) a = 1;
            else a = (value_type)uround(a_ * double(base_mask));
      return *this;
        }

References agg::gray8T< Colorspace >::a, agg::gray8T< Colorspace >::base_mask, and agg::uround().

Here is the call graph for this function:

operator rgba16()

template<class Colorspace >

agg::gray8T< Colorspace >::operator rgba16 ( ) const

inline

        {
            return make_rgba16(Colorspace());
        }

References agg::gray8T< Colorspace >::make_rgba16().

Here is the call graph for this function:

operator rgba32()

template<class Colorspace >

agg::gray8T< Colorspace >::operator rgba32 ( ) const

inline

        {
            return make_rgba32(Colorspace());
        }

References agg::gray8T< Colorspace >::make_rgba32().

Here is the call graph for this function:

operator rgba8()

template<class Colorspace >

agg::gray8T< Colorspace >::operator rgba8 ( ) const

inline

        {
            return make_rgba8(Colorspace());
        }

References agg::gray8T< Colorspace >::make_rgba8().

Here is the call graph for this function:

operator srgba8()

template<class Colorspace >

agg::gray8T< Colorspace >::operator srgba8 ( ) const

inline

        {
            return make_rgba8(Colorspace());
        }

References agg::gray8T< Colorspace >::make_rgba8().

Here is the call graph for this function:

prelerp()

template<class Colorspace >

static AGG_INLINE value_type agg::gray8T< Colorspace >::prelerp ( value_type  p, value_type  q, value_type  a  )

inlinestatic

        {
            return p + q - multiply(p, a);
        }

References agg::gray8T< Colorspace >::a, and agg::gray8T< Colorspace >::multiply().

Here is the call graph for this function:

premultiply()

template<class Colorspace >

self_type & agg::gray8T< Colorspace >::premultiply ( )

inline

        {
            if (a < base_mask)
            {
                if (a == 0) v = 0;
                else v = multiply(v, a);
            }
            return *this;
        }

References agg::gray8T< Colorspace >::a, agg::gray8T< Colorspace >::base_mask, agg::gray8T< Colorspace >::multiply(), and agg::gray8T< Colorspace >::v.

Here is the call graph for this function:

scale_cover()

template<class Colorspace >

static AGG_INLINE cover_type agg::gray8T< Colorspace >::scale_cover ( cover_type  a, value_type  b  )

inlinestatic

        {
            return multiply(b, a);
        }

References agg::gray8T< Colorspace >::a, and agg::gray8T< Colorspace >::multiply().

Here is the call graph for this function:

to_double()

template<class Colorspace >

static AGG_INLINE double agg::gray8T< Colorspace >::to_double ( value_type  a )

inlinestatic

        {
            return double(a) / base_mask;
        }

References agg::gray8T< Colorspace >::a, and agg::gray8T< Colorspace >::base_mask.

transparent()

template<class Colorspace >

self_type & agg::gray8T< Colorspace >::transparent ( )

inline

        {
            a = 0;
            return *this;
        }

References agg::gray8T< Colorspace >::a.

Member Data Documentation

a

template<class Colorspace >

value_type agg::gray8T< Colorspace >::a

Referenced by agg::gray8T< Colorspace >::add(), agg::gray8T< Colorspace >::clear(), agg::gray8T< Colorspace >::convert(), agg::gray8T< Colorspace >::convert(), agg::gray8T< Colorspace >::convert(), agg::gray8T< Colorspace >::convert(), agg::gray8T< Colorspace >::convert_from_sRGB(), agg::gray8T< Colorspace >::convert_to_sRGB(), agg::gray8T< Colorspace >::demultiply(), agg::gray8T< Colorspace >::demultiply(), agg::gray8T< Colorspace >::downscale(), agg::gray8T< Colorspace >::downshift(), agg::gray8T< Colorspace >::from_double(), agg::gray8T< Colorspace >::gradient(), agg::gray8T< Colorspace >::is_opaque(), agg::gray8T< Colorspace >::is_transparent(), agg::gray8T< Colorspace >::lerp(), agg::gray8T< Colorspace >::make_rgba16(), agg::gray8T< Colorspace >::make_rgba32(), agg::gray8T< Colorspace >::make_rgba8(), agg::gray8T< Colorspace >::make_srgba8(), agg::gray8T< Colorspace >::mult_cover(), agg::gray8T< Colorspace >::multiply(), agg::gray8T< Colorspace >::opacity(), agg::gray8T< Colorspace >::opacity(), agg::gray8T< Colorspace >::prelerp(), agg::gray8T< Colorspace >::premultiply(), agg::gray8T< Colorspace >::scale_cover(), agg::gray8T< Colorspace >::to_double(), and agg::gray8T< Colorspace >::transparent().

v

template<class Colorspace >

value_type agg::gray8T< Colorspace >::v

Referenced by agg::gray8T< Colorspace >::add(), agg::gray8T< Colorspace >::clear(), agg::gray8T< Colorspace >::convert(), agg::gray8T< Colorspace >::convert(), agg::gray8T< Colorspace >::convert(), agg::gray8T< Colorspace >::convert(), agg::gray8T< Colorspace >::convert_from_sRGB(), agg::gray8T< Colorspace >::convert_to_sRGB(), agg::gray8T< Colorspace >::demultiply(), agg::gray8T< Colorspace >::gradient(), agg::gray8T< Colorspace >::make_rgba16(), agg::gray8T< Colorspace >::make_rgba32(), agg::gray8T< Colorspace >::make_rgba8(), agg::gray8T< Colorspace >::make_srgba8(), and agg::gray8T< Colorspace >::premultiply().

---

The documentation for this struct was generated from the following file:

• src/agg/agg_color_gray.h