Struct Affine 

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

A 2D affine transform.

Implementations

impl Affine

pub const IDENTITY: Affine

The identity transform.

pub const FLIP_Y: Affine

A transform that is flipped on the y-axis. Useful for converting between y-up and y-down spaces.

pub const FLIP_X: Affine

A transform that is flipped on the x-axis.

pub const fn new(c: [f64; 6]) -> Affine

Construct an affine transform from coefficients.

If the coefficients are (a, b, c, d, e, f), then the resulting transformation represents this augmented matrix:

| a c e |
| b d f |
| 0 0 1 |

Note that this convention is transposed from PostScript and Direct2D, but is consistent with the Wikipedia formulation of affine transformation as augmented matrix. The idea is that (A * B) * v == A * (B * v), where * is the Mul trait.

pub const fn scale(s: f64) -> Affine

An affine transform representing uniform scaling.

pub const fn scale_non_uniform(s_x: f64, s_y: f64) -> Affine

An affine transform representing non-uniform scaling with different scale values for x and y

pub fn scale_about(s: f64, center: impl Into<Point>) -> Affine

An affine transform representing a scale of scale about center.

Useful for a view transform that zooms at a specific point, while keeping that point fixed in the result space.

See Affine::scale() for more info.

pub fn rotate(th: f64) -> Affine

An affine transform representing rotation.

The convention for rotation is that a positive angle rotates a positive X direction into positive Y. Thus, in a Y-down coordinate system (as is common for graphics), it is a clockwise rotation, and in Y-up (traditional for math), it is anti-clockwise.

The angle, th, is expressed in radians.

pub fn rotate_about(th: f64, center: impl Into<Point>) -> Affine

An affine transform representing a rotation of th radians about center.

See Affine::rotate() for more info.

pub fn translate<V>(p: V) -> Affine

where V: Into<Vec2>,

An affine transform representing translation.

pub const fn skew(skew_x: f64, skew_y: f64) -> Affine

An affine transformation representing a skew.

The skew_x and skew_y parameters represent skew factors for the horizontal and vertical directions, respectively.

This is commonly used to generate a faux oblique transform for font rendering. In this case, you can slant the glyph 20 degrees clockwise in the horizontal direction (assuming a Y-up coordinate system):

let oblique_transform = kurbo::Affine::skew(20f64.to_radians().tan(), 0.0);

pub fn reflect(point: impl Into<Point>, direction: impl Into<Vec2>) -> Affine

Create an affine transform that represents reflection about the line point + direction * t, t in (-infty, infty)

Examples

let point = Point::new(1., 0.);
let vec = Vec2::new(1., 1.);
let map = Affine::reflect(point, vec);
assert_near(map * Point::new(1., 0.), Point::new(1., 0.));
assert_near(map * Point::new(2., 1.), Point::new(2., 1.));
assert_near(map * Point::new(2., 2.), Point::new(3., 1.));

pub fn pre_rotate(self, th: f64) -> Affine

A rotation by th followed by self.

Equivalent to self * Affine::rotate(th)

pub fn pre_rotate_about(self, th: f64, center: impl Into<Point>) -> Affine

A rotation by th about center followed by self.

Equivalent to self * Affine::rotate_about(th, center)

pub fn pre_scale(self, scale: f64) -> Affine

A scale by scale followed by self.

Equivalent to self * Affine::scale(scale)

pub fn pre_scale_non_uniform(self, scale_x: f64, scale_y: f64) -> Affine

A scale by (scale_x, scale_y) followed by self.

Equivalent to self * Affine::scale_non_uniform(scale_x, scale_y)

pub fn pre_translate(self, trans: Vec2) -> Affine

A translation of trans followed by self.

Equivalent to self * Affine::translate(trans)

pub fn pre_skew(self, skew_x: f64, skew_y: f64) -> Affine

A skew of (skew_x, skew_y) followed by self.

Equivalent to self * Affine::skew(skew_x, skew_y)

pub fn pre_reflect( self, point: impl Into<Point>, direction: impl Into<Vec2>, ) -> Affine

A reflection about the line through point in direction followed by self.

Equivalent to self * Affine::reflect(point, direction)

pub fn then_rotate(self, th: f64) -> Affine

self followed by a rotation of th.

Equivalent to Affine::rotate(th) * self

pub fn then_rotate_about(self, th: f64, center: impl Into<Point>) -> Affine

self followed by a rotation of th about center.

Equivalent to Affine::rotate_about(th, center) * self

pub fn then_scale(self, scale: f64) -> Affine

self followed by a scale of scale.

Equivalent to Affine::scale(scale) * self

pub fn then_scale_non_uniform(self, scale_x: f64, scale_y: f64) -> Affine

self followed by a scale of (scale_x, scale_y).

Equivalent to Affine::scale_non_uniform(scale_x, scale_y) * self

pub fn then_scale_about(self, scale: f64, center: impl Into<Point>) -> Affine

self followed by a scale of scale about center.

Equivalent to Affine::scale_about(scale) * self

pub fn then_skew(self, skew_x: f64, skew_y: f64) -> Affine

self followed by a skew of (skew_x, skew_y).

Equivalent to Affine::skew(skew_x, skew_y) * self

pub fn then_reflect( self, point: impl Into<Point>, direction: impl Into<Vec2>, ) -> Affine

self followed by a reflection about the line through point in direction.

