Trait Skew

pub trait Skew<T: CoordNum> {
    // Required methods
    fn skew(&self, degrees: T) -> Self;
    fn skew_mut(&mut self, degrees: T);
    fn skew_xy(&self, degrees_x: T, degrees_y: T) -> Self;
    fn skew_xy_mut(&mut self, degrees_x: T, degrees_y: T);
    fn skew_around_point(
        &self,
        degrees_x: T,
        degrees_y: T,
        origin: impl Into<Coord<T>>,
    ) -> Self;
    fn skew_around_point_mut(
        &mut self,
        degrees_x: T,
        degrees_y: T,
        origin: impl Into<Coord<T>>,
    );
}

An affine transformation which skews a geometry, sheared by angles along x and y dimensions.

Performance

If you will be performing multiple transformations, like Scale, Skew, Translate, or Rotate, it is more efficient to compose the transformations and apply them as a single operation using the AffineOps trait.

Required Methods

fn skew(&self, degrees: T) -> Self

An affine transformation which skews a geometry, sheared by a uniform angle along the x and y dimensions.

Examples

use geo::Skew;
use geo::{Polygon, polygon};

let square: Polygon = polygon![
    (x: 0., y: 0.),
    (x: 10., y: 0.),
    (x: 10., y: 10.),
    (x: 0., y: 10.)
];

let skewed = square.skew(30.);

let expected_output: Polygon = polygon![
    (x: -2.89, y: -2.89),
    (x: 7.11, y: 2.89),
    (x: 12.89, y: 12.89),
    (x: 2.89, y: 7.11)
];
approx::assert_relative_eq!(skewed, expected_output, epsilon = 1e-2);

fn skew_mut(&mut self, degrees: T)

Mutable version of skew.

fn skew_xy(&self, degrees_x: T, degrees_y: T) -> Self

An affine transformation which skews a geometry, sheared by an angle along the x and y dimensions.

Examples

use geo::Skew;
use geo::{Polygon, polygon};

let square: Polygon = polygon![
    (x: 0., y: 0.),
    (x: 10., y: 0.),
    (x: 10., y: 10.),
    (x: 0., y: 10.)
];

let skewed = square.skew_xy(30., 12.);

let expected_output: Polygon = polygon![
    (x: -2.89, y: -1.06),
    (x: 7.11, y: 1.06),
    (x: 12.89, y: 11.06),
    (x: 2.89, y: 8.94)
];
approx::assert_relative_eq!(skewed, expected_output, epsilon = 1e-2);

fn skew_xy_mut(&mut self, degrees_x: T, degrees_y: T)

Mutable version of skew_xy.

fn skew_around_point( &self, degrees_x: T, degrees_y: T, origin: impl Into<Coord<T>>, ) -> Self

An affine transformation which skews a geometry around a point of origin, sheared by an angle along the x and y dimensions.

The point of origin is usually given as the 2D bounding box centre of the geometry, in which case you can just use skew or skew_xy, but this method allows you to specify any point.

Examples

use geo::Skew;
use geo::{Polygon, polygon, point};

let square: Polygon = polygon![
    (x: 0., y: 0.),
    (x: 10., y: 0.),
    (x: 10., y: 10.),
    (x: 0., y: 10.)
];

let origin = point! { x: 2., y: 2. };
let skewed = square.skew_around_point(45.0, 10.0, origin);

let expected_output: Polygon = polygon![
    (x: -2., y: -0.353),
    (x: 8., y: 1.410),
    (x: 18., y: 11.41),
    (x: 8., y: 9.647)
];
approx::assert_relative_eq!(skewed, expected_output, epsilon = 1e-2);

fn skew_around_point_mut( &mut self, degrees_x: T, degrees_y: T, origin: impl Into<Coord<T>>, )

Mutable version of skew_around_point.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<T, IR, G> Skew<T> for G

where T: CoordFloat, IR: Into<Option<Rect<T>>>, G: Clone + AffineOps<T> + BoundingRect<T, Output = IR>,