agg::trans_affine Struct Reference

#include <src/agg/agg_trans_affine.h>

Inheritance diagram for agg::trans_affine:

Public Member Functions
	trans_affine ()
	trans_affine (double v0, double v1, double v2, double v3, double v4, double v5)
	trans_affine (const double *m)
	trans_affine (double x1, double y1, double x2, double y2, const double *parl)
	trans_affine (const double *parl, double x1, double y1, double x2, double y2)
	trans_affine (const double *src, const double *dst)
const trans_affine &	parl_to_parl (const double *src, const double *dst)
const trans_affine &	rect_to_parl (double x1, double y1, double x2, double y2, const double *parl)
const trans_affine &	parl_to_rect (const double *parl, double x1, double y1, double x2, double y2)
const trans_affine &	reset ()
const trans_affine &	translate (double x, double y)
const trans_affine &	rotate (double a)
const trans_affine &	scale (double s)
const trans_affine &	scale (double x, double y)
const trans_affine &	multiply (const trans_affine &m)
const trans_affine &	premultiply (const trans_affine &m)
const trans_affine &	multiply_inv (const trans_affine &m)
const trans_affine &	premultiply_inv (const trans_affine &m)
const trans_affine &	invert ()
const trans_affine &	flip_x ()
const trans_affine &	flip_y ()
void	store_to (double *m) const
const trans_affine &	load_from (const double *m)
const trans_affine &	operator*= (const trans_affine &m)
const trans_affine &	operator/= (const trans_affine &m)
trans_affine	operator* (const trans_affine &m) const
trans_affine	operator/ (const trans_affine &m) const
trans_affine	operator~ () const
bool	operator== (const trans_affine &m) const
bool	operator!= (const trans_affine &m) const
void	transform (double *x, double *y) const
void	transform_2x2 (double *x, double *y) const
void	inverse_transform (double *x, double *y) const
double	determinant () const
double	determinant_reciprocal () const
double	scale () const
bool	is_valid (double epsilon=affine_epsilon) const
bool	is_identity (double epsilon=affine_epsilon) const
bool	is_equal (const trans_affine &m, double epsilon=affine_epsilon) const
double	rotation () const
void	translation (double *dx, double *dy) const
void	scaling (double *x, double *y) const
void	scaling_abs (double *x, double *y) const

Public Attributes
double	sx
double	shy
double	shx
double	sy
double	tx
double	ty

Detailed Description

Constructor & Destructor Documentation

trans_affine() [1/6]

agg::trans_affine::trans_affine ( )

inline

                       :
            sx(1.0), shy(0.0), shx(0.0), sy(1.0), tx(0.0), ty(0.0)
        {}

Referenced by operator*(), and operator/().

Here is the caller graph for this function:

trans_affine() [2/6]

agg::trans_affine::trans_affine ( double  v0, double  v1, double  v2, double  v3, double  v4, double  v5  )

inline

                                                      :
            sx(v0), shy(v1), shx(v2), sy(v3), tx(v4), ty(v5)
        {}

trans_affine() [3/6]

agg::trans_affine::trans_affine ( const double *  m )

inlineexplicit

                                               :
            sx(m[0]), shy(m[1]), shx(m[2]), sy(m[3]), tx(m[4]), ty(m[5])
        {}

trans_affine() [4/6]

agg::trans_affine::trans_affine ( double  x1, double  y1, double  x2, double  y2, const double *  parl  )

inline

        {
            rect_to_parl(x1, y1, x2, y2, parl);
        }

References rect_to_parl().

Here is the call graph for this function:

trans_affine() [5/6]

agg::trans_affine::trans_affine ( const double *  parl, double  x1, double  y1, double  x2, double  y2  )

inline

        {
            parl_to_rect(parl, x1, y1, x2, y2);
        }

References parl_to_rect().

Here is the call graph for this function:

trans_affine() [6/6]

agg::trans_affine::trans_affine ( const double *  src, const double *  dst  )

inline

        {
            parl_to_parl(src, dst);
        }

References parl_to_parl().

Here is the call graph for this function:

Member Function Documentation

determinant()

double agg::trans_affine::determinant ( ) const

inline

        {
            return sx * sy - shy * shx;
        }

References shx, shy, sx, and sy.

determinant_reciprocal()

double agg::trans_affine::determinant_reciprocal ( ) const

inline

        {
            return 1.0 / (sx * sy - shy * shx);
        }

References shx, shy, sx, and sy.

Referenced by inverse_transform().

Here is the caller graph for this function:

flip_x()

const trans_affine & agg::trans_affine::flip_x

(

)

flip_y()

const trans_affine & agg::trans_affine::flip_y

(

)

inverse_transform()