Equivalent to Affine::reflect(point, direction) * self

pub const fn then_translate(self, trans: Vec2) -> Affine

self followed by a translation of trans.

Equivalent to Affine::translate(trans) * self

pub const fn map_unit_square(rect: Rect) -> Affine

Creates an affine transformation that takes the unit square to the given rectangle.

Useful when you want to draw into the unit square but have your output fill any rectangle. In this case push the Affine onto the transform stack.

pub const fn as_coeffs(self) -> [f64; 6]

Get the coefficients of the transform.

pub const fn determinant(self) -> f64

Compute the determinant of this transform.

Geometric interpretation

Consider a region transformed by this affine. The transformed region’s area is the area of the original region scaled by the absolute value of the determinant. A negative determinant indicates orientation reversal.

pub const fn nuclear_norm_squared(self) -> f64

Compute the square of the nuclear norm of this transform.

This is the square of the Schatten p-norm with p=1, also known as the “trace norm.”

Returns the squared norm for efficiency; take the square root as necessary.

Geometric interpretation

Consider a unit circle transformed by this affine. The nuclear norm is the sum of the resulting ellipse’s radii (semi axes). That sum multiplied by π is a first-order approximation of the ellipse’s perimeter.

pub const fn frobenius_norm_squared(self) -> f64

Compute the square of the Frobenius norm of this transform.

This is the square of the Schatten p-norm with p=2.

Returns the squared norm for efficiency; take the square root as necessary.

Geometric interpretation

Consider a unit circle transformed by this affine. The squared Frobenius norm is twice the mean squared radius of the resulting ellipse. Alternatively, it is equal to the squared distance from the ellipse’s center to a corner of the rectangle spanned by the ellipse’s axes.

pub fn spectral_norm(self) -> f64

Compute the spectral norm of this transform.

This is the Schatten p-norm with p=∞.

Geometric interpretation

Consider a unit circle transformed by this affine. The spectral norm is the major radius (semi-major axis) of the Ellipse.

pub const fn inverse(self) -> Affine

Compute the inverse transform.

Produces NaN values when the determinant is zero.

pub fn transform_rect_bbox(self, rect: Rect) -> Rect

Compute the bounding box of a transformed rectangle.

Returns the minimal Rect that encloses the given Rect after affine transformation. If the transform is axis-aligned, then this bounding box is “tight”, in other words the returned Rect is the transformed rectangle.

The returned rectangle always has non-negative width and height.

pub const fn is_finite(&self) -> bool

Is this map finite?

pub const fn is_nan(&self) -> bool

Is this map NaN?

pub const fn translation(self) -> Vec2

Returns the translation part of this affine map ((self.0[4], self.0[5])).

pub const fn with_translation(self, trans: Vec2) -> Affine

Replaces the translation portion of this affine map

The translation can be seen as being applied after the linear part of the map.

Trait Implementations

impl Clone for Affine

fn clone(&self) -> Affine

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Affine

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

Formats the value using the given formatter.

impl Default for Affine

fn default() -> Affine

Returns the “default value” for a type.

impl From<TranslateScale> for Affine

fn from(ts: TranslateScale) -> Affine

Converts to this type from the input type.

impl Mul<&BezPath> for Affine

type Output = BezPath

The resulting type after applying the * operator.

fn mul(self, other: &BezPath) -> BezPath

Performs the * operation.

impl Mul<Arc> for Affine

type Output = Arc

The resulting type after applying the * operator.

fn mul(self, arc: Arc) -> <Affine as Mul<Arc>>::Output

Performs the * operation.

impl Mul<BezPath> for Affine

type Output = BezPath

The resulting type after applying the * operator.

fn mul(self, other: BezPath) -> BezPath

Performs the * operation.

impl Mul<Circle> for Affine

type Output = Ellipse

The resulting type after applying the * operator.

fn mul(self, other: Circle) -> <Affine as Mul<Circle>>::Output

Performs the * operation.

impl Mul<CubicBez> for Affine

type Output = CubicBez

The resulting type after applying the * operator.

fn mul(self, c: CubicBez) -> CubicBez

Performs the * operation.

impl Mul<Ellipse> for Affine

type Output = Ellipse

The resulting type after applying the * operator.

fn mul(self, other: Ellipse) -> <Affine as Mul<Ellipse>>::Output

Performs the * operation.

impl Mul<Line> for Affine

type Output = Line

The resulting type after applying the * operator.

fn mul(self, other: Line) -> Line

Performs the * operation.

impl Mul<PathEl> for Affine

type Output = PathEl

The resulting type after applying the * operator.

fn mul(self, other: PathEl) -> PathEl

Performs the * operation.

impl Mul<PathSeg> for Affine

type Output = PathSeg

The resulting type after applying the * operator.

fn mul(self, other: PathSeg) -> PathSeg

Performs the * operation.

impl Mul<Point> for Affine

type Output = Point

The resulting type after applying the * operator.

fn mul(self, other: Point) -> Point

Performs the * operation.

impl Mul<QuadBez> for Affine

type Output = QuadBez

The resulting type after applying the * operator.

fn mul(self, other: QuadBez) -> QuadBez

Performs the * operation.

impl Mul for Affine

type Output = Affine

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign for Affine

fn mul_assign(&mut self, other: Affine)

Performs the *= operation.

impl PartialEq for Affine

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

impl StructuralPartialEq for Affine