Struct Plane 

pub struct Plane<T: Number, const N: usize> { /* private fields */ }

A plane in 3D space, defined by a normal vector and a distance from the origin

Implementations

impl<T: Number> Plane<T, 3>

pub fn xy_plane() -> Self

pub fn xz_plane() -> Self

pub fn yz_plane() -> Self

impl<T, const N: usize> Plane<T, N>

where T: Number,

pub fn new(normal: SVector<T, N>, distance: T) -> Self

pub fn normal(&self) -> SVector<T, N>

pub fn with_normal(self, normal: SVector<T, N>) -> Self

pub fn distance(&self) -> T

Returns the signed distance from the origin to the plane along the normal.

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

Approximate equality check using epsilon tolerance.

pub fn origin_projection(&self) -> Point<T, N>

Returns the point on the plane closest to the origin. Requires the normal to be a unit vector.

pub fn classify_point(&self, point: &Point<T, N>) -> PlaneSide

pub fn has_point(&self, point: &Point<T, N>) -> bool

pub fn cast<T2: Number>(self) -> Plane<T2, N>

where T: AsPrimitive<T2>,

Cast the plane’s numeric type from T to T2.

pub fn flip(self) -> Self

pub fn classify_polygon(&self, polygon: &Polygon<T, N>) -> PolygonClassification

Classifies a polygon

Computes signed distances for all vertices in a single pass, tracking min/max to derive the classification without per-vertex branching.

impl<T: Number, const N: usize> Plane<T, N>

pub fn split_edge( &self, a: &Point<T, N>, b: &Point<T, N>, ) -> Result<(Point<T, N>, Point<T, N>, Point<T, N>), PlaneSide>

pub fn split_polygon( &self, polygon: Polygon<T, N>, ) -> (Polygon<T, N>, Polygon<T, N>)

Split a spanning polygon into a front fragment and a back fragment.

Algorithm:

1. Classify each vertex with classify_point.
2. For each consecutive edge (a, b):
   • If a is Front, add a to the front list.
   • If a is Back, add a to the back list.
   • If a is On, add a to both lists.
   • If edge (a, b) crosses the plane (a and b have opposite Front/Back classification): compute the intersection point p = a + t*(b-a) where t = (d - n·a) / (n·(b-a)), then add p to both lists.
3. Build two new Polygons from the front and back vertex lists, keeping the original plane.

Metadata is preserved: both fragments inherit the source polygon’s metadata.

impl<T> Plane<T, 3>

where T: Number + AddAssign + SubAssign + MulAssign + RealField,

pub fn from_points(p1: Point3<T>, p2: Point3<T>, p3: Point3<T>) -> Self

Construct a plane from three non-collinear points. The normal is oriented by the right-hand rule: (p2 - p1) × (p3 - p1).

pub fn rotation_to(&self, other: Plane<T, 3>) -> Matrix3<T>

where T: Signed,

Compute the 3×3 rotation matrix R such that R * self.normal() == other.normal().

In other words, given a point p that lies in the plane described by self, the product R * p will lie in the plane described by other. This is the unique shortest-arc rotation (minimum rotation angle) that carries one normal onto the other, computed via the Rodrigues rotation formula in its trigonometry-free form.

Mathematical derivation

Let a = self.normal() and b = other.normal() (both assumed to be unit vectors).

The angle θ between them satisfies:

  cos θ  = a · b           (dot product)
  sin θ  = ‖a × b‖         (magnitude of cross product)

The rotation axis is v = a × b (unnormalized; its magnitude is sin θ).

The skew-symmetric cross-product matrix [v]× encodes the “cross with v” operation:

        ⎡  0   −v₃   v₂ ⎤
[v]× =  ⎢  v₃   0   −v₁ ⎥
        ⎣ −v₂   v₁   0  ⎦

Rodrigues’ formula then gives:

R = I  +  [v]×  +  [v]ײ  ·  1/(1 + cos θ)

This avoids calling acos/sin/cos and is numerically stable for all θ except θ = 180° (anti-parallel normals), which is handled separately below.

Special case: anti-parallel normals (θ ≈ 180°)

When a · b ≈ −1 the denominator (1 + cos θ) approaches zero, so the formula above is undefined. Geometrically, any 180° rotation whose axis is perpendicular to a is a valid solution; we break the degeneracy by choosing the world axis that is least aligned with a (found with iamin() — the index of the smallest absolute component) as a helper to build a perpendicular rotation axis:

rot_axis = (a × world_axis).normalize()
R = −I + 2 · rot_axis · rot_axisᵀ

(This is Rodrigues with θ = π: cos π = −1, sin π = 0.)

Trait Implementations

impl<T: Clone + Number, const N: usize> Clone for Plane<T, N>

fn clone(&self) -> Plane<T, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Number, const N: usize> Debug for Plane<T, N>

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

Formats the value using the given formatter.

impl<T: PartialEq + Number, const N: usize> PartialEq for Plane<T, N>

fn eq(&self, other: &Plane<T, N>) -> 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<T: PartialOrd + Number, const N: usize> PartialOrd for Plane<T, N>

fn partial_cmp(&self, other: &Plane<T, N>) -> Option<Ordering>

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<T: Copy + Number, const N: usize> Copy for Plane<T, N>

impl<T: Number, const N: usize> StructuralPartialEq for Plane<T, N>