void agg::trans_affine::inverse_transform ( double *  x, double *  y  ) const

inline

    {
        double d = determinant_reciprocal();
        double a = (*x - tx) * d;
        double b = (*y - ty) * d;
        *x = a * sy - b * shx;
        *y = b * sx - a * shy;
    }

References determinant_reciprocal(), shx, shy, sx, sy, tx, and ty.

Here is the call graph for this function:

invert()

const trans_affine & agg::trans_affine::invert

(

)

Referenced by multiply_inv(), operator~(), and premultiply_inv().

Here is the caller graph for this function:

is_equal()

bool agg::trans_affine::is_equal	(	const trans_affine &	m,
		double	epsilon = affine_epsilon
	)		const

Referenced by operator!=(), and operator==().

Here is the caller graph for this function:

is_identity()

bool agg::trans_affine::is_identity

(

double

epsilon = affine_epsilon

)

const

is_valid()

bool agg::trans_affine::is_valid

(

double

epsilon = affine_epsilon

)

const

load_from()

const trans_affine & agg::trans_affine::load_from ( const double *  m )

inline

        {
            sx = *m++; shy = *m++; shx = *m++; sy = *m++; tx = *m++;  ty = *m++;
            return *this;
        }

References shx, shy, sx, sy, tx, and ty.

multiply()

const trans_affine & agg::trans_affine::multiply

(

const trans_affine &

m

)

Referenced by agg::trans_affine_line_segment::trans_affine_line_segment(), multiply_inv(), operator*=(), premultiply(), and premultiply_inv().

Here is the caller graph for this function:

multiply_inv()

const trans_affine & agg::trans_affine::multiply_inv ( const trans_affine &  m )

inline

    {
        trans_affine t = m;
        t.invert();
        return multiply(t);
    }

References invert(), and multiply().

Referenced by operator/=().

Here is the call graph for this function:

Here is the caller graph for this function:

operator!=()

bool agg::trans_affine::operator!= ( const trans_affine &  m ) const

inline

        {
            return !is_equal(m, affine_epsilon);
        }

References agg::affine_epsilon, and is_equal().

Here is the call graph for this function:

operator*()

trans_affine agg::trans_affine::operator* ( const trans_affine &  m ) const

inline

        {
            return trans_affine(*this).multiply(m);
        }

References trans_affine().

Here is the call graph for this function:

operator*=()

const trans_affine & agg::trans_affine::operator*= ( const trans_affine &  m )

inline

        {
            return multiply(m);
        }

References multiply().

Here is the call graph for this function:

operator/()

trans_affine agg::trans_affine::operator/ ( const trans_affine &  m ) const

inline

        {
            return trans_affine(*this).multiply_inv(m);
        }

References trans_affine().

Here is the call graph for this function:

operator/=()

const trans_affine & agg::trans_affine::operator/= ( const trans_affine &  m )

inline

        {
            return multiply_inv(m);
        }

References multiply_inv().

Here is the call graph for this function:

operator==()

bool agg::trans_affine::operator== ( const trans_affine &  m ) const

inline

        {
            return is_equal(m, affine_epsilon);
        }

References agg::affine_epsilon, and is_equal().

Here is the call graph for this function:

operator~()

trans_affine agg::trans_affine::operator~ ( ) const

inline

        {
            trans_affine ret = *this;
            return ret.invert();
        }

References invert().

Here is the call graph for this function:

parl_to_parl()

const trans_affine & agg::trans_affine::parl_to_parl	(	const double *	src,
		const double *	dst
	)

Referenced by trans_affine().

Here is the caller graph for this function:

parl_to_rect()

const trans_affine & agg::trans_affine::parl_to_rect	(	const double *	parl,
		double	x1,
		double	y1,
		double	x2,
		double	y2
	)

Referenced by trans_affine().

Here is the caller graph for this function:

premultiply()

const trans_affine & agg::trans_affine::premultiply ( const trans_affine &  m )

inline

    {
        trans_affine t = m;
        return *this = t.multiply(*this);
    }

References multiply().

Here is the call graph for this function:

premultiply_inv()

const trans_affine & agg::trans_affine::premultiply_inv ( const trans_affine &  m )

inline

    {
        trans_affine t = m;
        t.invert();
        return *this = t.multiply(*this);
    }

References invert(), and multiply().

Here is the call graph for this function:

rect_to_parl()

const trans_affine & agg::trans_affine::rect_to_parl	(	double	x1,
		double	y1,
		double	x2,
		double	y2,
		const double *	parl
	)

Referenced by trans_affine().

Here is the caller graph for this function:

reset()

const trans_affine & agg::trans_affine::reset

(

)

rotate()

const trans_affine & agg::trans_affine::rotate ( double  a )

