Struct Point2

pub struct Point2<T> {
    pub x: T,
    pub y: T,
}

Generic point in 2D space

Fields

x: T

y: T

Implementations

impl<T> Point2<T>

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

impl<T> Point2<T>

where T: Add<Output = T> + Mul<Output = T>,

pub fn dot(self, v: Self) -> T

impl<T> Point2<T>

where T: Add<Output = T>,

pub fn translate(self, vector: Self) -> Self

impl<T> Point2<T>

where T: Add<Output = T> + Copy + Neg<Output = T> + Sub<Output = T>,

pub fn rotate_90deg(&self, origin: Self, clockwise: bool) -> Self

Assumes a coordinate system with origin at the top-left. The behavior is undefined otherwise.

impl<T> Point2<T>

where T: Float,

pub fn rotate(&self, origin: Self, angle: T) -> Self

pub fn norm(self) -> T

The L2-norm

pub fn distance_to(&self, other: Point2<T>) -> T

The euclidean distance

impl<T> Point2<T>

where T: Default + Float,

pub fn get_normalized(&self) -> Self

impl Point2<i32>

pub fn to_point_usize(&self) -> PointUsize

pub fn to_point_f64(&self) -> PointF64

impl Point2<f64>

pub fn to_point_i32(&self) -> PointI32

pub fn to_point_f32(&self) -> PointF32

Trait Implementations

impl<T> Add for Point2<T>

where T: Add<Output = T>,

type Output = Point2<T>

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self

Performs the + operation.

impl<T> AddAssign for Point2<T>

where T: AddAssign,

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<T: Clone> Clone for Point2<T>

fn clone(&self) -> Point2<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F> Coordinate for Point2<F>

where F: Add<Output = F> + Copy + Default + Float + From<f64> + Into<f64> + Mul<f64, Output = F> + PartialEq + Sub<Output = F>,

fn from_components(components: &[f64]) -> Self

Creates a new coordinate from the specified set of components

fn origin() -> Self

Returns the origin coordinate

fn len() -> usize

The number of components in this coordinate

fn get(&self, index: usize) -> f64

Retrieves the component at the specified index

fn from_biggest_components(p1: Self, p2: Self) -> Self

Returns a point made up of the biggest components of the two points

fn from_smallest_components(p1: Self, p2: Self) -> Self

Returns a point made up of the smallest components of the two points

fn distance_to(&self, target: &Self) -> f64

Computes the distance between this coordinate and another of the same type

fn dot(&self, target: &Self) -> f64

Computes the dot product for this vector along with another vector

fn magnitude(&self) -> f64

Computes the magnitude of this vector

fn to_unit_vector(&self) -> Self

Treating this as a vector, returns a unit vector in the same direction

fn is_nan(&self) -> bool

Returns true if this coordinate has a NaN component

fn round(self, accuracy: f64) -> Self

Round this coordinate so that it is accurate to a certain precision

fn is_near_to(&self, other: &Self, max_distance: f64) -> bool

True if this point is within max_distance of another point

fn smooth(points: &[Self], weights: &[f64]) -> Vec<Self>

Generates a smoothed version of a set of coordinates, using the specified weights (weights should add up to 1.0).

impl<F> Coordinate2D for Point2<F>

where F: Copy + Into<f64>,

fn x(&self) -> f64

fn y(&self) -> f64

fn coords(&self) -> (f64, f64)

impl<T: Debug> Debug for Point2<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Point2<T>

fn default() -> Point2<T>

Returns the “default value” for a type.

impl<T, F> Div<F> for Point2<T>

where T: Div<F, Output = T>, F: Float,

type Output = Point2<T>

The resulting type after applying the / operator.

fn div(self, rhs: F) -> Self::Output

Performs the / operation.

impl<T, F> DivAssign<F> for Point2<T>

where T: DivAssign<F>, F: Float,

fn div_assign(&mut self, rhs: F)

Performs the /= operation.

impl<T: Hash> Hash for Point2<T>

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

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<T, F> Mul<F> for Point2<T>

where T: Mul<F, Output = T>, F: Float,

type Output = Point2<T>

The resulting type after applying the * operator.

fn mul(self, rhs: F) -> Self::Output

Performs the * operation.

impl<T, F> MulAssign<F> for Point2<T>

where T: MulAssign<F>, F: Float,

fn mul_assign(&mut self, rhs: F)

Performs the *= operation.

impl<T> Neg for Point2<T>

where T: Neg<Output = T>,

type Output = Point2<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: PartialEq> PartialEq for Point2<T>

fn eq(&self, other: &Point2<T>) -> 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<T> Sub for Point2<T>

where T: Sub<Output = T>,

type Output = Point2<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> SubAssign for Point2<T>

where T: SubAssign,

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<T> ToSvgString for Point2<T>

where T: Copy + NumberFormat,

fn to_svg_string(&self, precision: Option<u32>) -> String

impl<T: Copy> Copy for Point2<T>

impl<T: Eq> Eq for Point2<T>

impl<T> StructuralPartialEq for Point2<T>