Struct TransAffine 

pub struct TransAffine {
    pub sx: f64,
    pub shy: f64,
    pub shx: f64,
    pub sy: f64,
    pub tx: f64,
    pub ty: f64,
}

2D affine transformation matrix.

Stores six components: [sx, shy, shx, sy, tx, ty] representing the matrix:

  | sx  shx tx |
  | shy  sy ty |
  |  0    0  1 |

Transform: x' = x*sx + y*shx + tx, y' = x*shy + y*sy + ty.

Port of C++ agg::trans_affine.

Fields

sx: f64

shy: f64

shx: f64

sy: f64

tx: f64

ty: f64

Implementations

impl TransAffine

pub fn new() -> TransAffine

Identity matrix.

pub fn new_custom( sx: f64, shy: f64, shx: f64, sy: f64, tx: f64, ty: f64, ) -> TransAffine

Custom matrix from six components.

pub fn from_array(m: &[f64; 6]) -> TransAffine

Construct from a [6] array: [sx, shy, shx, sy, tx, ty].

pub fn new_rotation(a: f64) -> TransAffine

Rotation matrix.

pub fn new_scaling(x: f64, y: f64) -> TransAffine

Non-uniform scaling matrix.

pub fn new_scaling_uniform(s: f64) -> TransAffine

Uniform scaling matrix.

pub fn new_translation(x: f64, y: f64) -> TransAffine

Translation matrix.

pub fn new_skewing(x: f64, y: f64) -> TransAffine

Skewing (shear) matrix.

pub fn new_line_segment( x1: f64, y1: f64, x2: f64, y2: f64, dist: f64, ) -> TransAffine

Line segment transformation: maps 0..dist to the segment (x1,y1)-(x2,y2).

pub fn new_reflection(a: f64) -> TransAffine

Reflection across a line through the origin at angle a.

pub fn new_reflection_xy(x: f64, y: f64) -> TransAffine

Reflection across a line through the origin containing the non-unit vector (x, y).

pub fn new_reflection_unit(ux: f64, uy: f64) -> TransAffine

Reflection across a line through the origin containing unit vector (ux, uy).

pub fn parl_to_parl( &mut self, src: &[f64; 6], dst: &[f64; 6], ) -> &mut TransAffine

Map one parallelogram to another.

src and dst are [x1,y1, x2,y2, x3,y3] — three corners, the fourth is implicit.

pub fn rect_to_parl( &mut self, x1: f64, y1: f64, x2: f64, y2: f64, parl: &[f64; 6], ) -> &mut TransAffine

Map a rectangle to a parallelogram.

pub fn parl_to_rect( &mut self, parl: &[f64; 6], x1: f64, y1: f64, x2: f64, y2: f64, ) -> &mut TransAffine

Map a parallelogram to a rectangle.

pub fn reset(&mut self) -> &mut TransAffine

Reset to identity.

pub fn translate(&mut self, x: f64, y: f64) -> &mut TransAffine

Translate.

pub fn rotate(&mut self, a: f64) -> &mut TransAffine

Rotate by angle a (radians).

pub fn scale(&mut self, x: f64, y: f64) -> &mut TransAffine

Non-uniform scale.

pub fn scale_uniform(&mut self, s: f64) -> &mut TransAffine

Uniform scale.

pub fn multiply(&mut self, m: &TransAffine) -> &mut TransAffine

Post-multiply: self = self * m.

pub fn premultiply(&mut self, m: &TransAffine) -> &mut TransAffine

Pre-multiply: self = m * self.

pub fn multiply_inv(&mut self, m: &TransAffine) -> &mut TransAffine

Post-multiply by inverse of m.

pub fn premultiply_inv(&mut self, m: &TransAffine) -> &mut TransAffine

Pre-multiply by inverse of m.

pub fn invert(&mut self) -> &mut TransAffine

Invert the matrix in place.

pub fn flip_x(&mut self) -> &mut TransAffine

Mirror around X axis.

pub fn flip_y(&mut self) -> &mut TransAffine

Mirror around Y axis.

pub fn store_to(&self, m: &mut [f64; 6])

Store to a [6] array.

pub fn load_from(&mut self, m: &[f64; 6]) -> &mut TransAffine

Load from a [6] array.

pub fn transform(&self, x: &mut f64, y: &mut f64)

Forward transform: (x, y) -> (x', y').

pub fn transform_2x2(&self, x: &mut f64, y: &mut f64)

Forward transform (2x2 only, no translation).

pub fn inverse_transform(&self, x: &mut f64, y: &mut f64)

Inverse transform: (x', y') -> (x, y).

pub fn determinant(&self) -> f64

Determinant of the 2x2 portion.

pub fn determinant_reciprocal(&self) -> f64

Reciprocal of the determinant.

pub fn get_scale(&self) -> f64

Average scale factor (useful for approximation_scale on curves).

Uses the same truncated 1/sqrt(2) constant as C++ AGG (0.707106781) to match its behavior exactly. Using full-precision FRAC_1_SQRT_2 would produce a slightly different result that causes the line profile width computation to take a different branch, amplifying the difference.

pub fn is_valid(&self, epsilon: f64) -> bool

Check if the matrix is non-degenerate.

pub fn is_identity(&self, epsilon: f64) -> bool

Check if this is an identity matrix.

pub fn is_equal(&self, m: &TransAffine, epsilon: f64) -> bool

Check if two matrices are equal within epsilon.

pub fn rotation(&self) -> f64

Extract the rotation angle.

pub fn translation(&self) -> (f64, f64)

Extract the translation components.

pub fn scaling(&self) -> (f64, f64)

Extract scaling by removing rotation first.

pub fn scaling_abs(&self) -> (f64, f64)

Absolute scaling (from matrix magnitudes).

Trait Implementations

impl Clone for TransAffine

fn clone(&self) -> TransAffine

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TransAffine

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for TransAffine

fn default() -> TransAffine

Returns the “default value” for a type.

impl Mul for TransAffine

type Output = TransAffine

The resulting type after applying the * operator.

fn mul(self, rhs: TransAffine) -> TransAffine

Performs the * operation.

impl MulAssign for TransAffine

fn mul_assign(&mut self, rhs: TransAffine)

Performs the *= operation.

impl PartialEq for TransAffine

fn eq(&self, other: &TransAffine) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Transformer for TransAffine

fn transform(&self, x: &mut f64, y: &mut f64)

impl Copy for TransAffine