inline

    {
        double ca = cos(a); 
        double sa = sin(a);
        double t0 = sx  * ca - shy * sa;
        double t2 = shx * ca - sy * sa;
        double t4 = tx  * ca - ty * sa;
        shy = sx  * sa + shy * ca;
        sy  = shx * sa + sy * ca; 
        ty  = tx  * sa + ty * ca;
        sx  = t0;
        shx = t2;
        tx  = t4;
        return *this;
    }

References cos(), shx, shy, sin(), sx, sy, tx, and ty.

Here is the call graph for this function:

rotation()

double agg::trans_affine::rotation

(

)

const

scale() [1/3]

double agg::trans_affine::scale ( ) const

inline

    {
        double x = 0.707106781 * sx  + 0.707106781 * shx;
        double y = 0.707106781 * shy + 0.707106781 * sy;
        return sqrt(x*x + y*y);
    }

References shx, shy, sqrt(), sx, and sy.

Here is the call graph for this function:

scale() [2/3]

const trans_affine & agg::trans_affine::scale ( double  s )

inline

    {
        double m = s; // Possible hint for the optimizer
        sx  *= m;
        shx *= m;
        tx  *= m;
        shy *= m;
        sy  *= m;
        ty  *= m;
        return *this;
    }

References shx, shy, sx, sy, tx, and ty.

scale() [3/3]

const trans_affine & agg::trans_affine::scale ( double  x, double  y  )

inline

    {
        double mm0 = x; // Possible hint for the optimizer
        double mm3 = y; 
        sx  *= mm0;
        shx *= mm0;
        tx  *= mm0;
        shy *= mm3;
        sy  *= mm3;
        ty  *= mm3;
        return *this;
    }

References shx, shy, sx, sy, tx, and ty.

scaling()

void agg::trans_affine::scaling	(	double *	x,
		double *	y
	)		const

scaling_abs()

void agg::trans_affine::scaling_abs ( double *  x, double *  y  ) const

inline

    {
        // Used to calculate scaling coefficients in image resampling. 
        // When there is considerable shear this method gives us much
        // better estimation than just sx, sy.
        *x = sqrt(sx  * sx  + shx * shx);
        *y = sqrt(shy * shy + sy  * sy);
    }

References shx, shy, sqrt(), sx, and sy.

Here is the call graph for this function:

store_to()

void agg::trans_affine::store_to ( double *  m ) const

inline

        {
            *m++ = sx; *m++ = shy; *m++ = shx; *m++ = sy; *m++ = tx; *m++ = ty;
        }

References shx, shy, sx, sy, tx, and ty.

transform()

void agg::trans_affine::transform ( double *  x, double *  y  ) const

inline

    {
        double tmp = *x;
        *x = tmp * sx  + *y * shx + tx;
        *y = tmp * shy + *y * sy  + ty;
    }

References shx, shy, sx, sy, tx, and ty.

transform_2x2()

void agg::trans_affine::transform_2x2 ( double *  x, double *  y  ) const

inline

    {
        double tmp = *x;
        *x = tmp * sx  + *y * shx;
        *y = tmp * shy + *y * sy;
    }

References shx, shy, sx, and sy.

translate()

const trans_affine & agg::trans_affine::translate ( double  x, double  y  )

inline

    { 
        tx += x;
        ty += y; 
        return *this;
    }

References tx, and ty.

translation()

void agg::trans_affine::translation	(	double *	dx,
		double *	dy
	)		const

Member Data Documentation

shx

double agg::trans_affine::shx

Referenced by determinant(), determinant_reciprocal(), inverse_transform(), load_from(), rotate(), scale(), scale(), scale(), scaling_abs(), store_to(), transform(), and transform_2x2().

shy

double agg::trans_affine::shy

Referenced by determinant(), determinant_reciprocal(), inverse_transform(), load_from(), rotate(), scale(), scale(), scale(), scaling_abs(), store_to(), transform(), and transform_2x2().

sx

double agg::trans_affine::sx

Referenced by determinant(), determinant_reciprocal(), inverse_transform(), load_from(), rotate(), scale(), scale(), scale(), scaling_abs(), store_to(), transform(), and transform_2x2().

sy

double agg::trans_affine::sy

Referenced by determinant(), determinant_reciprocal(), inverse_transform(), load_from(), rotate(), scale(), scale(), scale(), scaling_abs(), store_to(), transform(), and transform_2x2().

tx

double agg::trans_affine::tx

Referenced by inverse_transform(), load_from(), rotate(), scale(), scale(), store_to(), transform(), and translate().

ty

double agg::trans_affine::ty

Referenced by inverse_transform(), load_from(), rotate(), scale(), scale(), store_to(), transform(), and translate().

---

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

• src/agg/agg_trans_affine.h