Struct Region

pub struct Region { /* private fields */ }

A validated planar region: a normalised set of polygons with holes.

Construction validates; operations preserve validity. Ring ordering is canonical (outer counter-clockwise, holes clockwise, each rotated to its lexicographically smallest vertex) and polygons are sorted, so equal regions compare equal regardless of how they were built.

Implementations

impl Region

pub fn minkowski_sum( &self, convex_ring: &Ring, tolerance: Tolerance, ) -> Result<Self, MinkowskiError>

The Minkowski sum with a convex polygon convex: every point of the region moved by every point of the polygon.

Decided exactly (ADR 0070), with each vertex sum a + k rounded once to f64 and output vertices rounded once.

Errors

MinkowskiError::NotConvex for a polygon that is not convex; the sum with a non-convex one is not built yet (#145).

pub fn minkowski_erosion( &self, convex_ring: &Ring, tolerance: Tolerance, ) -> Result<Self, MinkowskiError>

The Minkowski erosion by a convex polygon: the points x for which the polygon moved by x lies within the region.

Errors

As Self::minkowski_sum.

pub fn dilate_inner( &self, radius: f64, tolerance: Tolerance, ) -> Result<Self, OverlayError>

Dilation by a disc of radius, contained in the exact one: the sum with an inscribed polygon, drawn in by a margin.

Errors

OverlayError::InvalidOffsetDistance for a radius that is not finite and nonnegative, and overlay refusals.

pub fn dilate_outer( &self, radius: f64, tolerance: Tolerance, ) -> Result<Self, OverlayError>

Dilation by a disc of radius, containing the exact one: the sum with a circumscribed polygon, pushed out by a margin.

Errors

As Self::dilate_inner.

pub fn erode_inner( &self, radius: f64, tolerance: Tolerance, ) -> Result<Self, OverlayError>

Erosion by a disc of radius, contained in the exact one: eroded by a circumscribed polygon, pushed out by a margin. A route found in it proves reachability.

Errors

As Self::dilate_inner.

pub fn erode_outer( &self, radius: f64, tolerance: Tolerance, ) -> Result<Self, OverlayError>

Erosion by a disc of radius, containing the exact one: eroded by an inscribed polygon, drawn in by a margin. No route in it proves unreachability.

Errors

As Self::dilate_inner.

impl Region

pub fn empty() -> Self

The empty region. Not a failure: the identity for union.

pub fn new( polygons: Vec<Polygon>, tolerance: Tolerance, ) -> Result<Self, OverlayError>

Build a region from polygons, validating every ring.

Validation is the same used by crate::overlay, so the two cannot disagree about what a well-formed polygon is.

pub const fn bound(&self) -> Option<MorphologyBound>

For a result of Self::dilate_inner, Self::dilate_outer, Self::erode_inner or Self::erode_outer: which side of the exact disc morphology it lies on and how far from it it can be. None for every other region, including Self::dilate and Self::erode, whose side is not stated.

pub fn polygons(&self) -> &[Polygon]

The region’s polygons, in canonical order.

pub const fn evidence(&self) -> RegionEvidence

What the producing operation did.

pub fn is_empty(&self) -> bool

True when the region covers no area.

pub fn area(&self) -> f64

Total covered area. Holes subtract.

pub fn component_count(&self) -> usize

Number of disjoint connected components.

One polygon is one component: the overlay backend already resolves touching and overlapping input into disjoint output polygons, so counting them is the component count rather than an approximation of it.

pub fn boundary_rings(&self) -> Vec<Ring>

Every boundary ring, outer boundaries first then holes.

pub fn union( &self, other: &Self, tolerance: Tolerance, ) -> Result<Self, OverlayError>

Set union.

pub fn intersection( &self, other: &Self, tolerance: Tolerance, ) -> Result<Self, OverlayError>

Set intersection.

pub fn difference( &self, other: &Self, tolerance: Tolerance, ) -> Result<Self, OverlayError>

Set difference: this region minus other.

pub fn dilate( &self, radius: f64, tolerance: Tolerance, ) -> Result<Self, OverlayError>

Dilate by radius: the Minkowski sum with a disc, approximated by round joins on an unstated side of the exact result. Where a verdict must be proven, use Self::dilate_inner or Self::dilate_outer.

This is the disc-expansion form used for clearance envelopes. A zero radius is the identity.

pub fn erode( &self, radius: f64, tolerance: Tolerance, ) -> Result<Self, OverlayError>

Erode by radius: the Minkowski erosion by a disc, approximated on an unstated side of the exact result. Where a verdict must be proven, use Self::erode_inner (a route found proves reachability) or Self::erode_outer (no route proves unreachability).

A region thinner than 2 * radius anywhere is cut there, which is how a corridor narrower than a body radius becomes impassable. If that removes everything the result is empty and RegionEvidence::emptied is set.

pub fn translate(&self, offset: Vec2) -> Result<Self, OverlayError>

Translate by offset. Rigid: area and component count are preserved.

pub fn sweep( &self, direction: Vec2, tolerance: Tolerance, ) -> Result<Self, OverlayError>

Sweep along direction: the union of the region with every translate of itself along the vector.

Equivalent to the Minkowski sum with the segment [0, direction]. Built as the union of the region and its translate plus the hull swept between them, which for a polygon set is exactly the union of the two end positions with the stroke of each boundary edge; using the union of endpoints alone would miss the swept middle whenever the translation exceeds the region’s own extent.

impl Region

pub fn visibility_polygon( &self, viewpoint: Point2, tolerance: Tolerance, ) -> Result<Self, VisibilityError>

The part of the region in sight of viewpoint: every point the straight segment from the viewpoint reaches without leaving the region. Walls and holes cast shadows.

Errors

VisibilityError::NotInside for a viewpoint on the boundary or outside.

Trait Implementations

impl Clone for Region

fn clone(&self) -> Region

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Region

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

Formats the value using the given formatter.

impl Default for Region

fn default() -> Region

Returns the “default value” for a type.

impl PartialEq for Region

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