agg::gray16 Struct Reference

#include <src/agg/agg_color_gray.h>

Public Types
enum	base_scale_e { base_shift = 16 , base_scale = 1 << base_shift , base_mask = base_scale - 1 , base_MSB = 1 << (base_shift - 1) }
typedef int16u	value_type
typedef int32u	calc_type
typedef int64	long_type
typedef gray16	self_type

Public Member Functions
	gray16 ()
	gray16 (unsigned v_, unsigned a_=base_mask)
	gray16 (const self_type &c, unsigned a_)
	gray16 (const rgba &c)
	gray16 (const rgba8 &c)
	gray16 (const srgba8 &c)
	gray16 (const rgba16 &c)
	gray16 (const gray8 &c)
	gray16 (const sgray8 &c)
	operator rgba8 () const
	operator srgba8 () const
	operator rgba16 () const
	operator rgba32 () const
	operator gray8 () const
	operator sgray8 () 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 rgba16 &c)
static value_type	luminance (const rgba8 &c)
static value_type	luminance (const srgba8 &c)
static value_type	luminance (const rgba32 &c)
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, cover_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

Member Typedef Documentation

calc_type

typedef int32u agg::gray16::calc_type

long_type

typedef int64 agg::gray16::long_type

self_type

typedef gray16 agg::gray16::self_type

value_type

typedef int16u agg::gray16::value_type

Member Enumeration Documentation

base_scale_e

enum agg::gray16::base_scale_e

Enumerator
base_shift
base_scale
base_mask
base_MSB

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

Constructor & Destructor Documentation

gray16() [1/9]

agg::gray16::gray16 ( )

inline

{}

gray16() [2/9]

agg::gray16::gray16 ( unsigned  v_, unsigned  a_ = base_mask  )

inlineexplicit

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

gray16() [3/9]

agg::gray16::gray16 ( const self_type &  c, unsigned  a_  )

inline

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

gray16() [4/9]

agg::gray16::gray16 ( const rgba &  c )

inline

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

gray16() [5/9]

agg::gray16::gray16 ( const rgba8 &  c )

inline

                               :
            v(luminance(c)),
            a((value_type(c.a) << 8) | c.a) {}

gray16() [6/9]

agg::gray16::gray16 ( const srgba8 &  c )

inline

                                :
            v(luminance(c)),
            a((value_type(c.a) << 8) | c.a) {}

gray16() [7/9]

agg::gray16::gray16 ( const rgba16 &  c )

inline

                                :
            v(luminance(c)),
            a(c.a) {}

gray16() [8/9]

agg::gray16::gray16 ( const gray8 &  c )

inline

                               :
            v((value_type(c.v) << 8) | c.v),
            a((value_type(c.a) << 8) | c.a) {}

gray16() [9/9]

agg::gray16::gray16 ( const sgray8 &  c )

inline

                                :
            v(sRGB_conv<value_type>::rgb_from_sRGB(c.v)),
            a(sRGB_conv<value_type>::alpha_from_sRGB(c.a)) {}

Member Function Documentation

add()

AGG_INLINE void agg::gray16::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 a, base_mask, agg::cover_mask, mult_cover(), and v.

Here is the call graph for this function:

clear()

self_type & agg::gray16::clear ( )

inline

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

References a, and v.

demultiply() [1/2]

self_type & agg::gray16::demultiply ( )

inline

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

References a, base_mask, and v.

demultiply() [2/2]

static AGG_INLINE value_type agg::gray16::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 a, and base_mask.

downscale()

template<typename T >

static AGG_INLINE T agg::gray16::downscale ( T  a )

inlinestatic

        {
            return a >> base_shift;
        }

References a, and base_shift.

downshift()

template<typename T >

static AGG_INLINE T agg::gray16::downshift ( T  a, unsigned  n  )

inlinestatic

        {
            return a >> n;
        }

References a.

empty_value()

static AGG_INLINE value_type agg::gray16::empty_value ( )

inlinestatic

        {
            return 0;
        }

from_double()

static AGG_INLINE value_type agg::gray16::from_double ( double  a )

inlinestatic

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

References a, base_mask, and agg::uround().

Here is the call graph for this function:

full_value()

static AGG_INLINE value_type agg::gray16::full_value ( )

inlinestatic

        {
            return base_mask;
        }

References base_mask.

gradient()

self_type agg::gray16::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 a, base_scale, lerp(), agg::uround(), and v.

Here is the call graph for this function:

is_opaque()

AGG_INLINE bool agg::gray16::is_opaque ( ) const

inline

        {
            return a == base_mask;
        }

References a, and base_mask.

is_transparent()

AGG_INLINE bool agg::gray16::is_transparent ( ) const

