agg::gray32 Struct Reference

#include <src/agg/agg_color_gray.h>

Public Types
typedef float	value_type
typedef double	calc_type
typedef double	long_type
typedef gray32	self_type

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

Static Public Member Functions
static value_type	luminance (double r, double g, double b)
static value_type	luminance (const rgba &c)
static value_type	luminance (const rgba32 &c)
static value_type	luminance (const rgba8 &c)
static value_type	luminance (const rgba16 &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	invert (value_type x)
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 double agg::gray32::calc_type

long_type

typedef double agg::gray32::long_type

self_type

typedef gray32 agg::gray32::self_type

value_type

typedef float agg::gray32::value_type

Constructor & Destructor Documentation

gray32() [1/11]

agg::gray32::gray32 ( )

inline

{}

gray32() [2/11]

agg::gray32::gray32 ( value_type  v_, value_type  a_ = 1  )

inlineexplicit

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

gray32() [3/11]

agg::gray32::gray32 ( const self_type &  c, value_type  a_  )

inline

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

gray32() [4/11]

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

inline

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

gray32() [5/11]

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

inline

                               :
            v(luminance(c)),
            a(value_type(c.a / 255.0)) {}

gray32() [6/11]

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

inline

                                :
            v(luminance(rgba32(c))),
            a(value_type(c.a / 255.0)) {}

gray32() [7/11]

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

inline

                                :
            v(luminance(c)),
            a(value_type(c.a / 65535.0)) {}

gray32() [8/11]

agg::gray32::gray32 ( const rgba32 &  c )

inline

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

gray32() [9/11]

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

inline

                               :
            v(value_type(c.v / 255.0)), 
            a(value_type(c.a / 255.0)) {}

gray32() [10/11]

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

inline

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

gray32() [11/11]

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

inline

                                :
            v(value_type(c.v / 65535.0)), 
            a(value_type(c.a / 65535.0)) {}

Member Function Documentation

clear()

self_type & agg::gray32::clear ( )

inline

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

References a, and v.

demultiply() [1/2]

self_type & agg::gray32::demultiply ( )

inline

        {
            if (a < 0) v = 0;
            else if (a < 1) v /= a;
            return *this;
        }

References a, and v.

demultiply() [2/2]

static AGG_INLINE value_type agg::gray32::demultiply ( value_type  a, value_type  b  )

inlinestatic

        {
            return (b == 0) ? 0 : value_type(a / b);
        }

References a.

downscale()

template<typename T >

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

inlinestatic

        {
            return a;
        }

References a.

downshift()

template<typename T >

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

inlinestatic

        {
            return n > 0 ? a / (1 << n) : a;
        }

References a.

empty_value()

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

inlinestatic

        {
            return 0;
        }

from_double()

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

inlinestatic

        {
            return value_type(a);
        }

References a.

full_value()

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

inlinestatic

        {
            return 1;
        }

gradient()

self_type agg::gray32::gradient ( self_type  c, double  k  ) const

inline

        {
            return self_type(
                value_type(v + (c.v - v) * k), 
                value_type(a + (c.a - a) * k));
        }

References a, and v.

invert()

static AGG_INLINE value_type agg::gray32::invert ( value_type  x )

inlinestatic

        {
            return 1 - x;
        }

is_opaque()

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

inline

        {
            return a >= 1;
        }

References a.

is_transparent()

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

inline

        {
            return a <= 0;
        }

References a.

lerp()

static AGG_INLINE value_type agg::gray32::lerp ( value_type  p, value_type  q, value_type  a  )

inlinestatic

        {
      // The form "p + a * (q - p)" avoids a multiplication, but may produce an 
      // inaccurate result. For example, "p + (q - p)" may not be exactly equal 
      // to q. Therefore, stick to the basic expression, which at least produces 
      // the correct result at either extreme.
      return (1 - a) * p + a * q;
        }

References a.

luminance() [1/5]

static value_type agg::gray32::luminance ( const rgba &  c )

inlinestatic

        {
            return luminance(c.r, c.g, c.b);
        }

References luminance().

Here is the call graph for this function:

luminance() [2/5]

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

inlinestatic

        {
            return luminance(c.r / 65535.0, c.g / 65535.0, c.g / 65535.0);
        }

References luminance().

Here is the call graph for this function:

luminance() [3/5]

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

inlinestatic

        {
            return luminance(c.r, c.g, c.b);
        }

References luminance().

Here is the call graph for this function:

luminance() [4/5]

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

inlinestatic

        {
            return luminance(c.r / 255.0, c.g / 255.0, c.g / 255.0);
        }

References luminance().

Here is the call graph for this function:

luminance() [5/5]

static value_type agg::gray32::luminance ( double  r, double  g, double  b  )

inlinestatic

        {
            return value_type(0.2126 * r + 0.7152 * g + 0.0722 * b);
        }

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

Here is the caller graph for this function:

mult_cover()

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

inlinestatic

        {
            return value_type(a * b / cover_mask);
        }

References a, and agg::cover_mask.

multiply()

static AGG_INLINE value_type agg::gray32::multiply ( value_type  a, value_type  b  )

inlinestatic

        {
            return value_type(a * b);
        }

References a.

no_color()

static self_type agg::gray32::no_color ( )

inlinestatic

{ return self_type(0,0); }

opacity() [1/2]

double agg::gray32::opacity ( ) const

inline

        {
            return a;
        }

References a.

opacity() [2/2]

self_type & agg::gray32::opacity ( double  a_ )

inline

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

References a.

operator gray16()

agg::gray32::operator gray16 ( ) const

inline

        {
            return gray16(uround(v * 65535.0), uround(a * 65535.0));
        }

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

Here is the call graph for this function:

operator gray8()

agg::gray32::operator gray8 ( ) const

inline

        {
            return gray8(uround(v * 255.0), uround(a * 255.0));
        }

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

Here is the call graph for this function:

operator rgba()

agg::gray32::operator rgba ( ) const

inline

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

References a, and v.

operator rgba16()

agg::gray32::operator rgba16 ( ) const

inline

    {
      rgba16::value_type y = uround(v * 65535.0);
      return rgba16(y, y, y, uround(a * 65535.0));
    }

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

Here is the call graph for this function:

operator rgba32()

agg::gray32::operator rgba32 ( ) const

inline

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

References a, and v.

operator rgba8()

agg::gray32::operator rgba8 ( ) const

inline

        {
            rgba8::value_type y = uround(v * 255.0);
            return rgba8(y, y, y, uround(a * 255.0));
        }

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

Here is the call graph for this function:

operator sgray8()

agg::gray32::operator sgray8 ( ) const

inline

        {
            // Return (non-premultiplied) sRGB values.
            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::gray32::operator srgba8 ( ) const

inline

        {
            srgba8::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::gray32::prelerp ( value_type  p, value_type  q, value_type  a  )

inlinestatic

        {
            return (1 - a) * p + q; // more accurate than "p + q - p * a"
        }

References a.

premultiply()

self_type & agg::gray32::premultiply ( )

inline

        {
            if (a < 0) v = 0;
            else if(a < 1) v *= a;
            return *this;
        }

References a, and v.

scale_cover()

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

inlinestatic

        {
            return cover_type(uround(a * b));
        }

References a, and agg::uround().

Here is the call graph for this function:

to_double()

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

inlinestatic

        {
            return a;
        }

References a.

transparent()

self_type & agg::gray32::transparent ( )

inline

        {
            a = 0;
            return *this;
        }

References a.

Member Data Documentation

a

value_type agg::gray32::a

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

v

value_type agg::gray32::v

Referenced by clear(), demultiply(), gradient(), operator gray16(), operator gray8(), operator rgba(), 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