#@totto2727/geo/geo/2d/type
totto2727/geo/geo/2d/type owns the concrete two-dimensional geometry values consumed by totto2727/geo/geo/2d, including points, lines, polygons, collections, rectangles, triangles, and the Geometry sum type.
#Usage
Normalize clockwise survey vertices before handing a closed boundary to a polygon consumer:
///|
test "normalize a triangle boundary" {
let triangle = Triangle::ccw(
Coord(0.0, 0.0),
Coord(0.0, 6.0),
Coord(4.0, 0.0),
)
let boundary = triangle.to_polygon().exterior().coords()
@test.assert_eq(boundary, [
Coord(0.0, 0.0),
Coord(4.0, 0.0),
Coord(0.0, 6.0),
Coord(0.0, 0.0),
])
}#API
This README was generated from the share-artifact skill and README template.
HasLength
pub(open) trait HasLength {
fn length(Self) -> Int
}Collection-style cardinality (number of components or coords). Mirrors
Vec::len() / Array::length(). Distinct from HasEuclideanLength (the
physical length of a curve, defined in geo/2d/traits.mbt).
IsClosed
pub(open) trait IsClosed {
fn is_closed(Self) -> Bool
}Anything that can be a closed ring (first and last coord equal).
IsEmpty
pub(open) trait IsEmpty {
fn is_empty(Self) -> Bool
}Anything that can be empty (zero coords / zero components). Mirrors the
is_empty() inherent method present on every collection-shaped type.
MismatchedGeometry
Raised by Geometry::try_into_* when the variant does not match the
expected one. Carries both the expected variant name and the actual
variant name observed, matching the upstream Rust MismatchedGeometry
error.
Coord
A lightweight struct used to store coordinates on the 2-dimensional Cartesian plane.
Unlike Point (which in the future may contain additional information such as
an envelope, a precision model, and spatial reference system information), a
Coord only contains ordinate values and accessor methods.
This type implements the vector-space operations: add, sub, neg, zero,
mul, div (the last two by scalar), and dot.
Semantics
This type does not represent any geospatial primitive, but is used in their
definitions. The only requirement is that the coordinates it contains are
valid numbers (e.g. not NaN).
Coord::Coord
Creates a new Coord from the given x and y ordinate values.
Coord::cross
Returns the 2D cross / wedge product (signed area of the parallelogram).
Coord::div
Divides this coordinate component-wise by a scalar.
MoonBit's trait system cannot express the Rust Div<T> overload across
different types, so we expose this as a regular method instead.
Coord::dot
Returns the dot product of this coordinate with another.
Coord::from_array
Builds a Coord from a 2-element array [x, y].
Aborts when the input length is not 2.
Coord::from_tuple
Builds a Coord from a (x, y) tuple.
Coord::is_zero
Returns whether this Coord is at the origin.
Coord::mul
Multiplies this coordinate component-wise by a scalar.
MoonBit's trait system cannot express the Rust Mul<T> overload across
different types, so we expose this as a regular method instead.
Coord::to_array
Builds a 2-element array [x, y].
Coord::x_y
Returns a tuple (x, y) of this coordinate's components.
Geometry
pub(all) enum Geometry {
Point(Point)
Line(Line)
LineString(LineString)
Polygon(Polygon)
MultiPoint(MultiPoint)
MultiLineString(MultiLineString)
MultiPolygon(MultiPolygon)
GeometryCollection(GeometryCollection)
Rect(Rect)
Triangle(Triangle)
} derive(Eq, Debug)An enumeration of all geometry types except Coord (which is not itself a
"geometry" in the OGC sense).
Geometry::try_into_geometry_collection
fn Geometry::try_into_geometry_collection(self : Geometry) -> GeometryCollection raise MismatchedGeometryUnlike the Rust upstream — which excludes GeometryCollection from its
try_from_geometry_impl! macro to avoid clashing with a deprecated
From<single_geom> for GeometryCollection impl — the port has no such
deprecated conversion, so the symmetry is preserved here.
Geometry::try_into_line
Geometry::try_into_line_string
Geometry::try_into_multi_line_string
fn Geometry::try_into_multi_line_string(self : Geometry) -> MultiLineString raise MismatchedGeometryGeometry::try_into_multi_point
Geometry::try_into_multi_polygon
Geometry::try_into_point
If self is the Point variant, returns the inner Point. Otherwise
raises MismatchedGeometry with the expected / actual variant names.
Mirrors Rust upstream TryFrom<Geometry> for Point (g.try_into()).
Geometry::try_into_polygon
Geometry::try_into_rect
Geometry::try_into_triangle
GeometryCollection
A collection of Geometry values. Useful for representing heterogeneous
collections (the GeoJSON GeometryCollection).
impl HasLength for GeometryCollectionimpl IsEmpty for GeometryCollectionGeometryCollection::GeometryCollection
GeometryCollection::empty
Creates an empty GeometryCollection. Mirrors Rust
geo_types::GeometryCollection::empty.
GeometryCollection::geometries
GeometryCollection::is_empty
Line
A line segment made up of exactly two Coords.
Semantics
The interior and boundary are defined as with a LineString containing
only the two end points.
Line::Line
Creates a new line segment from two coordinates.
Line::delta
Calculates the difference in coordinates (Δx, Δy).
Line::determinant
Calculates the determinant start.x * end.y - start.y * end.x.
Line::from_tuples
Creates a new line segment from (x, y) tuples.
Line::reverse
Returns a new Line with start and end swapped — the same segment
traversed in the opposite direction.
Independent from Rust upstream (geo_types::Line does not expose a
dedicated reverse method); added here as a focused helper.
Note for LineString::rev_lines: that method intentionally does NOT
build forward lines first and then reverse them — it constructs each
segment with swapped endpoints directly inside its loop. This avoids
an avoidable round trip through Line::reverse.
LineString
An ordered collection of two or more Coords, representing a path between
locations.
Semantics
- 0 or 1 points: empty interior and boundary, treated as invalid in many APIs.
- 2 or more points: interior is the union of the line segments; boundary is the start and end coordinate (open) or empty (closed, i.e. start == end).
impl HasLength for LineStringReturns the number of coordinates in the line string.
impl IsClosed for LineStringReturns whether the line string is closed: the first and last coordinates
are equal. An empty line string is not closed.
impl IsEmpty for LineStringReturns whether the line string has no coordinates.
LineString::LineString
Creates a new LineString from an array of Coords.
LineString::closed
Returns a closed copy of this line string. If self is already closed
(or empty — there is no start coord to repeat), self is returned
directly without allocating a new value. Otherwise a new LineString
is built via the array-spread literal [..self.coords, self.coords[0]],
pre-sized to its final length in a single allocation.
The original self is never mutated. This is the immutable
counterpart of Rust upstream LineString::close(&mut self).
LineString::coords
Returns the underlying coordinate array.
LineString::empty
Creates an empty LineString (no coordinates). Equivalent to
LineString::LineString([]) and mirrors Rust geo_types::LineString::empty.
LineString::from_tuples
Creates a new LineString from (x, y) tuples.
LineString::lines
Returns the line segments composing this line string, eagerly. Each
segment connects two consecutive coords with the same orientation as
upstream Rust geo_types::LineString::lines. For a pipeline that
already consumes results as an iterator, prefer lines_iter to skip
the intermediate Array allocation.
An empty line string and a single-coordinate line string yield an empty
segment array.
LineString::lines_iter
Returns a lazy iterator yielding the line segments composing this line
string. Independent of lines() — does not allocate an intermediate
Array; each Line is constructed on demand. Use this when chaining
iterator combinators (take, filter, …) so allocation is paid only
for what is consumed.
An empty line string and a single-coordinate line string yield an
iterator with no elements.
LineString::points
Returns each coordinate wrapped as a Point, eagerly. Equivalent to
coords().map(Point::from_coord) but more readable at call sites and
matches the Rust geo_types::LineString::points API. For pipelines that
already process the result as an iterator, prefer points_iter to skip
the intermediate array allocation.
LineString::points_iter
Returns a lazy iterator yielding each coordinate wrapped as a Point.
Mirrors Rust geo_types::LineString::points_iter. Prefer this over
points when the consumer is itself iterator-based; the conversion
happens on demand without allocating a new array.
LineString::rev_lines
Returns the line segments in reverse order, with each segment's
start / end swapped, eagerly. Mirrors Rust
geo_types::LineString::rev_lines.
For a line string [a, b, c, d], lines() yields [a→b, b→c, c→d]
while rev_lines() yields [d→c, c→b, b→a].
An empty line string and a single-coordinate line string yield an empty
segment array.
LineString::rev_lines_iter
Lazy iterator version of rev_lines(). Independent implementation; does
not allocate an intermediate Array. Yields segments in reverse order
with each Line's start / end swapped, just like the eager variant.
An empty line string and a single-coordinate line string yield an
iterator with no elements.
MultiLineString
A collection of LineStrings.
impl HasLength for MultiLineStringimpl IsClosed for MultiLineStringReturns whether all line strings inside are closed. An empty multi line
string is considered closed.
impl IsEmpty for MultiLineStringMultiLineString::MultiLineString
MultiLineString::empty
Creates an empty MultiLineString. Mirrors Rust
geo_types::MultiLineString::empty.
MultiLineString::line_strings
MultiPoint
A collection of Points. Can be created from a list of points, or from
tuples / coords via the helper constructors.
impl HasLength for MultiPointimpl IsEmpty for MultiPointMultiPoint::empty
Creates an empty MultiPoint. Mirrors Rust geo_types::MultiPoint::empty.
MultiPoint::from_coord
Creates a MultiPoint containing a single Coord.
MultiPoint::from_coords
Creates a MultiPoint from an Array[Coord].
MultiPoint::from_point
Creates a MultiPoint containing a single Point.
MultiPoint::from_tuples
MultiPolygon
A collection of Polygons.
impl HasLength for MultiPolygonimpl IsEmpty for MultiPolygonMultiPolygon::MultiPolygon
MultiPolygon::empty
Creates an empty MultiPolygon. Mirrors Rust
geo_types::MultiPolygon::empty.
Point
A single point in 2D space.
Semantics
The interior of the point is itself (a singleton set), and its boundary
is empty. A point is valid if and only if its Coord is valid.
Point::Point
Canonical constructor: creates a new point from x and y.
Point::cross_prod
Returns the cross product of three points.
A positive value implies self → b → c is counter-clockwise; a negative
value implies clockwise; zero implies collinear. This function is not
robust against floating-point error — see src/robust/orient2d.mbt.
Point::div
Divides the point's coordinates by a scalar.
Point::dot
Returns the dot product of the two points: x1 * x2 + y1 * y2.
Point::from_coord
Creates a point from a Coord. Goes through the canonical constructor.
Point::from_tuple
Creates a point from a (x, y) tuple. Goes through the canonical
constructor.
Point::mul
Multiplies the point's coordinates by a scalar.
Point::with_x
Returns a new point with x set, the original y preserved.
Point::with_y
Returns a new point with y set, the original x preserved.
Polygon
A bounded two-dimensional area.
A Polygon's outer boundary (exterior) is represented by a LineString
that is automatically closed. It may contain zero or more interiors
representing holes (rings within the polygon).
Validity
Per the OGC SFA, a valid Polygon requires:
- Each ring is closed (first coord == last coord).
- Rings have at least 4 coords (3 unique).
- Rings do not self-cross.
- The exterior contains all interior rings, and interiors do not overlap.
This module does not enforce validity; use the validation algorithm
(planned for ms-15) for explicit checks.
Polygon::Polygon
Creates a new Polygon.
The exterior and each interior ring are closed (auto-closure matches the
Rust geo-types semantics). The closure is immutable: each input
LineString is replaced via LineString::closed, which returns either
self (if already closed) or a fresh closed copy. The caller's
references are never mutated as a side effect of constructing a
Polygon.
Polygon::empty
Creates an empty Polygon (exterior ring has no coordinates, no holes).
Mirrors Rust geo_types::Polygon::empty.
Polygon::interiors
Returns the array of interior rings (holes).
Polygon::num_interiors
Returns the number of interior rings (holes).
Polygon::num_rings
Returns the total number of rings: exterior (1) plus interiors. Mirrors
Rust upstream Polygon::num_rings.
Polygon::pushed_interior
Returns a new Polygon whose interiors are the original interiors plus
new_interior appended at the end. The original Polygon is not modified
(immutable counterpart of Rust upstream Polygon::interiors_push, which
mutates &mut self).
new_interior itself is left untouched: LineString::closed returns
self when already closed (no allocation), or a freshly closed copy
otherwise — never mutating the caller's value.
The destination interiors array is built with the array-spread literal
[..self.interiors, new_interior.closed()], which pre-sizes to the
final length in a single allocation.
Rect
An axis-aligned bounded 2D rectangle whose area is defined by minimum and
maximum Coords.
The constructor normalises the input so that min.x <= max.x and
min.y <= max.y.
Rect::Rect
Creates a new Rect from two coordinates. Order is not significant — the
resulting rectangle's min/max are the component-wise min/max of the
inputs.
Rect::area
Returns the rectangle's signed area: width * height.
Rect::split_x
Splits the rectangle into two equal-width halves along the X-axis at the
midpoint. Returns (left, right) where left.max.x == right.min.x is
the shared mid-X. The shared mid coordinate is computed once and reused
in both halves so floating-point round-off is bit-identical on the seam.
Mirrors Rust upstream geo_types::Rect::split_x (which returns a
[Rect<T>; 2] fixed-length array; a tuple is the closest MoonBit
equivalent that preserves the "exactly two" type-level guarantee).
Rect::split_y
Splits the rectangle into two equal-height halves along the Y-axis at
the midpoint. Returns (bottom, top) where bottom.max.y == top.min.y
is the shared mid-Y. The shared mid coordinate is computed once and
reused in both halves so floating-point round-off is bit-identical on
the seam.
Mirrors Rust upstream geo_types::Rect::split_y.
Rect::to_lines
Returns the four edges of the rectangle as Line segments, walked CCW
starting from the min corner: bl→br, br→tr, tr→tl, tl→bl.
Mirrors Triangle::to_lines for symmetry and matches the upstream
geo_types API surface (the algorithm-layer helper
lines_of_rect is now a thin wrapper around this method).
Rect::to_polygon
Converts the rectangle into a Polygon with the four corners (CCW from
min).
Triangle
A bounded 2D area whose three vertices are defined by Coords.
Triangle::Triangle
Stores vertices as-given (no winding normalisation). Semantically equivalent
to upstream Triangle::unchecked_winding.
Triangle::ccw
Creates a Triangle with counter-clockwise (CCW) winding.
Winding is determined by the signed double-area cross product
(v1 − v0) × (v2 − v0) (non-robust, matching geo-types
Triangle::new). If the input vertices are clockwise, v1 and v2
are swapped to produce CCW winding. Collinear input is stored as-is.
Triangle::to_lines
Returns the three line segments that make up this triangle in (v0->v1,v1->v2, v2->v0) order.
Triangle::to_polygon
Converts to a closed Polygon representation.
Install
Download zipMoonBit port of georust/geo: 2D planar geospatial primitives and algorithms
gisgeogeographygeospatial
MIT
Updated 2 months ago
61 downloads