agg::rgba32 Struct Reference

#include <src/agg/agg_color_rgba.h>

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

Public Member Functions
	rgba32 ()
	rgba32 (value_type r_, value_type g_, value_type b_, value_type a_=1)
	rgba32 (const self_type &c, float a_)
	rgba32 (const rgba &c)
	rgba32 (const rgba8 &c)
	rgba32 (const srgba8 &c)
	rgba32 (const rgba16 &c)
	operator rgba () const
	operator rgba8 () const
	operator srgba8 () const
	operator rgba16 () const
AGG_INLINE bool	is_transparent () const
AGG_INLINE bool	is_opaque () const
self_type &	clear ()
self_type &	transparent ()
AGG_INLINE self_type &	opacity (double a_)
double	opacity () const
AGG_INLINE self_type &	premultiply ()
AGG_INLINE self_type &	demultiply ()
AGG_INLINE self_type	gradient (const self_type &c, double k) const
AGG_INLINE void	add (const self_type &c, unsigned cover)
template<class GammaLUT >
AGG_INLINE void	apply_gamma_dir (const GammaLUT &gamma)
template<class GammaLUT >
AGG_INLINE void	apply_gamma_inv (const GammaLUT &gamma)

Static Public Member Functions
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 ()
static self_type	from_wavelength (double wl, double gamma=1)

Public Attributes
value_type	r
value_type	g
value_type	b
value_type	a

Detailed Description

Member Typedef Documentation

calc_type

typedef double agg::rgba32::calc_type

long_type

typedef double agg::rgba32::long_type

self_type

typedef rgba32 agg::rgba32::self_type

value_type

typedef float agg::rgba32::value_type

Constructor & Destructor Documentation

rgba32() [1/7]

agg::rgba32::rgba32 ( )

inline

{}

rgba32() [2/7]

agg::rgba32::rgba32 ( value_type  r_, value_type  g_, value_type  b_, value_type  a_ = 1  )

inline

                                                                              :
            r(r_), g(g_), b(b_), a(a_) {}

rgba32() [3/7]

agg::rgba32::rgba32 ( const self_type &  c, float  a_  )

inline

                                             :
            r(c.r), g(c.g), b(c.b), a(a_) {}

rgba32() [4/7]

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

inline

                              :
            r(value_type(c.r)), g(value_type(c.g)), b(value_type(c.b)), a(value_type(c.a)) {}

rgba32() [5/7]

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

inline

                               :
            r(value_type(c.r / 255.0)), 
            g(value_type(c.g / 255.0)), 
            b(value_type(c.b / 255.0)), 
            a(value_type(c.a / 255.0)) {}

rgba32() [6/7]

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

inline

                                :
            r(sRGB_conv<value_type>::rgb_from_sRGB(c.r)), 
            g(sRGB_conv<value_type>::rgb_from_sRGB(c.g)), 
            b(sRGB_conv<value_type>::rgb_from_sRGB(c.b)), 
            a(sRGB_conv<value_type>::alpha_from_sRGB(c.a)) {}

rgba32() [7/7]

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

inline

                                :
            r(value_type(c.r / 65535.0)), 
            g(value_type(c.g / 65535.0)), 
            b(value_type(c.b / 65535.0)), 
            a(value_type(c.a / 65535.0)) {}

Member Function Documentation

add()

AGG_INLINE void agg::rgba32::add ( const self_type &  c, unsigned  cover  )

inline

        {
            if (cover == cover_mask)
            {
                if (c.is_opaque()) 
                {
                    *this = c;
                    return;
                }
                else
                {
                    r += c.r; 
                    g += c.g; 
                    b += c.b; 
                    a += c.a; 
                }
            }
            else
            {
                r += mult_cover(c.r, cover);
                g += mult_cover(c.g, cover);
                b += mult_cover(c.b, cover);
                a += mult_cover(c.a, cover);
            }
            if (a > 1) a = 1;
            if (r > a) r = a;
            if (g > a) g = a;
            if (b > a) b = a;
        }

References a, b, agg::cover_mask, g, mult_cover(), and r.

Here is the call graph for this function:

apply_gamma_dir()

template<class GammaLUT >

AGG_INLINE void agg::rgba32::apply_gamma_dir ( const GammaLUT &  gamma )

inline

        {
            r = gamma.dir(r);
            g = gamma.dir(g);
            b = gamma.dir(b);
        }

References b, g, and r.

apply_gamma_inv()

template<class GammaLUT >

AGG_INLINE void agg::rgba32::apply_gamma_inv ( const GammaLUT &  gamma )

inline

        {
            r = gamma.inv(r);
            g = gamma.inv(g);
            b = gamma.inv(b);
        }

References b, g, and r.

clear()

self_type & agg::rgba32::clear ( )

inline

        {
            r = g = b = a = 0;
      return *this;
        }

References a, b, g, and r.

demultiply() [1/2]

