Struct fj_math::Line

#[repr(C)]
pub struct Line<const D: usize> { /* private fields */ }

An n-dimensional line, defined by an origin and a direction

The dimensionality of the line is defined by the const generic D parameter.

Implementations

impl<const D: usize> Line<D>

pub fn from_origin_and_direction(origin: Point<D>, direction: Vector<D>) -> Self

Create a line from a point and a vector

Panics

Panics, if direction has a length of zero.

Examples found in repository

src/transform.rs (lines 60-63)

    pub fn transform_line(&self, line: &Line<3>) -> Line<3> {
        Line::from_origin_and_direction(
            self.transform_point(&line.origin()),
            self.transform_vector(&line.direction()),
        )
    }

src/line.rs (line 45)

    pub fn from_points(
        points: [impl Into<Point<D>>; 2],
    ) -> (Self, [Point<1>; 2]) {
        let [a, b] = points.map(Into::into);

        let line = Self::from_origin_and_direction(a, b - a);
        let coords = [[0.], [1.]].map(Point::from);

        (line, coords)
    }

    /// Create a line from two points that include line coordinates
    ///
    /// # Panics
    ///
    /// Panics, if the points are coincident.
    pub fn from_points_with_line_coords(
        points: [(impl Into<Point<1>>, impl Into<Point<D>>); 2],
    ) -> Self {
        let [(a_line, a_global), (b_line, b_global)] =
            points.map(|(point_line, point_global)| {
                (point_line.into(), point_global.into())
            });

        let direction = (b_global - a_global) / (b_line - a_line).t;
        let origin = a_global + direction * -a_line.t;

        Self::from_origin_and_direction(origin, direction)
    }

src/plane.rs (lines 86-89)

    pub fn project_line(&self, line: &Line<3>) -> Line<2> {
        let line_origin_relative_to_plane = line.origin() - self.origin();
        let line_origin_in_plane = Point {
            coords: Vector::from([
                self.u()
                    .scalar_projection_onto(&line_origin_relative_to_plane),
                self.v()
                    .scalar_projection_onto(&line_origin_relative_to_plane),
            ]),
        };

        let line_direction_in_plane = self.project_vector(&line.direction());

        Line::from_origin_and_direction(
            line_origin_in_plane,
            line_direction_in_plane,
        )
    }

pub fn from_points(points: [impl Into<Point<D>>; 2]) -> (Self, [Point<1>; 2])

Create a line from two points

Also returns the lines coordinates of the provided points on the new line.

Panics

Panics, if the points are coincident.

pub fn from_points_with_line_coords(
    points: [(impl Into<Point<1>>, impl Into<Point<D>>); 2]
) -> Self

Create a line from two points that include line coordinates

Panics

Panics, if the points are coincident.

pub fn origin(&self) -> Point<D>

Access the origin of the line

The origin is a point on the line which, together with the direction field, defines the line fully. The origin also defines the origin of the line’s 1-dimensional coordinate system.

Examples found in repository

src/transform.rs (line 61)

    pub fn transform_line(&self, line: &Line<3>) -> Line<3> {
        Line::from_origin_and_direction(
            self.transform_point(&line.origin()),
            self.transform_vector(&line.direction()),
        )
    }

src/plane.rs (line 74)

    pub fn project_line(&self, line: &Line<3>) -> Line<2> {
        let line_origin_relative_to_plane = line.origin() - self.origin();
        let line_origin_in_plane = Point {
            coords: Vector::from([
                self.u()
                    .scalar_projection_onto(&line_origin_relative_to_plane),
                self.v()
                    .scalar_projection_onto(&line_origin_relative_to_plane),
            ]),
        };

        let line_direction_in_plane = self.project_vector(&line.direction());

        Line::from_origin_and_direction(
            line_origin_in_plane,
            line_direction_in_plane,
        )
    }

pub fn direction(&self) -> Vector<D>

Access the direction of the line

The length of this vector defines the unit of the line’s curve coordinate system. The coordinate 1. is always were the direction vector points, from origin.

Examples found in repository

src/transform.rs (line 62)

    pub fn transform_line(&self, line: &Line<3>) -> Line<3> {
        Line::from_origin_and_direction(
            self.transform_point(&line.origin()),
            self.transform_vector(&line.direction()),
        )
    }

src/plane.rs (line 84)

    pub fn project_line(&self, line: &Line<3>) -> Line<2> {
        let line_origin_relative_to_plane = line.origin() - self.origin();
        let line_origin_in_plane = Point {
            coords: Vector::from([
                self.u()
                    .scalar_projection_onto(&line_origin_relative_to_plane),
                self.v()
                    .scalar_projection_onto(&line_origin_relative_to_plane),
            ]),
        };

        let line_direction_in_plane = self.project_vector(&line.direction());

        Line::from_origin_and_direction(
            line_origin_in_plane,
            line_direction_in_plane,
        )
    }

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

Determine if this line is coincident with another line

Implementation Note

This method only returns true, if the lines are precisely coincident. This will probably not be enough going forward, but it’ll do for now.

pub fn reverse(self) -> Self

Create a new instance that is reversed

pub fn point_to_line_coords(&self, point: impl Into<Point<D>>) -> Point<1>

Convert a D-dimensional point to line coordinates

Projects the point onto the line before the conversion. This is done to make this method robust against floating point accuracy issues.

Callers are advised to be careful about the points they pass, as the point not being on the line, intentional or not, will never result in an error.

pub fn vector_to_line_coords(&self, vector: impl Into<Vector<D>>) -> Vector<1>

Convert a D-dimensional vector to line coordinates

Examples found in repository

src/line.rs (line 132)

    pub fn point_to_line_coords(&self, point: impl Into<Point<D>>) -> Point<1> {
        Point {
            coords: self.vector_to_line_coords(point.into() - self.origin),
        }
    }

pub fn point_from_line_coords(&self, point: impl Into<Point<1>>) -> Point<D>

Convert a point in line coordinates into a D-dimensional point

pub fn vector_from_line_coords(&self, vector: impl Into<Vector<1>>) -> Vector<D>

Convert a vector in line coordinates into a D-dimensional vector

Examples found in repository

src/line.rs (line 151)

    pub fn point_from_line_coords(
        &self,
        point: impl Into<Point<1>>,
    ) -> Point<D> {
        self.origin + self.vector_from_line_coords(point.into().coords)
    }

Trait Implementations

impl<const D: usize> AbsDiffEq<Line<D>> for Line<D>

type Epsilon = <Scalar as AbsDiffEq<Scalar>>::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<const D: usize> Clone for Line<D>

fn clone(&self) -> Line<D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const D: usize> Debug for Line<D>

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

Formats the value using the given formatter.

impl<const D: usize> Default for Line<D>

fn default() -> Line<D>

Returns the “default value” for a type.

impl<const D: usize> Hash for Line<D>

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,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const D: usize> Ord for Line<D>

fn cmp(&self, other: &Line<D>) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<const D: usize> PartialEq<Line<D>> for Line<D>

fn eq(&self, other: &Line<D>) -> 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<const D: usize> PartialOrd<Line<D>> for Line<D>

fn partial_cmp(&self, other: &Line<D>) -> Option<Ordering>

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

fn lt(&self, other: &Rhs) -> bool

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

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

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

fn ge(&self, other: &Rhs) -> bool

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

impl<const D: usize> Copy for Line<D>

impl<const D: usize> Eq for Line<D>

impl<const D: usize> StructuralEq for Line<D>

impl<const D: usize> StructuralPartialEq for Line<D>