Crate axiolid_overlay

Expand description

Validated, deterministic planar boolean overlay and offset.

A straight ring’s orientation and its ZeroArea check are exact signs of its area taken as a fan of triangles from its first vertex (#274): a shoelace over the coordinates as given rounds at the size of the coordinates squared, which at georeferenced plan positions swamps the area of a small ring. Areas reported as values are summed the same way, so their rounding scales with the ring’s extent, not its position. scripts/probe_ring_orientation_mutants.py lists the faults the tests in tests/far_from_origin.rs must catch.

Whether two boundary edges meet, the SelfIntersection rule, is exact too, and validation and settling share it (contact, #272): an end on the other edge within the tolerance, or a proper crossing with each segment’s ends strictly on both sides of the other’s line. So an operation’s settled output is a valid operand wherever it lies.

A degenerate input ring refuses the operation by default. Asked explicitly, overlay_with and union_soup_with leave out a ring that is too short, has a repeated vertex, or has zero area under the exact ZeroArea rule, and report each one with its area (degenerate, #256); a self-intersecting ring is never dropped. scripts/probe_degenerate_drop_mutants.py lists the faults the tests in tests/degenerate_drop.rs must catch.

A Region’s rings lie apart and nested: every hole inside its own outer ring and in no other of its holes, and no point in two polygons (nesting, #448). Region::new decides that exactly, on one arrangement of all the rings, and refuses by name; rings may touch. Operands of overlay and union_soup are not held to it: their rings may overlap, read by the fill rule. scripts/probe_region_nesting_mutants.py lists the faults the tests in tests/region_nesting.rs must catch.

Structs§

ArcArrangement: The plane cut by several simple arc rings.
ArcCheckOptions: Options of check_arc_polygon_with.
ArcOverlayEvidence: Evidence that the arc path did what it claims.
ArcOverlayResult: The result of an arc-aware boolean.
ArcPolygon: An arc-aware region: one outer boundary and its holes.
ArcPolygonCheck: The result of check_arc_polygon.
ArcRing: A closed boundary whose edges may be arcs.
ArcRingContact: A point where two different rings meet.
ArcVertex: One boundary vertex and the bulge of the edge leaving it.
ArrangementEdge: One piece of the subdivision: part of one or more input edges, running between two vertices with no other ring’s boundary crossing it.
ArrangementEdgeUse: One use of a piece in a region boundary.
ArrangementRegion: A region of the subdivision: an outer boundary and its holes.
Bridge: A segment added across a gap narrower than the closing width.
CircleEvidence: Which points determine the circle and how exact the output is.
DroppedRing: One input ring an operation left out, and why.
EdgeSource: Where a piece of the subdivision came from.
EnclosingCircle: A circle by its centre and radius.
ExactPoint2: A planar point with exact rational coordinates.
FreeFace: A bounded free face.
FreeFaceEvidence: What the operation did besides the faces.
FreeFaces: The bounded free faces of a FreeSpaceInput (module docs).
FreeRing: A closed boundary of a free face.
FreeSpaceInput: What blocks free space: obstacle polygons and open segments.
Incidence: One segment through a reported point.
IntersectionPoint: A point where two or more segments meet.
MinimumCircle: The circle and its evidence.
MinimumRectangle: The rectangle and its evidence.
MorphologyBound: How a disc morphology’s result relates to the exact one.
OffsetEvidence: What an offset actually did.
OffsetResult: Result of an offset.
OrientedRectangle: A rectangle by its centre, two unit axes and the half extents along them.
OverlayEvidence
OverlayInput
OverlayOptions: Options for crate::overlay_with and crate::union_soup_with.
OverlayResult
Polygon
RectangleEvidence: What the construction did and how exact its output is.
Region: A validated planar region: a normalised set of polygons with holes, whose holes lie apart inside their outer rings and whose polygons do not overlap (#448).
RegionEvidence: What an operation did to produce a region.
ReportedOverlay: An overlay’s result and the rings it dropped (#256).
ReportedUnion: A soup union’s polygons and the rings it dropped (#256).
Ring
SegmentIntersections: The result of segment_intersections.
SegmentOverlap: A collinear piece shared by two or more segments.
SweepEvidence: What the sweep did, for measurement.

Enums§

ArcPolygonDefect: Why an ArcPolygon does not bound a valid region.
ArcRingRef: A ring of an ArcPolygon: the outer boundary or hole k.
BarrierDefect: Why a barrier is refused.
BoundSide: Which side of the exact disc morphology a region lies on.
CapStyle: How an open stroke terminates.
CircleError: Why no circle was built.
DegenerateRings: What an operation does with a degenerate input ring (#256).
DropReason: Why a ring was dropped.
FaceLocation: Where a point lies relative to a FreeFaces.
FillRule
FreeFacesError: Why no free faces were built.
JoinStyle: How the outline turns a corner.
MinkowskiError: Why a Minkowski operation was refused.
MorphologyMode: How the disc morphology (Region::erode_inner_with and its siblings) is computed (#330).
OverlayError
OverlayOperand: Which operand a dropped ring came from.
OverlayOperation
OverlayRefusal: Why a budgeted overlay gave no result.
PieceSource: The input an edge of a free face lies on.
RectangleError: Why no rectangle was built.
RingRole: Which ring of its polygon a dropped ring was.
SegmentLocation: Where on a segment an incidence lies, in the segment’s own direction (Start is the segment’s first point as given).
SegmentSweepError: Why the sweep refused its input.
VisibilityError: Why no visibility polygon was built.

Functions§

arc_edge_radius: Arc radius implied by an edge, or None for a straight edge.
arc_overlay: Boolean of two arc-capable regions.
arc_ring_area: Signed area enclosed by an arc ring.
check_arc_polygon: Exact validity of an arc polygon: rings simple, holes nested.
check_arc_polygon_with: check_arc_polygon with options (#388): the default options are exactly check_arc_polygon; ArcCheckOptions::with_clearance adds the clearance defects.
free_faces: The bounded free faces of input, closing gaps narrower than gap.
free_faces_within: free_faces with execution options: the memory budget (ADR 0088) and the cancellation token; the tolerance is execution.tolerance().
minimum_area_rectangle: The minimum-area rectangle enclosing points.
minimum_enclosing_circle: The minimum circle enclosing points.
offset_polygons: Offset closed polygons by distance.
overlay: Performs a neutral planar overlay. Output ordering is deterministic: polygons sort by outer-ring lexicographic start, rings are canonicalized CCW/CW.
overlay_with: overlay with explicit options; the default options make it overlay exactly.
overlay_within: overlay_with under the caller’s execution options (#338): the tolerance is ExecutionOptions::tolerance, and with ExecutionOptions::with_memory_budget the subdivision is refused with OverlayRefusal::BudgetExceeded before it would hold more than the budget. Without a budget it is overlay_with exactly, its refusals wrapped in OverlayRefusal::Invalid. An admitted call gives the same result as overlay_with, bit for bit. No other option is read: a cancellation token is not polled.
polygon_area: Net area of a polygon: outer boundary minus its holes.
reverse_arc_ring: Reverse a ring’s orientation, preserving its geometry.
ring_area: Absolute area of a ring.
segment_intersections: Every intersection among segments, exactly, by a Bentley–Ottmann sweep in O((n + k) log n) time for k reported incidences.
stroke_polyline: Sweep an open polyline into a closed region of the given width.
total_area: Total net area across a set of polygons.
union_soup: Union a set of individually-valid rings that may overlap each other.
union_soup_with: union_soup with explicit options; the default options make it union_soup exactly.
union_soup_within: union_soup_with under the caller’s execution options (#338), as overlay_within is overlay_with: the tolerance is ExecutionOptions::tolerance, and a memory budget refuses the subdivision with OverlayRefusal::BudgetExceeded before it would hold more. Without a budget it is union_soup_with exactly.
validate_arc_ring: Validate an arc ring against the same contract as crate::Ring, plus the arc-specific degeneracies.