AGG_INLINE self_type & agg::rgba32::demultiply ( )

inline

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

References a, b, g, and r.

demultiply() [2/2]

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

inlinestatic

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

References a, and b.

downscale()

template<typename T >

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

inlinestatic

        {
            return a;
        }

References a.

downshift()

template<typename T >

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

inlinestatic

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

References a.

empty_value()

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

inlinestatic

        {
            return 0;
        }

from_double()

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

inlinestatic

        {
            return value_type(a);
        }

References a.

from_wavelength()

static self_type agg::rgba32::from_wavelength ( double  wl, double  gamma = 1  )

inlinestatic

        {
            return self_type(rgba::from_wavelength(wl, gamma));
        }

References agg::rgba::from_wavelength().

Here is the call graph for this function:

full_value()

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

inlinestatic

        {
            return 1;
        }

gradient()

AGG_INLINE self_type agg::rgba32::gradient ( const self_type &  c, double  k  ) const

inline

        {
            self_type ret;
            ret.r = value_type(r + (c.r - r) * k);
            ret.g = value_type(g + (c.g - g) * k);
            ret.b = value_type(b + (c.b - b) * k);
            ret.a = value_type(a + (c.a - a) * k);
            return ret;
        }

References a, b, g, and r.

invert()

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

inlinestatic

        {
            return 1 - x;
        }

is_opaque()

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

inline

        {
            return a >= 1;
        }

References a.

is_transparent()

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

inline

        {
            return a <= 0;
        }

References a.

lerp()

static AGG_INLINE value_type agg::rgba32::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.

mult_cover()

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

inlinestatic

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

References a, b, and agg::cover_mask.

Referenced by add().

Here is the caller graph for this function:

multiply()

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

inlinestatic

        {
            return value_type(a * b);
        }

References a, and b.

no_color()

static self_type agg::rgba32::no_color ( )

inlinestatic

{ return self_type(0,0,0,0); }

opacity() [1/2]

double agg::rgba32::opacity ( ) const

inline

        {
            return a;
        }

References a.

opacity() [2/2]

AGG_INLINE self_type & agg::rgba32::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 rgba()

agg::rgba32::operator rgba ( ) const

inline

        {
            return rgba(r, g, b, a);
        }

References a, b, g, and r.

operator rgba16()

agg::rgba32::operator rgba16 ( ) const

inline

        {
            return rgba8(
                uround(r * 65535.0), 
                uround(g * 65535.0), 
                uround(b * 65535.0), 
                uround(a * 65535.0));
        }

References a, b, g, r, and agg::uround().

Here is the call graph for this function:

operator rgba8()

agg::rgba32::operator rgba8 ( ) const

inline

        {
            return rgba8(
                uround(r * 255.0), 
                uround(g * 255.0), 
                uround(b * 255.0), 
                uround(a * 255.0));
        }

References a, b, g, r, and agg::uround().

Here is the call graph for this function:

operator srgba8()

agg::rgba32::operator srgba8 ( ) const

inline

        {
            return srgba8(
                sRGB_conv<value_type>::rgb_to_sRGB(r), 
                sRGB_conv<value_type>::rgb_to_sRGB(g), 
                sRGB_conv<value_type>::rgb_to_sRGB(b), 
                sRGB_conv<value_type>::alpha_to_sRGB(a));
        }

References a, b, g, and r.

prelerp()

static AGG_INLINE value_type agg::rgba32::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()

AGG_INLINE self_type & agg::rgba32::premultiply ( )

inline

        {
            if (a < 1)
            {
                if (a <= 0)
                {
                    r = g = b = 0;
                }
                else
                {
                    r *= a;
                    g *= a;
                    b *= a;
                }
            }
            return *this;
        }

References a, b, g, and r.

scale_cover()

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

inlinestatic

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

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

Here is the call graph for this function:

to_double()

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

inlinestatic

        {
            return a;
        }

References a.

transparent()

self_type & agg::rgba32::transparent ( )

inline

        {
            a = 0;
            return *this;
        }

References a.

Member Data Documentation

a

value_type agg::rgba32::a

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

b

value_type agg::rgba32::b

Referenced by add(), apply_gamma_dir(), apply_gamma_inv(), clear(), demultiply(), demultiply(), gradient(), mult_cover(), multiply(), operator rgba(), operator rgba16(), operator rgba8(), operator srgba8(), premultiply(), and scale_cover().

g

value_type agg::rgba32::g

Referenced by add(), apply_gamma_dir(), apply_gamma_inv(), clear(), demultiply(), gradient(), operator rgba(), operator rgba16(), operator rgba8(), operator srgba8(), and premultiply().

r

value_type agg::rgba32::r

Referenced by add(), apply_gamma_dir(), apply_gamma_inv(), clear(), demultiply(), gradient(), operator rgba(), operator rgba16(), operator rgba8(), operator srgba8(), and premultiply().

---

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

• src/agg/agg_color_rgba.h