Struct Polygon 

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

A simple 2d polygon in an N dimensional space, defined by its vertices and holes, and the plane it lies on

Implementations

impl<T> Polygon<T, 3>

where T: Number,

pub fn tessellate_earcut<N: Index>(&self) -> TessellatedPolygon<'_, T, 3, N>

Run earcut tessellation on the polygon

pub fn tessellate_earcut_with<N: Index>( &self, earcut: &mut Earcut<T>, ) -> TessellatedPolygon<'_, T, 3, N>

Use earcut tessellation on the polygon

pub fn tessellate_earcut_using_transform<N: Index>( &self, ) -> TessellatedPolygon<'_, T, 3, N>

Use earcut tessellation using

pub fn tessellate_delaunay<S: Index>(&self) -> TessellatedPolygon<'_, T, 3, S>

where T: SpadeNum,

Tessellate the polygon using Delaunay triangulation via the spade crate.

Projects vertices onto the dominant plane axis (same projection as tessellate_earcut) and feeds them into a fresh [DelaunayTriangulation]. Holes are not supported by the plain Delaunay algorithm; use tessellate_earcut when holes are present.

pub fn tessellate_delaunay_with<S: Index>( &self, triangulation: &mut DelaunayTriangulation<DelaunayVertex<T>>, ) -> TessellatedPolygon<'_, T, 3, S>

where T: SpadeNum,

Tessellate the polygon using a caller-supplied [DelaunayTriangulation].

The triangulation is cleared before use so that it can be reused across multiple calls without heap re-allocation (mirroring the earcut _with API pattern).

pub fn tessellate_delaunay_using_transform<S: Index>( &self, ) -> TessellatedPolygon<'_, T, 3, S>

where T: SpadeNum,

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

where T: Number,

pub fn from_points_and_plane( vertices: impl Into<Vec<Point<T, N>>>, plane: Plane<T, N>, ) -> Result<Self, String>

pub fn face_key(&self) -> Option<FaceKey>

pub fn set_face_key(&mut self, key: Option<FaceKey>)

pub fn holes(&self) -> &[Array1<usize>]

pub fn vertices(&self) -> ArrayView1<'_, Point<T, N>>

pub fn translate(self, offset: impl Into<SVector<T, N>>) -> Self

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

pub fn transform(self, transform: Transform<T, TAffine, N>) -> Self

where Const<N>: ToTypenum + DimNameAdd<U1>, <Const<N> as ToTypenum>::Typenum: Add<UInt<UTerm, B1>>, DefaultAllocator: Allocator<DimNameSum<Const<N>, U1>, DimNameSum<Const<N>, U1>> + Allocator<DimNameSum<Const<N>, U1>>,

Takes an affine transformation matrix and applies it to a n dimensional point polygon

pub fn bounding_box(&self) -> AxisAlignedBoundingBox<T, N>

pub fn map_vertices<F>(self, f: F) -> Self

where F: Fn(Point<T, N>) -> Point<T, N>,

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

where T: AsPrimitive<T2>,

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

impl<T> Polygon<T, 3>

where T: Number,

pub fn from_points( vertices: impl IntoIterator<Item = Point3<T>>, ) -> Result<Self, PolygonError>

Construct a polygon from a list of coplanar 3D points. The plane is derived from the first three vertices. Returns an error if fewer than 3 vertices are provided, or if any vertex is not coplanar with the plane defined by the first three.

pub fn circle(radius: T, segments: usize, plane: Plane<T, 3>) -> Self

pub fn square(size: T, plane: Plane<T, 3>) -> Self

pub fn rotate(self, rotation: Matrix3<T>) -> Self

Rotate all vertices and the plane by a 3×3 rotation matrix.

The rotation matrix must be orthogonal (e.g., from [euler_rotation_matrix]). For an orthogonal matrix, the plane distance is preserved.

pub fn rotate_euler(self, angles_deg: Vector3<T>) -> Self

Rotate by Euler angles (degrees), applied as Z × Y × X.

pub fn flip(self) -> Self

pub fn flip_in_place(&mut self)

pub fn recompute_plane(&mut self)

Recompute the cached plane from the current vertices via Newell’s method (normal oriented by winding, matching Plane::from_points, but robust to near-collinear leading vertices).

Required after any vertex map that doesn’t preserve the plane normal (e.g. non-uniform scale): a stale plane makes BSP classification inconsistent with the vertices, which cascades into unbounded polygon splitting.

Trait Implementations

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

fn clone(&self) -> Polygon<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 Polygon<T, N>

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

Formats the value using the given formatter.

impl<T, const N: usize> Mul<Polygon<T, N>> for SMatrix<T, N, N>

where T: Number,

type Output = Polygon<T, N>

The resulting type after applying the * operator.

fn mul(self, rhs: Polygon<T, N>) -> Self::Output

Performs the * operation.

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

fn eq(&self, other: &Polygon<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: Number, const N: usize> StructuralPartialEq for Polygon<T, N>