Struct substrate::geometry::transform::Transformation

pub struct Transformation { /* private fields */ }

A transformation representing translation, rotation, and reflection of geometry.

This object does not support scaling of geometry, and as such all transformation matrices should be unitary.

Implementations

impl Transformation

pub fn identity() -> Transformation

Returns the identity transform, leaving any transformed object unmodified.

pub fn translate(x: f64, y: f64) -> Transformation

Returns a translation by (x,y).

pub fn rotate(angle: f64) -> Transformation

Returns a rotatation by angle degrees.

pub fn reflect_vert() -> Transformation

Returns a reflection about the x-axis.

pub fn builder() -> TransformationBuilder

Returns a new TransformationBuilder.

pub fn from_offset(offset: Point) -> Transformation

Creates a transform from only an offset.

The resulting transformation will apply only a translation (i.e. no rotations/reflections).

pub fn from_offset_and_orientation( offset: Point, orientation: impl Into<Orientation> ) -> Transformation

Creates a transform from an offset and Orientation.

pub fn from_opts( offset: Point, reflect_vert: bool, angle: f64 ) -> Transformation

Creates a transform from an offset, angle, and a bool indicating whether or not to reflect vertically.

pub fn cascade(parent: Transformation, child: Transformation) -> Transformation

Create a new Transformation that is the cascade of parent and child.

“Parents” and “children” refer to typical layout-instance hierarchies, in which each layer of instance has a nested set of transformations relative to its top-level parent.

Note this operation is not commutative. For example the set of transformations:

• (a) Reflect vertically, then
• (b) Translate by (1,1)
• (c) Place a point at (local coordinate) (1,1) Lands said point at (2,-2) in top-level space, whereas reversing the order of (a) and (b) lands it at (2,0).

pub fn offset_point(&self) -> Point

The point representing the translation of this transformation.

pub fn orientation(&self) -> Orientation

Returns an Orientation corresponding to this transformation.

pub fn inv(&self) -> Transformation

Returns the inverse Transformation of self.

Examples

use geometry::transform::Transformation;
use approx::assert_relative_eq;

let trans = Transformation::cascade(
    Transformation::rotate(90.),
    Transformation::translate(5., 10.),
);
let inv = trans.inv();

assert_relative_eq!(Transformation::cascade(inv, trans), Transformation::identity());

Trait Implementations

impl AbsDiffEq for Transformation

type Epsilon = f64

Used for specifying relative comparisons.

fn default_epsilon() -> <Transformation as AbsDiffEq>::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, other: &Transformation, epsilon: f64) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of [AbsDiffEq::abs_diff_eq].

impl Clone for Transformation

fn clone(&self) -> Transformation

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Transformation

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

Formats the value using the given formatter.

impl Default for Transformation

fn default() -> Transformation

Returns the “default value” for a type.

impl<T> From<T> for Transformation

where T: Into<Orientation>,

fn from(value: T) -> Transformation

Converts to this type from the input type.

impl PartialEq for Transformation

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl RelativeEq for Transformation

fn default_max_relative() -> f64

The default relative tolerance for testing values that are far-apart.

fn relative_eq( &self, other: &Transformation, epsilon: f64, max_relative: f64 ) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne( &self, other: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon ) -> bool

The inverse of [RelativeEq::relative_eq].

impl UlpsEq for Transformation

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn ulps_eq(&self, other: &Transformation, epsilon: f64, max_ulps: u32) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of [UlpsEq::ulps_eq].

impl Copy for Transformation

impl StructuralPartialEq for Transformation