Struct plane_split::polygon::Polygon

pub struct Polygon<A> {
    pub points: [Point3D<f64>; 4],
    pub plane: Plane,
    pub anchor: A,
}

A convex polygon with 4 points lying on a plane.

Fields

points: [Point3D<f64>; 4]

Points making the polygon.

plane: Plane

A plane describing polygon orientation.

anchor: A

A simple anchoring index to allow association of the produced split polygons with the original one.

Implementations

impl<A> Polygon<A>

where A: Copy,

pub fn from_points(points: [Point3D<f64>; 4], anchor: A) -> Option<Self>

Construct a polygon from points that are already transformed. Return None if the polygon doesn’t contain any space.

pub fn from_rect(rect: Rect<f64>, anchor: A) -> Self

Construct a polygon from a non-transformed rectangle.

pub fn from_transformed_rect( rect: Rect<f64>, transform: Transform3D<f64>, anchor: A, ) -> Option<Self>

Construct a polygon from a rectangle with 3D transform.

pub fn from_transformed_rect_with_inverse( rect: Rect<f64>, transform: &Transform3D<f64>, inv_transform: &Transform3D<f64>, anchor: A, ) -> Option<Self>

Construct a polygon from a rectangle with an invertible 3D transform.

pub fn untransform_point(&self, point: Point3D<f64>) -> Point2D<f64>

Bring a point into the local coordinate space, returning the 2D normalized coordinates.

pub fn transform(&self, transform: &Transform3D<f64>) -> Option<Polygon<A>>

Transform a polygon by an affine transform (preserving straight lines).

pub fn is_valid(&self) -> bool

Check if all the points are indeed placed on the plane defined by the normal and offset, and the winding order is consistent.

pub fn is_empty(&self) -> bool

Check if the polygon doesn’t contain any space. This may happen after a sequence of splits, and such polygons should be discarded.

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

Check if this polygon contains another one.

pub fn project_on(&self, vector: &Vector3D<f64>) -> LineProjection

Project this polygon onto a 3D vector, returning a line projection. Note: we can think of it as a projection to a ray placed at the origin.

pub fn intersect_plane(&self, other: &Plane) -> Intersection<Line>

Compute the line of intersection with an infinite plane.

pub fn intersect(&self, other: &Self) -> Intersection<Line>

Compute the line of intersection with another polygon.

fn split_impl( &mut self, first: (usize, Point3D<f64>), second: (usize, Point3D<f64>), ) -> (Option<Self>, Option<Self>)

pub fn split(&mut self, line: &Line) -> (Option<Self>, Option<Self>)

👎Deprecated: Use split_with_normal instead

Split the polygon along the specified Line. Will do nothing if the line doesn’t belong to the polygon plane.

pub fn split_with_normal( &mut self, line: &Line, normal: &Vector3D<f64>, ) -> (Option<Self>, Option<Self>)

Split the polygon along the specified Line, with a normal to the split line provided. This is useful when called by the plane splitter, since the other plane’s normal forms the side direction here, and figuring out the actual line of split isn’t needed. Will do nothing if the line doesn’t belong to the polygon plane.

pub fn cut( &self, poly: &Self, front: &mut SmallVec<[Polygon<A>; 2]>, back: &mut SmallVec<[Polygon<A>; 2]>, ) -> PlaneCut

Cut a polygon with another one.

Write the resulting polygons in front and back if the polygon needs to be split.

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

Returns whether both polygon’s planes are parallel.

Trait Implementations

impl<A: Copy> Clone for Polygon<A>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug> Debug for Polygon<A>

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

Formats the value using the given formatter.

impl<A: PartialEq> PartialEq for Polygon<A>

fn eq(&self, other: &Polygon<A>) -> 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<A> StructuralPartialEq for Polygon<A>