# Struct euclid::Point2D

``````#[repr(C)]pub struct Point2D<T, U> {
pub x: T,
pub y: T,
/* private fields */
}``````
Expand description

A 2d Point tagged with a unit.

## Fields§

§`x: T`§`y: T`

## Implementations§

source§

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

source

#### pub fn origin() -> Selfwhere T: Zero,

Constructor, setting all components to zero.

source

source

#### pub const fn new(x: T, y: T) -> Self

Constructor taking scalar values directly.

source

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

Constructor taking properly Lengths instead of scalar values.

source

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

Tag a unitless value with units.

source§

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

source

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

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

source

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

Cast this point into a vector.

Equivalent to subtracting the origin from this point.

source

#### pub fn yx(self) -> Self

Swap x and y.

##### §Example
``````enum Mm {}

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

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

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

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);``````
source

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

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);``````
source

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

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]);``````
source

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

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));``````
source

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

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

source

#### pub fn round(self) -> Selfwhere T: Round,

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))``````
source

#### pub fn ceil(self) -> Selfwhere T: Ceil,

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))``````
source

#### pub fn floor(self) -> Selfwhere T: Floor,

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))``````
source

#### pub fn lerp(self, other: Self, t: T) -> Selfwhere T: One + Sub<Output = T> + Mul<Output = T> + Add<Output = T>,

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));``````
source§

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

source

source

source

#### pub fn clamp(self, start: Self, end: Self) -> Selfwhere T: Copy,

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

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

source§

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

source

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

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.

source

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

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.

source

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

Cast into an `f32` point.

source

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

Cast into an `f64` point.

source

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

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.

source

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

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.

source

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

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.

source

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

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.

source§

source

source§

source

## Trait Implementations§

source§

§

#### type Output = Point2D<<T as Add>::Output, U>

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Size2D<T, U>) -> Self::Output

Performs the `+` operation. Read more
source§

§

#### type Output = Point2D<<T as Add>::Output, U>

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Vector2D<T, U>) -> Self::Output

Performs the `+` operation. Read more
source§

source§

#### fn add_assign(&mut self, other: Size2D<T, U>)

Performs the `+=` operation. Read more
source§

### impl<T: Copy + Add<T, Output = T>, U> AddAssign<Vector2D<T, U>> for Point2D<T, U>

source§

#### fn add_assign(&mut self, other: Vector2D<T, U>)

Performs the `+=` operation. Read more
source§

### impl<T: ApproxEq<T>, U> ApproxEq<Point2D<T, U>> for Point2D<T, U>

source§

#### fn approx_epsilon() -> Self

Default epsilon value
source§

#### fn approx_eq_eps(&self, other: &Self, eps: &Self) -> bool

Returns `true` is this object is approximately equal to the other one, using a provided epsilon value.
source§

#### fn approx_eq(&self, other: &Self) -> bool

Returns `true` is this object is approximately equal to the other one, using the `approx_epsilon()` epsilon value.
source§

source§

source§

### impl<T: Clone, U> Clone for Point2D<T, U>

source§

#### fn clone(&self) -> Self

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from `source`. Read more
source§

### impl<T: Debug, U> Debug for Point2D<T, U>

source§

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

Formats the value using the given formatter. Read more
source§

### impl<T: Default, U> Default for Point2D<T, U>

source§

#### fn default() -> Self

Returns the “default value” for a type. Read more
source§

### impl<'de, T, U> Deserialize<'de> for Point2D<T, U>where T: Deserialize<'de>,

source§

#### fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

### impl<T: Copy + Div, U1, U2> Div<Scale<T, U1, U2>> for Point2D<T, U2>

§

#### type Output = Point2D<<T as Div>::Output, U1>

The resulting type after applying the `/` operator.
source§

#### fn div(self, scale: Scale<T, U1, U2>) -> Self::Output

Performs the `/` operation. Read more
source§

### impl<T: Copy + Div, U> Div<T> for Point2D<T, U>

§

#### type Output = Point2D<<T as Div>::Output, U>

The resulting type after applying the `/` operator.
source§

#### fn div(self, scale: T) -> Self::Output

Performs the `/` operation. Read more
source§

### impl<T: Copy + DivAssign, U> DivAssign<Scale<T, U, U>> for Point2D<T, U>

source§

#### fn div_assign(&mut self, scale: Scale<T, U, U>)

Performs the `/=` operation. Read more
source§

### impl<T: Copy + Div<T, Output = T>, U> DivAssign<T> for Point2D<T, U>

source§