inline

        {
            return a == 0;
        }

References a.

lerp()

static AGG_INLINE value_type agg::gray16::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 a, base_MSB, and base_shift.

Referenced by gradient().

Here is the caller graph for this function:

luminance() [1/5]

static value_type agg::gray16::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 base_mask, and agg::uround().

Referenced by luminance(), luminance(), and luminance().

Here is the call graph for this function:

Here is the caller graph for this function:

luminance() [2/5]

static value_type agg::gray16::luminance ( const rgba16 &  c )

inlinestatic

        {
            // Calculate grayscale value as per ITU-R BT.709.
            return value_type((13933u * c.r + 46872u * c.g + 4732u * c.b) >> 16);
        }

luminance() [3/5]

static value_type agg::gray16::luminance ( const rgba32 &  c )

inlinestatic

        {
            return luminance(rgba(c));
        }

References luminance().

Here is the call graph for this function:

luminance() [4/5]

static value_type agg::gray16::luminance ( const rgba8 &  c )

inlinestatic

        {
            return luminance(rgba16(c));
        }

References luminance().

Here is the call graph for this function:

luminance() [5/5]

static value_type agg::gray16::luminance ( const srgba8 &  c )

inlinestatic

        {
            return luminance(rgba16(c));
        }

References luminance().

Here is the call graph for this function:

mult_cover()

static AGG_INLINE value_type agg::gray16::mult_cover ( value_type  a, cover_type  b  )

inlinestatic

        {
            return multiply(a, b << 8 | b);
        }

References a, and multiply().

Referenced by add(), and scale_cover().

Here is the call graph for this function:

Here is the caller graph for this function:

multiply()

static AGG_INLINE value_type agg::gray16::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 a, base_MSB, and base_shift.

Referenced by mult_cover(), prelerp(), and premultiply().

Here is the caller graph for this function:

no_color()

static self_type agg::gray16::no_color ( )

inlinestatic

{ return self_type(0,0); }

opacity() [1/2]

double agg::gray16::opacity ( ) const

inline

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

References a, and base_mask.

opacity() [2/2]

self_type & agg::gray16::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 a, base_mask, and agg::uround().

Here is the call graph for this function:

operator gray8()

agg::gray16::operator gray8 ( ) const

inline

        {
            return gray8(v >> 8, a >> 8);
        }

References a, and v.

operator rgba16()

agg::gray16::operator rgba16 ( ) const

inline

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

References a, and v.

operator rgba32()

agg::gray16::operator rgba32 ( ) const

inline

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

References a, and v.

operator rgba8()

agg::gray16::operator rgba8 ( ) const

inline

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

References a, and v.

operator sgray8()

agg::gray16::operator sgray8 ( ) const

inline

        {
            return sgray8(
                sRGB_conv<value_type>::rgb_to_sRGB(v), 
                sRGB_conv<value_type>::alpha_to_sRGB(a));
        }

References a, and v.

operator srgba8()

agg::gray16::operator srgba8 ( ) const

inline

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

References a, and v.

prelerp()

static AGG_INLINE value_type agg::gray16::prelerp ( value_type  p, value_type  q, value_type  a  )

inlinestatic

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

References a, and multiply().

Here is the call graph for this function:

premultiply()

self_type & agg::gray16::premultiply ( )

inline

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

References a, base_mask, multiply(), and v.

Here is the call graph for this function:

scale_cover()

static AGG_INLINE cover_type agg::gray16::scale_cover ( cover_type  a, value_type  b  )

inlinestatic

        {
            return mult_cover(b, a) >> 8;
        }

References a, and mult_cover().

Here is the call graph for this function:

to_double()

static AGG_INLINE double agg::gray16::to_double ( value_type  a )

inlinestatic

        {
            return double(a) / base_mask;
        }

References a, and base_mask.

transparent()

self_type & agg::gray16::transparent ( )

inline

        {
            a = 0;
            return *this;
        }

References a.

Member Data Documentation

a

value_type agg::gray16::a

Referenced by add(), clear(), demultiply(), demultiply(), downscale(), downshift(), from_double(), gradient(), is_opaque(), is_transparent(), lerp(), mult_cover(), multiply(), opacity(), opacity(), operator gray8(), operator rgba16(), operator rgba32(), operator rgba8(), operator sgray8(), operator srgba8(), prelerp(), premultiply(), scale_cover(), to_double(), and transparent().

v

value_type agg::gray16::v

Referenced by add(), clear(), demultiply(), gradient(), operator gray8(), operator rgba16(), operator rgba32(), operator rgba8(), operator sgray8(), operator srgba8(), and premultiply().

---

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

• src/agg/agg_color_gray.h