Struct spade::primitives::SimpleEdge

pub struct SimpleEdge<V: PointN> {
    pub from: V,
    pub to: V,
}

An edge defined by it's two end points.

Fields

from: V

The edge's origin.

to: V

The edge's destination.

Methods

impl<V> SimpleEdge<V> where
    V: PointN, 

pub fn new(from: V, to: V) -> SimpleEdge<V>

Creates a new edge from from to to.

pub fn is_projection_on_edge(&self, query_point: &V) -> bool

Projects a point onto the infinite line going through the edge's start and end point and returns true if the projected points lies between from and to.

pub fn length2(&self) -> V::Scalar

Returns the edge's squared length.

impl<V> SimpleEdge<V> where
    V: TwoDimensional, 

pub fn side_query<K: DelaunayKernel<V::Scalar>>(
    &self,
    q: &V
) -> EdgeSideInfo<V::Scalar>

Determines on which side of this edge a given point lies.

Example:

use nalgebra::Point2;
use spade::kernels::TrivialKernel;
use spade::primitives::SimpleEdge;

let e = SimpleEdge::new(Point2::new(0f32, 0.), Point2::new(1., 1.));
assert!(e.side_query::<TrivialKernel>(&Point2::new(1.0, 0.0)).is_on_right_side());
assert!(e.side_query::<TrivialKernel>(&Point2::new(0.0, 1.0)).is_on_left_side());
assert!(e.side_query::<TrivialKernel>(&Point2::new(0.5, 0.5)).is_on_line());

pub fn intersects_edge_non_collinear<K>(&self, other: &SimpleEdge<V>) -> bool where
    K: DelaunayKernel<V::Scalar>, 

Checks if this and another edge intersect.

The edges must not be collinear. Also, true is returned if the edges just touch each other.

Panics

Panics if both lines are collinear.

impl<V> SimpleEdge<V> where
    V: PointN,
    V::Scalar: SpadeFloat, 

pub fn nearest_point(&self, query_point: &V) -> V

Yields the nearest point on this edge.

pub fn projection_distance2(&self, query_point: &V) -> V::Scalar

Returns the squared distance of a given point to its projection onto the infinite line going through this edge's start and end point.

pub fn project_point(&self, query_point: &V) -> V::Scalar

Projects a point on this line and returns its relative position.

This method will return a value between 0. and 1. (linearly interpolated) if the projected point lies between self.from and self.to, a value close to zero (due to rounding errors) if the projected point is equal to self.from and a value smaller than zero if the projected point lies "before" self.from. Analogously, a value close to 1. or greater than 1. is returned if the projected point is equal to or lies behind self.to.

Trait Implementations

impl<V: PointN> SpatialObject for SimpleEdge<V> where
    V::Scalar: SpadeFloat, 

type Point = V

The object's point type.

fn mbr(&self) -> BoundingRect<V>

Returns the object's minimal bounding rectangle.

fn distance2(&self, point: &V) -> V::Scalar

Returns the squared euclidean distance from the object's contour. Returns a value samller than zero if the point is contained within the object.

fn contains(&self, point: &Self::Point) -> bool

Returns true if a given point is contained in this object.

impl<V: Eq + PointN> Eq for SimpleEdge<V>

impl<V: Clone + PointN> Clone for SimpleEdge<V>

fn clone(&self) -> SimpleEdge<V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V: PartialOrd + PointN> PartialOrd<SimpleEdge<V>> for SimpleEdge<V>

fn partial_cmp(&self, other: &SimpleEdge<V>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &SimpleEdge<V>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &SimpleEdge<V>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &SimpleEdge<V>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &SimpleEdge<V>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<V: Ord + PointN> Ord for SimpleEdge<V>

fn cmp(&self, other: &SimpleEdge<V>) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<V: PartialEq + PointN> PartialEq<SimpleEdge<V>> for SimpleEdge<V>

fn eq(&self, other: &SimpleEdge<V>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &SimpleEdge<V>) -> bool

This method tests for !=.

impl<V: Copy + PointN> Copy for SimpleEdge<V>

impl<V: Hash + PointN> Hash for SimpleEdge<V>

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, 

Feeds a slice of this type into the given [Hasher].

impl<V: Debug + PointN> Debug for SimpleEdge<V>

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

Formats the value using the given formatter.