Struct Transformation

pub struct Transformation { /* private fields */ }

A transformation representing a Manhattan translation, rotation, and/or 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: i64, y: i64) -> Transformation

Returns a translation by (x,y).

pub fn translate_ref(&self, x: i64, y: i64) -> Transformation

Translates the current transformation by (x, y), returning a new Transformation.

pub fn rotate(angle: Rotation) -> 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: Rotation, ) -> 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 geometry::transform::Rotation;

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

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

Trait Implementations

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<'de> Deserialize<'de> for Transformation

fn deserialize<__D>( __deserializer: __D, ) -> Result<Transformation, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> From<T> for Transformation

where T: Into<Orientation>,

fn from(value: T) -> Transformation

Converts to this type from the input type.

impl Hash for Transformation

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

where __H: Hasher,

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 PartialEq for Transformation

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

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Transformation

impl Eq for Transformation

impl StructuralPartialEq for Transformation