Struct Polygon2

pub struct Polygon2 {
    pub vertices: Vec<DVec2>,
}

A simple polygon in the XY-plane, without holes.

The closing edge is implicit, so the last vertex joins the first. Repeating the first vertex at the end creates a zero-length edge rather than closing the ring, which is a common source of degenerate imported data.

Simplicity – no self-intersection – is assumed and not checked: that is a tolerance-dependent judgement, and the types here hold data rather than enforce policy. A polygon set with holes is a different concept; see the planar overlay crate’s region type for that.

Fields

vertices: Vec<DVec2>

Boundary vertices in order. The closing edge is implicit.

Implementations

impl Polygon2

pub const fn new(vertices: Vec<DVec2>) -> Polygon2

Construct from boundary vertices in order.

pub fn len(&self) -> usize

Number of boundary vertices, which equals the number of edges.

pub fn is_empty(&self) -> bool

Whether the polygon has no vertices.

pub fn signed_area2(&self) -> f64

Twice the signed area by the shoelace formula.

Summed about the first vertex rather than the origin. The two agree mathematically, but a polygon in georeferenced coordinates sits far from the origin, where the terms are large and nearly cancel; rebasing keeps the terms the size of the polygon instead of the size of the coordinate system.

Fewer than three vertices enclose nothing and give zero.

pub fn signed_area(&self) -> f64

Signed area: positive counter-clockwise, negative clockwise.

pub fn area(&self) -> f64

Area, always non-negative.

pub fn is_counter_clockwise(&self) -> bool

Whether the vertex order is counter-clockwise.

A degenerate polygon has no winding; this reports false for it rather than inventing one.

pub fn bounds(&self) -> Aabb2

Axis-aligned bounds of the boundary vertices.

Trait Implementations

impl Clone for Polygon2

fn clone(&self) -> Polygon2

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Polygon2

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

Formats the value using the given formatter.

impl From<&Ring> for Polygon2

fn from(ring: &Ring) -> Polygon2

Converts to this type from the input type.

impl From<Polygon2> for Ring

A Ring is a closed boundary and so is Polygon2; converting between them moves the points and nothing else.

The two exist separately because they are reached from different places: Polygon2 is a foundation value type usable without this crate, while Ring is what the overlay consumes. Making them the same type would drag the planar boolean vocabulary into axiolid-core.

fn from(polygon: Polygon2) -> Ring

Converts to this type from the input type.

impl From<Ring> for Polygon2

fn from(ring: Ring) -> Polygon2

Converts to this type from the input type.

impl PartialEq for Polygon2

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