Struct Matrix 

pub struct Matrix<P> {
    pub a: P,
    pub b: P,
    pub c: P,
    pub d: P,
    pub e: P,
    pub f: P,
}

A font matrix

⎛ a b 0 ⎞
⎜ c d 0 ⎟
⎝ e f 1 ⎠

Fields

a: P

M_1,1

b: P

M_1,2

c: P

M_2,1

d: P

M_2,2

e: P

M_3,1

f: P

M_3,2

Implementations

impl Matrix<f32>

A matrix

pub fn identity() -> Self

use pdf_create::common::Matrix;
let id = Matrix::<f32>::identity();
assert_eq!(id, id * id);

pub fn inverse_y() -> Self

use pdf_create::common::Matrix;
let id = Matrix::<f32>::identity();
let ivy = Matrix::<f32>::inverse_y();
assert_eq!(ivy, ivy * id);
assert_eq!(id, ivy * ivy);

pub fn inverse_x() -> Self

use pdf_create::common::Matrix;
let id = Matrix::<f32>::identity();
let ivx = Matrix::<f32>::inverse_x();
assert_eq!(ivx, ivx * id);
assert_eq!(id, ivx * ivx);

pub fn inverse_xy() -> Self

Inverts both coordinates

pub fn translate(x: f32, y: f32) -> Self

use pdf_create::common::Matrix;
let ty1 = Matrix::<f32>::translate(0.0, 3.0);
let ty2 = Matrix::<f32>::translate(0.0, 5.0);
let tx1 = Matrix::<f32>::translate(2.0, 0.0);
let tx2 = Matrix::<f32>::translate(7.0, 0.0);
let res = Matrix::<f32>::translate(9.0, 8.0);
assert_eq!(res, ty1 * ty2 * tx1 * tx2);
assert_eq!(res, ty1 * tx2 * ty2 * tx1);

pub fn scale(x: f32, y: f32) -> Self

Create a scaling matrix

pub fn default_glyph() -> Self

Create a default 1:1000 glyph matrix

Trait Implementations

impl<P: Clone> Clone for Matrix<P>

fn clone(&self) -> Matrix<P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: Debug> Debug for Matrix<P>

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

Formats the value using the given formatter.

impl<P> Mul for Matrix<P>

where P: Copy + Mul<Output = P> + Add<Output = P>,

type Output = Matrix<P>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<P: PartialEq> PartialEq for Matrix<P>

fn eq(&self, other: &Matrix<P>) -> 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<P: Serialize> Serialize for Matrix<P>

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

Write the object to a stream

impl<P: Copy> Copy for Matrix<P>

impl<P: Eq> Eq for Matrix<P>

impl<P> StructuralPartialEq for Matrix<P>