cosmic::iced::daemon::program::graphics::geometry::path::lyon_path::geom::euclid

Struct Point2D

pub struct Point2D<T, U> {
    pub x: T,
    pub y: T,
    /* private fields */
}

Available on crate feature geometry only.

Expand description

A 2d Point tagged with a unit.

Fields§

§x: T§y: T

Implementations§

§

impl<T, U> Point2D<T, U>

pub fn origin() -> Point2D<T, U>
where T: Zero,

Available on crate feature canvas only.

Constructor, setting all components to zero.

pub fn zero() -> Point2D<T, U>
where T: Zero,

Available on crate feature canvas only.

The same as Point2D::origin.

pub const fn new(x: T, y: T) -> Point2D<T, U>

Available on crate feature canvas only.

Constructor taking scalar values directly.

pub fn from_lengths(x: Length<T, U>, y: Length<T, U>) -> Point2D<T, U>

Available on crate feature canvas only.

Constructor taking properly Lengths instead of scalar values.

pub fn splat(v: T) -> Point2D<T, U>
where T: Clone,

Available on crate feature canvas only.

Constructor setting all components to the same value.

pub fn from_untyped(p: Point2D<T, UnknownUnit>) -> Point2D<T, U>

Available on crate feature canvas only.

Tag a unitless value with units.

pub fn map<V, F>(self, f: F) -> Point2D<V, U>
where F: FnMut(T) -> V,

Available on crate feature canvas only.

Apply the function f to each component of this point.

§Example

This may be used to perform unusual arithmetic which is not already offered as methods.

use euclid::default::Point2D;

let p = Point2D::<u32>::new(5, 15);
assert_eq!(p.map(|coord| coord.saturating_sub(10)), Point2D::new(0, 5));

pub fn zip<V, F>(self, rhs: Point2D<T, U>, f: F) -> Vector2D<V, U>
where F: FnMut(T, T) -> V,

Available on crate feature canvas only.

Apply the function f to each pair of components of this point and rhs.

§Example

This may be used to perform unusual arithmetic which is not already offered as methods.

use euclid::{default::{Point2D, Vector2D}, point2};

let a: Point2D<u32> = point2(50, 200);
let b: Point2D<u32> = point2(100, 100);
assert_eq!(a.zip(b, u32::saturating_sub), Vector2D::new(0, 100));

§

impl<T, U> Point2D<T, U>
where T: Copy,

pub fn extend(self, z: T) -> Point3D<T, U>

Available on crate feature canvas only.

Create a 3d point from this one, using the specified z value.

pub fn to_vector(self) -> Vector2D<T, U>

Available on crate feature canvas only.

Cast this point into a vector.

Equivalent to subtracting the origin from this point.

pub fn yx(self) -> Point2D<T, U>

Available on crate feature canvas only.

Swap x and y.

§Example

enum Mm {}

let point: Point2D<_, Mm> = point2(1, -8);

assert_eq!(point.yx(), point2(-8, 1));

pub fn to_untyped(self) -> Point2D<T, UnknownUnit>

Available on crate feature canvas only.

Drop the units, preserving only the numeric value.

§Example

enum Mm {}

let point: Point2D<_, Mm> = point2(1, -8);

assert_eq!(point.x, point.to_untyped().x);
assert_eq!(point.y, point.to_untyped().y);

pub fn cast_unit<V>(self) -> Point2D<T, V>

Available on crate feature canvas only.

Cast the unit, preserving the numeric value.

§Example

enum Mm {}
enum Cm {}

let point: Point2D<_, Mm> = point2(1, -8);

assert_eq!(point.x, point.cast_unit::<Cm>().x);
assert_eq!(point.y, point.cast_unit::<Cm>().y);

pub fn to_array(self) -> [T; 2]

Available on crate feature canvas only.

Cast into an array with x and y.

§Example

enum Mm {}

let point: Point2D<_, Mm> = point2(1, -8);

assert_eq!(point.to_array(), [1, -8]);

pub fn to_tuple(self) -> (T, T)

Available on crate feature canvas only.

Cast into a tuple with x and y.

§Example

enum Mm {}

let point: Point2D<_, Mm> = point2(1, -8);

assert_eq!(point.to_tuple(), (1, -8));

pub fn to_3d(self) -> Point3D<T, U>
where T: Zero,

Available on crate feature canvas only.

Convert into a 3d point with z-coordinate equals to zero.

pub fn round(self) -> Point2D<T, U>
where T: Round,

Available on crate feature canvas only.

Rounds each component to the nearest integer value.

This behavior is preserved for negative values (unlike the basic cast).

enum Mm {}

assert_eq!(point2::<_, Mm>(-0.1, -0.8).round(), point2::<_, Mm>(0.0, -1.0))

pub fn ceil(self) -> Point2D<T, U>
where T: Ceil,

Available on crate feature canvas only.

Rounds each component to the smallest integer equal or greater than the original value.

This behavior is preserved for negative values (unlike the basic cast).

enum Mm {}

assert_eq!(point2::<_, Mm>(-0.1, -0.8).ceil(), point2::<_, Mm>(0.0, 0.0))

pub fn floor(self) -> Point2D<T, U>
where T: Floor,

Available on crate feature canvas only.

Rounds each component to the biggest integer equal or lower than the original value.

This behavior is preserved for negative values (unlike the basic cast).

enum Mm {}

assert_eq!(point2::<_, Mm>(-0.1, -0.8).floor(), point2::<_, Mm>(-1.0, -1.0))

