Struct Line 

pub struct Line {
    pub a: f64,
    pub b: f64,
    pub c: f64,
}

A mathematical Line which has an infinite length, but no width.

A line can be represented by the equation a*x + b*y + c = 0. The three fields Line::a, Line::b and Line::c correspond to these coefficients.

The main purpose of this type is being a tool for calculations. For example, the intersection of two LineSegments (straight connections between two points of usually finite length) can be calculated by first calculating the intersection of the corresponding infinite lines and then by checking whether the found intersection point is actually located on the segments. Another example is the ray casting algorithm, which is used in the contains_point implementation for Shapes.

Obviously, a Line object can be directly created by providing its three coefficients. Additionally, it is also possible to derive a Line from a point it goes through and its angle (Line::from_point_angle) and from a two-point representation (Line::from_two_points). Because the Line is closely related to the LineSegment, a From implementation exists.

The crate docstring describes the relationship between the Line and the other geometric types provided by this crate.

Serialization and deserialization

This struct can be serialized and deserialized from its three fields Line::a, Line::b and Line::c using the serde crate if the serde feature is enabled.

Fields

a: f64

Coefficient a in the line formula a*x + b*y + c = 0.

b: f64

Coefficient b in the line formula a*x + b*y + c = 0.

c: f64

Coefficient c in the line formula a*x + b*y + c = 0.

Implementations

impl Line

pub fn new(a: f64, b: f64, c: f64) -> Self

Creates a Line from its three coefficients. This is an alias for using the literal struct construction syntax Line { a, b, c }.

pub fn from_point_angle(pt: [f64; 2], angle: f64) -> Self

Creates a Line from a point it goes through and its angle (relative to the x / horizontal axis).

Examples

use std::f64::consts::PI;
use planar_geo::prelude::*;

// A line with a 45° angle going through [2.0, 0.0].
let line = Line::from_point_angle([2.0, 0.0], 0.25 * PI);

assert!(line.contains_point([1.0, -1.0], DEFAULT_EPSILON, DEFAULT_MAX_ULPS));
assert!(line.contains_point([2.0, 0.0], DEFAULT_EPSILON, DEFAULT_MAX_ULPS));
assert!(line.contains_point([3.0, 1.0], DEFAULT_EPSILON, DEFAULT_MAX_ULPS));

pub fn from_two_points( pt1: [f64; 2], pt2: [f64; 2], epsilon: f64, max_ulps: u32, ) -> Result<Self, Error>

Creates a Line from two points. This constructor fails if the points are identical (which is checked with approx::assert_ulps_eq, using the arguments epsilon and max_ulps for defining the absolute and ULPs tolerance respectively).

Examples

use planar_geo::prelude::*;

// A line with a 45° angle going through [2.0, 0.0].
let line = Line::from_two_points([2.0, 0.0], [3.0, 1.0], DEFAULT_EPSILON, DEFAULT_MAX_ULPS).expect("points not identical");

assert!(line.contains_point([1.0, -1.0], DEFAULT_EPSILON, DEFAULT_MAX_ULPS));
assert!(line.contains_point([2.0, 0.0], DEFAULT_EPSILON, DEFAULT_MAX_ULPS));
assert!(line.contains_point([3.0, 1.0], DEFAULT_EPSILON, DEFAULT_MAX_ULPS));

pub fn parallel(&self, other: &Self, epsilon: f64, max_ulps: u32) -> bool

Returns true if the two given lines are parallel within the tolerance band defined by the absolute tolerance epsilon and the ULPs tolerance max_ulps.

Examples

use planar_geo::prelude::*;

let line_1 = Line::from_point_angle([2.0, 0.0], 1.0);
let line_2 = Line::from_point_angle([2.0, 1.0], 1.0);
let line_3 = Line::from_point_angle([2.0, 0.0], -1.0);
assert!(line_1.parallel(&line_2, DEFAULT_EPSILON, DEFAULT_MAX_ULPS));
assert!(!line_1.parallel(&line_3, DEFAULT_EPSILON, DEFAULT_MAX_ULPS));
assert!(!line_2.parallel(&line_3, DEFAULT_EPSILON, DEFAULT_MAX_ULPS));

pub fn identical(&self, other: &Self, epsilon: f64, max_ulps: u32) -> bool

Returns true if the two given lines are identical within the tolerance band defined by the absolute tolerance epsilon and the ULPs tolerance max_ulps.

Examples

use planar_geo::prelude::*;

let line_1 = Line::from_point_angle([2.0, 0.0], 0.0);
let line_2 = Line::from_point_angle([-3.0, 0.0], 0.0);
let line_3 = Line::from_point_angle([2.0, 1.0], 0.0);
assert!(line_1.identical(&line_2, DEFAULT_EPSILON, DEFAULT_MAX_ULPS));
assert!(!line_1.identical(&line_3, DEFAULT_EPSILON, DEFAULT_MAX_ULPS));
assert!(!line_2.identical(&line_3, DEFAULT_EPSILON, DEFAULT_MAX_ULPS));

Trait Implementations

impl Clone for Line

fn clone(&self) -> Line

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Line

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Line

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&LineSegment> for Line

fn from(l: &LineSegment) -> Self

Converts to this type from the input type.

impl From<[[f64; 2]; 2]> for Line

fn from(pts: [[f64; 2]; 2]) -> Self

Converts to this type from the input type.

impl From<LineSegment> for Line

fn from(l: LineSegment) -> Self

Converts to this type from the input type.

impl PartialEq for Line

fn eq(&self, other: &Self) -> 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 Primitive for Line

fn contains_point(&self, point: [f64; 2], epsilon: f64, max_ulps: u32) -> bool

Returns true if self contains the given point and false otherwise.

fn intersections_line( &self, line: &Line, epsilon: f64, max_ulps: u32, ) -> PrimitiveIntersections

Returns the intersections between self and a Line.

fn intersections_line_segment( &self, line_segment: &LineSegment, epsilon: f64, max_ulps: u32, ) -> PrimitiveIntersections

Returns the intersections between self and a LineSegment.

fn intersections_arc_segment( &self, arc_segment: &ArcSegment, epsilon: f64, max_ulps: u32, ) -> PrimitiveIntersections

Returns the intersections between self and an ArcSegment.

fn intersections_primitive<T: Primitive>( &self, other: &T, epsilon: f64, max_ulps: u32, ) -> PrimitiveIntersections

Returns the intersection between self and another type implementing Primitive.

fn intersections_point( &self, point: [f64; 2], epsilon: f64, max_ulps: u32, ) -> PrimitiveIntersections

Returns the intersections between self and a point [f64; 2] * This function wraps the given point in PrimitiveIntersections::One if Primitive::contains_point returned true and returns PrimitiveIntersections::Zero otherwise.

fn intersections_segment( &self, segment: &Segment, epsilon: f64, max_ulps: u32, ) -> PrimitiveIntersections

Returns the intersection between self and a Segment.

impl Serialize for Line

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Transformation for Line

fn translate(&mut self, shift: [f64; 2])

Translates self by the given shift.

fn rotate(&mut self, center: [f64; 2], angle: f64)

Rotates self around the center by the given angle (in rad).

fn scale(&mut self, factor: f64)

Scales self by factor with respect to the origin [0.0, 0.0].

fn line_reflection(&mut self, start: [f64; 2], stop: [f64; 2])

Mirrors self about a line defined by two points.

fn point_reflection(&mut self, point: [f64; 2])

Mirrors self about a point. This operation is equivalent to a rotation around the point with the angle PI.

impl Copy for Line