Struct Linear 

pub struct Linear(/* private fields */);

Linear transformation: scaling and rotation

This represents scaling and rotation transformations (i.e. the linear mappings on DVec2 in the mathematical sense, excluding skew).

A Linear transform a may be applied to a vector v via multiplication: a * v. Multiple transforms can be combined: a * (b * v) == (a * b) * v.

Linear transforms are a ring algebra with commutative operations. Both addition and multiplication operations are associative and commutative, e.g. (a * b) * c == a * (b * c) and a * b == b * c. The operators are also distributive: a * (b + c) == a * b + a * c. (Subject to the limitations of floating-point numbers.)

Implementations

impl Linear

pub const IDENTITY: Linear

The multiplicitive identity

pub const ZERO: Linear

The additive identity

pub fn new(u: f64, v: f64) -> Self

Construct as a complex number

The state is treated as a complex number of the form u + v*i = a * e^{i*t} where a is the scale component and t is the angle of rotation.

pub fn scale(scale: f64) -> Self

Construct a scaling transform

pub fn rotate(radians: f64) -> Self

Construct a rotating transform

In case two vectors are available, it is preferable to use Linear::from_vectors(a, b).normalize().

To also scale, use Linear::rotate(radians) * scale.

pub fn from_vectors(a: DVec2, b: DVec2) -> Self

Construct a scaling and rotation transform taking a to b

This may be used to construct from two-finger touch motions. In this case, a = old.finger1 - old.finger2 and b = new.finger1 - new.finger2.

pub fn pan(a: DVec2, b: DVec2, (scale, rotate): (bool, bool)) -> Self

Construct from two vectors with optional scaling and rotation

This is a multiplexer over Self::from_vectors and other methods, making scaling and rotation optional (though unless both are true, the transform won’t map a to b).

pub fn get_complex(self) -> (f64, f64)

Get the internal representation

The state is treated as a complex number of the form u + v*i = a * e^{i*t} where a is the scale component and t is the angle of rotation. These components can be calculated as follows:

let (u, v) = alpha.get_complex();
let a = (u*u + v*v).sqrt();
let t = v.atan2(a);

The matrix form of this transform is:

    u  -v
    v   u

pub fn get_vec2(self) -> DVec2

Get the internal representation as a DVec2

pub fn get_scale(self) -> f64

Calculate the change in scale (non-trivial)

pub fn get_angle(self) -> f64

Calculate the rotation angle (non-trivial)

pub fn has_scale(self) -> bool

True if the transform scales its input

This is a non-trivial operation.

pub fn has_rotation(self) -> bool

True if the transform rotates its input

This is a trivial operation.

pub fn is_finite(self) -> bool

True if all components are finite

pub fn is_bijective(self) -> bool

True if the transform has an inverse

This test corresponds approximately but not exactly to self.inverse().is_finite(). Further, self.is_bijective() approximately implies self.inverse().is_bijective().

pub fn normalize(self) -> Self

Remove the scaling component

pub fn inverse(self) -> Self

Calculate the inverse

This is the reciprical: Self::IDENTITY / self. Due to the limitations of floating-point numbers, it is not guaranteed that self * self.inverse() == Self::IDENTITY in general.

Trait Implementations

impl Add for Linear

type Output = Linear

The resulting type after applying the + operator.

fn add(self, rhs: Linear) -> Linear

Performs the + operation.

impl AddAssign for Linear

fn add_assign(&mut self, rhs: Linear)

Performs the += operation.

impl Clone for Linear

fn clone(&self) -> Linear

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Linear

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

Formats the value using the given formatter.

impl Div<Affine> for Linear

type Output = Affine

The resulting type after applying the / operator.

fn div(self, rhs: Affine) -> Affine

Performs the / operation.

impl Div<Linear> for Affine

type Output = Affine

The resulting type after applying the / operator.

fn div(self, rhs: Linear) -> Affine

Performs the / operation.

impl Div<f64> for Linear

type Output = Linear

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Linear

Performs the / operation.

impl Div for Linear

type Output = Linear

The resulting type after applying the / operator.

fn div(self, rhs: Linear) -> Linear

Performs the / operation.

impl DivAssign<Linear> for Affine

fn div_assign(&mut self, rhs: Linear)

Performs the /= operation.

impl DivAssign<f64> for Linear

fn div_assign(&mut self, rhs: f64)

Performs the /= operation.

impl DivAssign for Linear

fn div_assign(&mut self, rhs: Linear)

Performs the /= operation.

impl From<Linear> for Affine

fn from(alpha: Linear) -> Self

Converts to this type from the input type.

impl Mul<Affine> for Linear

type Output = Affine

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<DVec2> for Linear

type Output = DVec2

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Linear> for Affine

type Output = Affine

The resulting type after applying the * operator.

fn mul(self, rhs: Linear) -> Affine

Performs the * operation.

impl Mul<f64> for Linear

type Output = Linear

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Linear

Performs the * operation.

impl Mul for Linear

type Output = Linear

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<Linear> for Affine

fn mul_assign(&mut self, rhs: Linear)

Performs the *= operation.

impl MulAssign<f64> for Linear

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation.

impl MulAssign for Linear

fn mul_assign(&mut self, rhs: Linear)

Performs the *= operation.

impl Neg for Linear

type Output = Linear

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl PartialEq for Linear

fn eq(&self, other: &Linear) -> 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 Sub for Linear

type Output = Linear

The resulting type after applying the - operator.

fn sub(self, rhs: Linear) -> Linear

Performs the - operation.

impl SubAssign for Linear

fn sub_assign(&mut self, rhs: Linear)

Performs the -= operation.

impl Copy for Linear

impl StructuralPartialEq for Linear