pub fn lerp(self, other: Point2D<T, U>, t: T) -> Point2D<T, U>
where T: One + Sub<Output = T> + Mul<Output = T> + Add<Output = T>,

Available on crate feature canvas only.

Linearly interpolate between this point and another point.

§Example

use euclid::point2;
use euclid::default::Point2D;

let from: Point2D<_> = point2(0.0, 10.0);
let to:  Point2D<_> = point2(8.0, -4.0);

assert_eq!(from.lerp(to, -1.0), point2(-8.0,  24.0));
assert_eq!(from.lerp(to,  0.0), point2( 0.0,  10.0));
assert_eq!(from.lerp(to,  0.5), point2( 4.0,   3.0));
assert_eq!(from.lerp(to,  1.0), point2( 8.0,  -4.0));
assert_eq!(from.lerp(to,  2.0), point2(16.0, -18.0));

§

impl<T, U> Point2D<T, U>
where T: PartialOrd,

pub fn min(self, other: Point2D<T, U>) -> Point2D<T, U>

Available on crate feature canvas only.

pub fn max(self, other: Point2D<T, U>) -> Point2D<T, U>

Available on crate feature canvas only.

pub fn clamp(self, start: Point2D<T, U>, end: Point2D<T, U>) -> Point2D<T, U>
where T: Copy,

Available on crate feature canvas only.

Returns the point each component of which clamped by corresponding components of start and end.

Shortcut for self.max(start).min(end).

§

impl<T, U> Point2D<T, U>
where T: NumCast + Copy,

pub fn cast<NewT>(self) -> Point2D<NewT, U>
where NewT: NumCast,

Available on crate feature canvas only.

Cast from one numeric representation to another, preserving the units.

When casting from floating point to integer coordinates, the decimals are truncated as one would expect from a simple cast, but this behavior does not always make sense geometrically. Consider using round(), ceil() or floor() before casting.

pub fn try_cast<NewT>(self) -> Option<Point2D<NewT, U>>
where NewT: NumCast,

Available on crate feature canvas only.

Fallible cast from one numeric representation to another, preserving the units.

When casting from floating point to integer coordinates, the decimals are truncated as one would expect from a simple cast, but this behavior does not always make sense geometrically. Consider using round(), ceil() or floor() before casting.

pub fn to_f32(self) -> Point2D<f32, U>

Available on crate feature canvas only.

Cast into an f32 point.

pub fn to_f64(self) -> Point2D<f64, U>

Available on crate feature canvas only.

Cast into an f64 point.

pub fn to_usize(self) -> Point2D<usize, U>

Available on crate feature canvas only.

Cast into an usize point, truncating decimals if any.

When casting from floating point points, it is worth considering whether to round(), ceil() or floor() before the cast in order to obtain the desired conversion behavior.

pub fn to_u32(self) -> Point2D<u32, U>

Available on crate feature canvas only.

Cast into an u32 point, truncating decimals if any.

When casting from floating point points, it is worth considering whether to round(), ceil() or floor() before the cast in order to obtain the desired conversion behavior.

pub fn to_i32(self) -> Point2D<i32, U>

Available on crate feature canvas only.

Cast into an i32 point, truncating decimals if any.

When casting from floating point points, it is worth considering whether to round(), ceil() or floor() before the cast in order to obtain the desired conversion behavior.

pub fn to_i64(self) -> Point2D<i64, U>

Available on crate feature canvas only.

Cast into an i64 point, truncating decimals if any.

When casting from floating point points, it is worth considering whether to round(), ceil() or floor() before the cast in order to obtain the desired conversion behavior.

§

impl<T, U> Point2D<T, U>
where T: Float,

pub fn is_finite(self) -> bool

Available on crate feature canvas only.

Returns true if all members are finite.

§

impl<T, U> Point2D<T, U>
where T: Real<Output = T> + Sub,

pub fn distance_to(self, other: Point2D<T, U>) -> T

Available on crate feature canvas only.

§

impl<T, U> Point2D<T, U>
where T: Copy + Add<Output = T>,

pub fn add_size(self, other: &Size2D<T, U>) -> Point2D<T, U>

Available on crate feature canvas only.

§

impl<T, U> Point2D<T, U>
where T: Euclid,

pub fn rem_euclid(&self, other: &Size2D<T, U>) -> Point2D<T, U>

Available on crate feature canvas only.

Calculates the least nonnegative remainder of self (mod other).

§Example

use euclid::point2;
use euclid::default::{Point2D, Size2D};

let p = Point2D::new(7.0, -7.0);
let s = Size2D::new(4.0, -4.0);

assert_eq!(p.rem_euclid(&s), point2(3.0, 1.0));
assert_eq!((-p).rem_euclid(&s), point2(1.0, 3.0));
assert_eq!(p.rem_euclid(&-s), point2(3.0, 1.0));

pub fn div_euclid(&self, other: &Size2D<T, U>) -> Point2D<T, U>

Available on crate feature canvas only.

Calculates Euclidean division, the matching method for rem_euclid.

§Example

use euclid::point2;
use euclid::default::{Point2D, Size2D};

let p = Point2D::new(7.0, -7.0);
let s = Size2D::new(4.0, -4.0);

assert_eq!(p.div_euclid(&s), point2(1.0, 2.0));
assert_eq!((-p).div_euclid(&s), point2(-2.0, -1.0));
assert_eq!(p.div_euclid(&-s), point2(-1.0, -2.0));