#### fn div_assign(&mut self, scale: T)

Performs the `/=` operation. Read more
source§

source§

source§

### impl<T, U> From<[T; 2]> for Point2D<T, U>

source§

#### fn from([x, y]: [T; 2]) -> Self

Converts to this type from the input type.
source§

### impl<T, U> From<(T, T)> for Point2D<T, U>

source§

#### fn from(tuple: (T, T)) -> Self

Converts to this type from the input type.
source§

### impl<T: Zero + One, U> From<Point2D<T, U>> for HomogeneousVector<T, U>

source§

#### fn from(p: Point2D<T, U>) -> Self

Converts to this type from the input type.
source§

### impl<T, U> Hash for Point2D<T, U>where T: Hash,

source§

#### fn hash<H: Hasher>(&self, h: &mut H)

Feeds this value into the given `Hasher`. Read more
1.3.0 · source§

#### fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given `Hasher`. Read more
source§

### impl<T, U> Into<[T; 2]> for Point2D<T, U>

source§

#### fn into(self) -> [T; 2]

Converts this type into the (usually inferred) input type.
source§

### impl<T, U> Into<(T, T)> for Point2D<T, U>

source§

#### fn into(self) -> (T, T)

Converts this type into the (usually inferred) input type.
source§

### impl<T: Copy + Mul, U1, U2> Mul<Scale<T, U1, U2>> for Point2D<T, U1>

§

#### type Output = Point2D<<T as Mul>::Output, U2>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, scale: Scale<T, U1, U2>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<T: Copy + Mul, U> Mul<T> for Point2D<T, U>

§

#### type Output = Point2D<<T as Mul>::Output, U>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, scale: T) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<T: Copy + MulAssign, U> MulAssign<Scale<T, U, U>> for Point2D<T, U>

source§

#### fn mul_assign(&mut self, scale: Scale<T, U, U>)

Performs the `*=` operation. Read more
source§

### impl<T: Copy + Mul<T, Output = T>, U> MulAssign<T> for Point2D<T, U>

source§

#### fn mul_assign(&mut self, scale: T)

Performs the `*=` operation. Read more
source§

### impl<T: Neg, U> Neg for Point2D<T, U>

§

#### type Output = Point2D<<T as Neg>::Output, U>

The resulting type after applying the `-` operator.
source§

#### fn neg(self) -> Self::Output

Performs the unary `-` operation. Read more
source§

### impl<T, U> PartialEq for Point2D<T, U>where T: PartialEq,

source§

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

This method tests for `self` and `other` values to be equal, and is used by `==`.
1.0.0 · source§

#### 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.
source§

source§

source§

### impl<T, U> Serialize for Point2D<T, U>where T: Serialize,

source§

#### fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer. Read more
source§

### impl<T: Sub, U> Sub<Size2D<T, U>> for Point2D<T, U>

§

#### type Output = Point2D<<T as Sub>::Output, U>

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Size2D<T, U>) -> Self::Output

Performs the `-` operation. Read more
source§

### impl<T: Sub, U> Sub<Vector2D<T, U>> for Point2D<T, U>

§

#### type Output = Point2D<<T as Sub>::Output, U>

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Vector2D<T, U>) -> Self::Output

Performs the `-` operation. Read more
source§

### impl<T: Sub, U> Sub for Point2D<T, U>

§

#### type Output = Vector2D<<T as Sub>::Output, U>

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Self) -> Self::Output

Performs the `-` operation. Read more
source§

### impl<T: SubAssign, U> SubAssign<Size2D<T, U>> for Point2D<T, U>

source§

#### fn sub_assign(&mut self, other: Size2D<T, U>)

Performs the `-=` operation. Read more
source§

### impl<T: Copy + Sub<T, Output = T>, U> SubAssign<Vector2D<T, U>> for Point2D<T, U>

source§

#### fn sub_assign(&mut self, other: Vector2D<T, U>)

Performs the `-=` operation. Read more
source§

source§

source§

source§

§

§

§

§

§

§

## Blanket Implementations§

source§

### impl<T> Any for Twhere T: 'static + ?Sized,

source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
source§

### impl<T> Borrow<T> for Twhere T: ?Sized,

source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

### impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

### impl<T> From<T> for T

source§

#### fn from(t: T) -> T

Returns the argument unchanged.

source§

### impl<T, U> Into<U> for Twhere U: From<T>,

source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source§

### impl<T> ToOwned for Twhere T: Clone,

§

#### type Owned = T

The resulting type after obtaining ownership.
source§

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

### impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

### impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§