[][src]Trait nannou::math::prelude::EuclideanSpace

pub trait EuclideanSpace: Copy + Clone + Array<Element = Self::Scalar> + Add<Self::Diff, Output = Self> + Sub<Self::Diff, Output = Self, Output = Self::Diff> + Sub<Self> + Mul<Self::Scalar, Output = Self> + Div<Self::Scalar, Output = Self> + Rem<Self::Scalar, Output = Self> where
    <Self::Diff as VectorSpace>::Scalar == Self::Scalar
{ type Scalar: BaseNum; type Diff: VectorSpace; fn origin() -> Self;
fn from_vec(v: Self::Diff) -> Self;
fn to_vec(self) -> Self::Diff;
fn dot(self, v: Self::Diff) -> Self::Scalar; fn midpoint(self, other: Self) -> Self { ... }
fn centroid(points: &[Self]) -> Self { ... } }

Points in a Euclidean space with an associated space of displacement vectors.

Point-Vector distinction

cgmath distinguishes between points and vectors in the following way:

  • Points are locations relative to an origin
  • Vectors are displacements between those points

For example, to find the midpoint between two points, you can write the following:

use cgmath::Point3;

let p0 = Point3::new(1.0, 2.0, 3.0);
let p1 = Point3::new(-3.0, 1.0, 2.0);
let midpoint: Point3<f32> = p0 + (p1 - p0) * 0.5;

Breaking the expression up, and adding explicit types makes it clearer to see what is going on:

let dv: Vector3<f32> = p1 - p0;
let half_dv: Vector3<f32> = dv * 0.5;
let midpoint: Point3<f32> = p0 + half_dv;

Converting between points and vectors

Points can be converted to and from displacement vectors using the EuclideanSpace::{from_vec, to_vec} methods. Note that under the hood these are implemented as inlined a type conversion, so should not have any performance implications.

References

Associated Types

type Scalar: BaseNum

The associated scalar over which the space is defined.

Due to the equality constraints demanded by Self::Diff, this is effectively just an alias to Self::Diff::Scalar.

type Diff: VectorSpace

The associated space of displacement vectors.

Loading content...

Required methods

fn origin() -> Self

The point at the origin of the Euclidean space.

fn from_vec(v: Self::Diff) -> Self

Convert a displacement vector to a point.

This can be considered equivalent to the addition of the displacement vector v to to Self::origin().

fn to_vec(self) -> Self::Diff

Convert a point to a displacement vector.

This can be seen as equivalent to the displacement vector from Self::origin() to self.

fn dot(self, v: Self::Diff) -> Self::Scalar

This is a weird one, but its useful for plane calculations.

Loading content...

Provided methods

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

Returns the middle point between two other points.

use cgmath::prelude::*;
use cgmath::Point3;

let p = Point3::midpoint(
    Point3::new(1.0, 2.0, 3.0),
    Point3::new(3.0, 1.0, 2.0),
);

fn centroid(points: &[Self]) -> Self

Returns the average position of all points in the slice.

use cgmath::prelude::*;
use cgmath::Point2;

let triangle = [
    Point2::new(1.0, 1.0),
    Point2::new(2.0, 3.0),
    Point2::new(3.0, 1.0),
];

let centroid = Point2::centroid(&triangle);
Loading content...

Implementations on Foreign Types

impl<S> EuclideanSpace for Point1<S> where
    S: BaseNum
[src]

type Scalar = S

type Diff = Vector1<S>

fn midpoint(self, other: Self) -> Self[src]

fn centroid(points: &[Self]) -> Self[src]

impl<S> EuclideanSpace for Point3<S> where
    S: BaseNum
[src]

type Scalar = S

type Diff = Vector3<S>

fn midpoint(self, other: Self) -> Self[src]

fn centroid(points: &[Self]) -> Self[src]

impl<S> EuclideanSpace for Point2<S> where
    S: BaseNum
[src]

type Scalar = S

type Diff = Vector2<S>

fn midpoint(self, other: Self) -> Self[src]

fn centroid(points: &[Self]) -> Self[src]

Loading content...

Implementors

impl<S> EuclideanSpace for Vector2<S> where
    S: BaseNum
[src]

type Scalar = S

type Diff = Vector2<S>

fn midpoint(self, other: Self) -> Self[src]

fn centroid(points: &[Self]) -> Self[src]

impl<S> EuclideanSpace for Vector3<S> where
    S: BaseNum
[src]

type Scalar = S

type Diff = Vector3<S>

fn midpoint(self, other: Self) -> Self[src]

fn centroid(points: &[Self]) -> Self[src]

impl<S> EuclideanSpace for Vector4<S> where
    S: BaseNum
[src]

type Scalar = S

type Diff = Vector4<S>

fn midpoint(self, other: Self) -> Self[src]

fn centroid(points: &[Self]) -> Self[src]

Loading content...