Struct fart_2d_geom::Line

pub struct Line<T, U> {
    pub a: TypedPoint2D<T, U>,
    pub b: TypedPoint2D<T, U>,
}

A line between two points.

Fields

a: TypedPoint2D<T, U>

The first point.

b: TypedPoint2D<T, U>

The second point.

Methods

impl<T, U> Line<T, U> where
    T: Copy + Num + PartialOrd, 

pub fn new(a: TypedPoint2D<T, U>, b: TypedPoint2D<T, U>) -> Line<T, U>

Create a new line between the given points.

pub fn relative_direction_of(
    &self,
    point: TypedPoint2D<T, U>
) -> RelativeDirection

Get the direction of the point relative to this line.

pub fn is_left(&self, point: TypedPoint2D<T, U>) -> bool

Is the given point on the left of this line?

use euclid::{point2, UnknownUnit};
use fart_2d_geom::{line, Line};

let l: Line<i32, UnknownUnit> = line(point2(0, 0), point2(1, 1));

assert!(l.is_left(point2(0, 1)));
assert!(!l.is_left(point2(1, 0)));

// Collinear points are not considered on the left of the line. See
// also `is_left_or_collinear`.
assert!(!l.is_left(point2(2, 2)));

pub fn is_left_or_collinear(&self, point: TypedPoint2D<T, U>) -> bool

Is the given point on the left of this line or collinear with it?

use euclid::{point2, UnknownUnit};
use fart_2d_geom::{line, Line};

let l: Line<i32, UnknownUnit> = line(point2(0, 0), point2(1, 1));

assert!(l.is_left_or_collinear(point2(0, 1)));
assert!(l.is_left_or_collinear(point2(2, 2)));

assert!(!l.is_left_or_collinear(point2(1, 0)));

pub fn is_collinear(&self, point: TypedPoint2D<T, U>) -> bool

Is the given point collinear with this line?

use euclid::{point2, UnknownUnit};
use fart_2d_geom::{line, Line};

let l: Line<i32, UnknownUnit> = line(point2(0, 0), point2(1, 1));

assert!(l.is_collinear(point2(2, 2)));

assert!(!l.is_collinear(point2(0, 1)));
assert!(!l.is_collinear(point2(1, 0)));

pub fn is_right(&self, point: TypedPoint2D<T, U>) -> bool

Is the given point on the right of this line?

use euclid::{point2, UnknownUnit};
use fart_2d_geom::{line, Line};

let l: Line<i32, UnknownUnit> = line(point2(0, 0), point2(1, 1));

assert!(l.is_right(point2(1, 0)));
assert!(!l.is_right(point2(0, 1)));

// Collinear points are not considered on the right of the line. See
// also `is_right_or_collinear`.
assert!(!l.is_right(point2(2, 2)));

pub fn is_right_or_collinear(&self, point: TypedPoint2D<T, U>) -> bool

Is the given point on the right of this line or collinear with it?

use euclid::{point2, UnknownUnit};
use fart_2d_geom::{line, Line};

let l: Line<i32, UnknownUnit> = line(point2(0, 0), point2(1, 1));

assert!(l.is_right_or_collinear(point2(1, 0)));
assert!(l.is_right_or_collinear(point2(2, 2)));

assert!(!l.is_right_or_collinear(point2(0, 1)));

pub fn is_on(&self, point: TypedPoint2D<T, U>) -> bool

Is the given point on this line segment? That is, not just collinear, but also between self.a and self.b?

use euclid::{point2, UnknownUnit};
use fart_2d_geom::{line, Line};

let l: Line<i32, UnknownUnit> = line(point2(0, 0), point2(2, 2));

assert!(l.is_on(point2(1, 1)));

assert!(!l.is_on(point2(0, 1)));
assert!(!l.is_on(point2(1, 0)));

// Inclusive of the line segment's boundaries.
assert!(l.is_on(l.a));
assert!(l.is_on(l.b));

// Does not include collinear-but-not-between points.
assert!(!l.is_on(point2(3, 3)));

pub fn intersects(&self, other: &Line<T, U>) -> bool

Does this line segment (properly) intersect with the other line segment?

use euclid::{point2, UnknownUnit};
use fart_2d_geom::{line, Line};

assert!(
    line::<i32, UnknownUnit>(point2(0, 0), point2(1, 1))
        .intersects(&line(point2(0, 1), point2(1, 0)))
);

assert!(
    !line::<i32, UnknownUnit>(point2(0, 0), point2(1, 1))
        .intersects(&line(point2(1, 0), point2(2, -1)))
);

// If any end points from one line segment land on the other line
// segment, `false` is returned because that is not proper intersection.
assert!(
    !line::<i32, UnknownUnit>(point2(0, 0), point2(2, 2))
        .intersects(&line(point2(1, 1), point2(2, 0)))
);

pub fn improperly_intersects(&self, other: &Line<T, U>) -> bool

Does this line segment improperly intersect with the other line segment?

use euclid::{point2, UnknownUnit};
use fart_2d_geom::{line, Line};

assert!(
    line::<i32, UnknownUnit>(point2(0, 0), point2(1, 1))
        .improperly_intersects(&line(point2(0, 1), point2(1, 0)))
);

assert!(
    !line::<i32, UnknownUnit>(point2(0, 0), point2(1, 1))
        .improperly_intersects(&line(point2(1, 0), point2(2, -1)))
);

// If any end points from one line segment land on the other line
// segment, `true` is still returned.
assert!(
    line::<i32, UnknownUnit>(point2(0, 0), point2(2, 2))
        .improperly_intersects(&line(point2(1, 1), point2(2, 0)))
);

Trait Implementations

impl<T: Copy, U: Copy> Copy for Line<T, U>

impl<T: PartialEq, U: PartialEq> PartialEq<Line<T, U>> for Line<T, U>

fn eq(&self, other: &Line<T, U>) -> bool

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

fn ne(&self, other: &Line<T, U>) -> bool

This method tests for !=.

impl<T: Clone, U: Clone> Clone for Line<T, U>

fn clone(&self) -> Line<T, U>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Eq, U: Eq> Eq for Line<T, U>

impl<T: Debug, U: Debug> Debug for Line<T, U>

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

Formats the value using the given formatter.

impl<T: Hash, U: Hash> Hash for Line<T, U>

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

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].