Struct Affine2x2 

pub struct Affine2x2 {
    pub xx: F2Dot14,
    pub yx: F2Dot14,
    pub xy: F2Dot14,
    pub yy: F2Dot14,
}

A simple F2Dot14 2×2 affine transformation [xx, yx; xy, yy] $\left[\begin{array}{cc}\mathrm{xx}& \mathrm{yx}\\ \mathrm{xy}& \mathrm{yy}\end{array}\right]$.

Fields

xx: F2Dot14

X-component of transformed X-basis vector.

yx: F2Dot14

Y-component of transformed X-basis vector (aka. scale01 in glyf).

xy: F2Dot14

X-component of transformed Y-basis vector (aka. scale10 in glyf).

yy: F2Dot14

Y-component of transformed Y-basis vector.

Implementations

impl Affine2x2

pub const IDENTITY: Self

The identity transform [1, 0; 0, 1] $\left[\begin{array}{cc}1& 0\\ 0& 1\end{array}\right]$.

Examples

assert_eq!(Affine2x2::IDENTITY.to_tuple_f32(), (1.0, 0.0, 0.0, 1.0));

pub const fn new(xx: F2Dot14, yx: F2Dot14, xy: F2Dot14, yy: F2Dot14) -> Self

Creates an Affine2x2 with [xx, yx; xy, yy] $\left[\begin{array}{cc}\mathrm{xx}& \mathrm{yx}\\ \mathrm{xy}& \mathrm{yy}\end{array}\right]$.

pub const fn scale(scale: F2Dot14) -> Self

Creates an Affine2x2 with [scale, 0; 0, scale] $\left[\begin{array}{cc}\mathrm{scale}& 0\\ 0& \mathrm{scale}\end{array}\right]$.

pub const fn scale_xy(x: F2Dot14, y: F2Dot14) -> Self

Creates an Affine2x2 with [x, 0; 0, y] $\left[\begin{array}{cc}x& 0\\ 0& y\end{array}\right]$.

pub fn rotation(radians: f32) -> Self

Creates an Affine2x2 with [cos(θ),-sin(θ);sin(θ),cos(θ)] $\left[\begin{array}{cc}\mathrm{cos(\theta )}& \mathrm{-sin(\theta )}\\ \mathrm{sin(\theta )}& \mathrm{cos(\theta )}\end{array}\right]$, rotating the image counter-clockwise by specified angle.

pub fn rotation_degrees(degrees: f32) -> Self

Creates an Affine2x2 with [cos(θ),-sin(θ); sin(θ),cos(θ)] $\left[\begin{array}{cc}\mathrm{cos(\theta )}& \mathrm{-sin(\theta )}\\ \mathrm{sin(\theta )}& \mathrm{cos(\theta )}\end{array}\right]$, rotating the image counter-clockwise by specified angle.

pub const fn map(&self, x: F2Dot14, y: F2Dot14) -> (F2Dot14, F2Dot14)

Applies this Affine2x2 transformation to the point [x, y] $[xy]$:

[x,y]×[xx,yx; xy,yy]=[xx*x+xy*y, yx*x+yy*y] $[xy]\times \left[\begin{array}{cc}\mathrm{xx}& \mathrm{yx}\\ \mathrm{xy}& \mathrm{yy}\end{array}\right]=[\mathrm{xx}*x+\mathrm{xy}*y,\mathrm{yx}*x+\mathrm{yy}*y]$

Examples

use ttf_view::types::Affine2x2;

assert_eq!(Affine2x2::IDENTITY.map_f32(10.0, -10.0), (10.0, -10.0));
assert_eq!(Affine2x2::IDENTITY.map_f32(-2583.2, 1842.2), (-2583.2, 1842.2));

let rot90 = Affine2x2::rotation_degrees(90.0);
assert_eq!(rot90.map_f32(23.5, 9.8), (9.8, -23.5));

pub const fn map_i16(&self, x: i16, y: i16) -> (i16, i16)

Applies this Affine2x2 transformation to the point [x, y] $[xy]$.

pub const fn map_f32(&self, x: f32, y: f32) -> (f32, f32)

Applies this Affine2x2 transformation to the point [x, y] $[xy]$.

pub const fn wrapping_mul(self, rhs: Self) -> Self

Multiplies this Affine2x2 by another, wrapping and truncating at F2Dot14’s bounds.

pub const fn saturating_mul(self, rhs: Self) -> Self

Multiplies this Affine2x2 by another, saturating at F2Dot14’s bounds.

pub const fn checked_mul(self, rhs: Self) -> Option<Self>

Multiplies this Affine2x2 by another, returning None if overflow occurs.

pub const fn from_be_bytes(bytes: [u8; 8]) -> Self

Creates an Affine2x2 from big-endian bytes.

pub const fn to_be_bytes(self) -> [u8; 8]

Returns this Affine2x2 as big-endian bytes.

pub const fn to_tuple(self) -> (F2Dot14, F2Dot14, F2Dot14, F2Dot14)

Returns this Affine2x2’s (xx, yx, xy, yy) as a tuple.

pub const fn to_tuple_f32(self) -> (f32, f32, f32, f32)

Returns this Affine2x2’s (xx, yx, xy, yy) as a tuple of f32s.

pub const fn from_array([xx, yx, xy, yy]: [F2Dot14; 4]) -> Self

Creates an Affine2x2 from a [xx, yx, xy, yy] array.

pub const fn to_array(self) -> [F2Dot14; 4]

Returns this Affine2x2’s [xx, yx, xy, yy] as an array.

Trait Implementations

impl Clone for Affine2x2

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Affine2x2

impl Debug for Affine2x2

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

Formats the value using the given formatter.

impl Default for Affine2x2

fn default() -> Self

Returns the “default value” for a type.

impl Eq for Affine2x2

impl From<BigEndian<Affine2x2>> for Affine2x2

fn from(value: BigEndian<Affine2x2>) -> Self

Converts to this type from the input type.

impl Hash for Affine2x2

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Mul for Affine2x2

Performs multiplication * (panics on overflow in debug configuration).

type Output = Affine2x2

The resulting type after applying the * operator.

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

Performs the * operation.

impl PartialEq for Affine2x2

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

Equality operator ==.

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

Inequality operator !=.

impl Primitive for Affine2x2

type BigEndian = [u8; 8]

fn from_big_endian(x: Self::BigEndian) -> Self

fn to_big_endian(x: Self) -> Self::BigEndian

impl StructuralPartialEq for Affine2x2