Struct intersection_detection::Line

pub struct Line<F: Float + PartialEq, P: PointLike<F>> {
    pub start: P,
    pub end: P,
    /* private fields */
}

A line segment from start to end.

See: PointLike

Fields

start: P

end: P

Implementations

impl<F: Float + PartialEq, P: PointLike<F>> Line<F, P>

pub fn new(start: P, end: P) -> Self

Constructs a new Line.

impl<F: Float, P: PointLike<F>> Line<F, P>

pub fn length(&self) -> F

Compute the length of the line segment.

pub fn direction(&self) -> P

Compute the non-normalized direction of self.

pub fn intersection(&self, other: &Self, epsilon: F) -> IntersectionResult<F, P>

Compute the intersection between two line segments, if any.

Trait Implementations

impl<F: Float, P: PointLike<F>> ApproxEq<&Line<F, P>, F> for Line<F, P>

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

Approximate equality between two line segments.

See: [PointLike::approx_eq]

impl<F: Clone + Float + PartialEq, P: Clone + PointLike<F>> Clone for Line<F, P>

fn clone(&self) -> Line<F, P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: Debug + Float + PartialEq, P: Debug + PointLike<F>> Debug for Line<F, P>

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

Formats the value using the given formatter.

impl<F: Float, P> From<[&P; 2]> for Line<F, P>

where P: Clone + PointLike<F>,

fn from([start, end]: [&P; 2]) -> Self

Converts to this type from the input type.

impl<F: Float, P: PointLike<F>> From<[P; 2]> for Line<F, P>

fn from([start, end]: [P; 2]) -> Self

Converts to this type from the input type.

impl<F: Float, P> From<(&P, &P)> for Line<F, P>

where P: Clone + PointLike<F>,

fn from((start, end): (&P, &P)) -> Self

Converts to this type from the input type.

impl<F: Float, P: PointLike<F>> From<(P, P)> for Line<F, P>

fn from((start, end): (P, P)) -> Self

Converts to this type from the input type.

impl<F: Float, P: PointLike<F>> PartialEq for Line<F, P>

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

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

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.

impl<F: Float, P: PointLike<F>> PrecisionRound for Line<F, P>

fn round(self, precision: usize) -> Self

Round a line segment’s start and end points to precision decimal places.

impl<F: Copy + Float + PartialEq, P: Copy + PointLike<F>> Copy for Line<F, P>

impl<F: Eq + Float + PartialEq, P: Eq + PointLike<F>> Eq for Line<F, P>

impl<F: Float + PartialEq, P: PointLike<F>> StructuralEq for Line<F, P>