Struct Affine

source

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

Expand description

A 2D affine transform.

Implementations§

source §

impl Affine

source

pub const IDENTITY: Affine = _

The identity transform.

source

pub const FLIP_Y: Affine = _

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

source

pub const FLIP_X: Affine = _

A transform that is flipped on the x-axis.

source

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.

source

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

An affine transform representing uniform scaling.

source

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

source

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.

source

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

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

See Affine::rotate() for more info.

source

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

An affine transform representing translation.

source

pub 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);

source

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

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.));

source

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

A rotation by th followed by self.

Equivalent to self * Affine::rotate(th)

source

pub fn pre_rotate_about(self, th: f64, center: Point) -> Self

A rotation by th about center followed by self.

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

source

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

A scale by scale followed by self.

Equivalent to self * Affine::scale(scale)

source

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

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

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

source

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

A translation of trans followed by self.

Equivalent to self * Affine::translate(trans)

source

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

self followed by a rotation of th.

Equivalent to Affine::rotate(th) * self

source

pub fn then_rotate_about(self, th: f64, center: Point) -> Self

self followed by a rotation of th about center.

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

source

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

self followed by a scale of scale.

Equivalent to Affine::scale(scale) * self

source

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

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

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

source

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

self followed by a translation of trans.

Equivalent to Affine::translate(trans) * self

source

pub 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.

source

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

Get the coefficients of the transform.

source

pub fn determinant(self) -> f64

Compute the determinant of this transform.

source

pub fn inverse(self) -> Affine

Compute the inverse transform.

Produces NaN values when the determinant is zero.

source

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.

source