Struct TransPerspective 

pub struct TransPerspective {
    pub sx: f64,
    pub shy: f64,
    pub w0: f64,
    pub shx: f64,
    pub sy: f64,
    pub w1: f64,
    pub tx: f64,
    pub ty: f64,
    pub w2: f64,
}

Perspective 2D transformation (3×3 projective matrix).

| sx  shy  w0 |
| shx  sy  w1 |
| tx   ty  w2 |

Transform: m = 1/(x*w0 + y*w1 + w2), then x' = m*(x*sx + y*shx + tx), y' = m*(x*shy + y*sy + ty).

Port of C++ trans_perspective.

Fields

sx: f64

shy: f64

w0: f64

shx: f64

sy: f64

w1: f64

tx: f64

ty: f64

w2: f64

Implementations

impl TransPerspective

pub fn new() -> Self

Identity matrix.

pub fn new_from_values( v0: f64, v1: f64, v2: f64, v3: f64, v4: f64, v5: f64, v6: f64, v7: f64, v8: f64, ) -> Self

Custom matrix from 9 values.

pub fn new_from_array(m: &[f64; 9]) -> Self

Custom matrix from array of 9 doubles.

pub fn new_from_affine(a: &TransAffine) -> Self

From an affine transformation (w0=0, w1=0, w2=1).

pub fn square_to_quad(&mut self, q: &[f64; 8]) -> bool

Map unit square (0,0,1,1) to the quadrilateral.

pub fn quad_to_square(&mut self, q: &[f64; 8]) -> bool

Map the quadrilateral to unit square (inverse of square_to_quad).

pub fn quad_to_quad(&mut self, qs: &[f64; 8], qd: &[f64; 8]) -> bool

Map quadrilateral src to quadrilateral dst.

pub fn rect_to_quad( &mut self, x1: f64, y1: f64, x2: f64, y2: f64, q: &[f64; 8], ) -> bool

Rectangle → quadrilateral.

pub fn quad_to_rect( &mut self, q: &[f64; 8], x1: f64, y1: f64, x2: f64, y2: f64, ) -> bool

Quadrilateral → rectangle.

pub fn reset(&mut self)

Reset to identity matrix.

pub fn invert(&mut self) -> bool

Invert the matrix. Returns false if degenerate.

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

Translate the matrix.

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

Rotate the matrix.

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

Scale uniformly.

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

Scale non-uniformly.

pub fn multiply(&mut self, a: &TransPerspective)

Multiply by another perspective matrix: self = a * self.

pub fn premultiply(&mut self, b: &TransPerspective)

Premultiply: self = self * b.

pub fn multiply_affine(&mut self, a: &TransAffine)

Multiply by an affine matrix: self = a * self.

pub fn premultiply_affine(&mut self, b: &TransAffine)

Premultiply by an affine matrix: self = self * b.

pub fn multiply_inv(&mut self, m: &TransPerspective)

Multiply by inverse of another perspective matrix.

pub fn premultiply_inv(&mut self, m: &TransPerspective)

Premultiply by inverse of another perspective matrix.

pub fn multiply_inv_affine(&mut self, m: &TransAffine)

Multiply by inverse of an affine matrix.

pub fn premultiply_inv_affine(&mut self, m: &TransAffine)

Premultiply by inverse of an affine matrix.

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

Direct transformation of x and y with perspective divide.

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

Direct transformation, affine part only (no perspective divide).

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

Direct transformation, 2×2 matrix only (no translation).

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

Inverse transformation (slow — inverts on every call).

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

Store matrix to array of 9 doubles.

pub fn load_from(&mut self, m: &[f64; 9])

Load matrix from array of 9 doubles.

pub fn from_affine(&mut self, a: &TransAffine)

Load from an affine transformation.

pub fn determinant(&self) -> f64

Determinant of the 3×3 matrix.

pub fn determinant_reciprocal(&self) -> f64

Reciprocal of determinant.

pub fn is_valid(&self) -> bool

Check if matrix is valid (non-degenerate).

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

Check if matrix is valid with custom epsilon.

pub fn is_identity(&self) -> bool

Check if matrix is identity.

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

Check if matrix is identity with custom epsilon.

pub fn is_equal(&self, m: &TransPerspective) -> bool

Check equality with another matrix.

pub fn is_equal_eps(&self, m: &TransPerspective, epsilon: f64) -> bool

Check equality with custom epsilon.

pub fn scale(&self) -> f64

Determine overall scale factor.

pub fn rotation(&self) -> f64

Determine rotation angle.

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

Get translation components.

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

Determine scaling components.

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

Absolute scaling components.

pub fn begin(&self, x: f64, y: f64, step: f64) -> PerspectiveIteratorX

Create an incremental scanline iterator.

Trait Implementations

impl Clone for TransPerspective

fn clone(&self) -> TransPerspective

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for TransPerspective

fn default() -> Self

Returns the “default value” for a type.

impl Transformer for TransPerspective

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

impl Copy for TransPerspective