geo

You can define geometries using macros like polygon! and line_string! and perform operations like convex_hull() on them. The crate supports various algorithms including:

• Topological Relationships: DE-9IM support, containment, and intersection.
• Affine Operations: Scale, rotate, skew, and translate.
• Boolean Operations: Clip, union, difference, intersection, and xor.
• Buffer/Offset: Buffer and offset operations on geometries.
• Geometry Repair: Repairing invalid polygons/multipolygons using constrained Delaunay triangulation.
• Clustering: DBSCAN and k-means.
• Distance/Length: Euclidean, spherical, haversine, and other non-planar calculations.
• Projections: Coordinate reference system conversion via PROJ.
• IO: Integration with geojson and geozero crates.

// primitives
use geo::{line_string, polygon};

// algorithms
use geo::ConvexHull;

// An L shape
let poly = polygon![ 
    (x: 0.0, y: 0.0),
    (x: 4.0, y: 0.0),
    (x: 4.0, y: 1.0),
    (x: 1.0, y: 1.0),
    (x: 1.0, y: 4.0),
    (x: 0.0, y: 4.0),
    (x: 0.0, y: 0.0),
];

// Calculate the polygon's convex hull
let hull = poly.convex_hull();

assert_eq!(
    hull.exterior(),
    &line_string![
        (x: 4.0, y: 0.0),
        (x: 4.0, y: 1.0),
        (x: 1.0, y: 4.0),
        (x: 0.0, y: 4.0),
        (x: 0.0, y: 0.0),
        (x: 4.0, y: 0.0),
    ]
);

The geo crate provides planar geospatial geometries and algorithms. It is designed to adhere to the OpenGIS Simple Feature Access (OGC-SFA) standards, making it interoperable with other implementations like JTS and GEOS.

Key capabilities include:

• Topological Relationships: DE-9IM support, containment, and intersection.
• Boolean Operations: Clip, union, difference, intersection, and XOR on geometries.
• Affine Operations: Scale, rotate, skew, and translate.
• Measurements: Euclidean, Haversine, Geodesic, and Rhumb line calculations for distance and length.
• Clustering: DBSCAN and k-means.
• Simplification: Ramer–Douglas–Peucker and Visvalingam-Whyatt algorithms.
• Spatial Indexing: Support for R*-tree (via rstar) and BallTree for point-only data.
• Coordinate Conversion: Support for projecting and converting between coordinate reference systems using PROJ.

The Centroid trait provides a method to calculate the arithmetic mean position of all points in a shape. The centroid is the point where a cutout of the shape could be perfectly balanced.

Important Behaviors:

• Non-convex objects: The centroid may lie outside the object itself.
• Dimensionality in Collections: When calculating the centroid of a GeometryCollection or Multi* type, the library tracks dimensionality. Higher-dimensional elements (e.g., a 2D Polygon) will 'clobber' or take precedence over lower-dimensional elements (e.g., a 0D Point) in the calculation. For example, in a GeometryCollection, a 2D element's centroid will determine the result, effectively ignoring 0D or 1D elements.
• Empty Geometries: For types like LineString, MultiLineString, Polygon, MultiPolygon, MultiPoint, and GeometryCollection, the centroid() method returns an Option<Point<T>>. If the geometry is empty or cannot have a centroid, it returns None.

use geo::Centroid;
use geo::{polygon, point};

// rhombus shaped polygon
let polygon = polygon![
    (x: -2., y: 1.),
    (x: 1., y: 3.),
    (x: 4., y: 1.),
    (x: 1., y: -1.),
    (x: -2., y: 1.),
];

assert_eq!(
    Some(point!(x: 1., y: 1.)),
    polygon.centroid(),
);

An AffineTransform<T> represents a 2D affine transformation matrix in row-major order:

[[a, b, xoff],
 [d, e, yoff],
 [0, 0, 1]]

Transformations can be efficiently composed into a single matrix before being applied to geometries. This avoids the overhead of multiple passes over the coordinate data.

Construction vs. Mutation

• Construction (Present Tense): Methods like scale(), translate(), rotate(), and skew() create a new transform.
• Mutation (Past Participle): Methods like scaled(), translated(), rotated(), and skewed() add the operation to the existing transform (cumulative).

Key Methods

• identity(): Returns an identity matrix (no-op).
• compose(&self, other: &Self) -> Self: Composes two transforms into one.
• compose_many(&self, transforms: &[Self]) -> Self: Composes an arbitrary number of transforms.
• inverse(&self) -> Option<Self>: Returns the inverse of the transform if it is invertible.
• is_identity(&self) -> bool: Checks if the transform is the identity matrix.

use geo::AffineTransform;

// Compose multiple transforms
let mut transform = AffineTransform::identity();
let transform1 = AffineTransform::translate(1.0, 2.0);
let transform2 = AffineTransform::translate(-1.0, -2.0);
let transforms = vec![transform1, transform2];

let outcome = transform.compose_many(&transforms);
assert!(outcome.is_identity());

The geo-types library provides standard geometric primitives following the OpenGIS Simple Feature Access (OGC-SFA) standards. These types are designed for interoperability with other geospatial implementations like JTS and GEOS.

Available geometries include:

• Point: A single point represented by one Coord.
• MultiPoint: A collection of Points.
• Line: A line segment represented by two Coords.
• LineString: A series of contiguous line segments represented by two or more Coords.
• MultiLineString: A collection of LineStrings.
• Polygon: A bounded area represented by one LineString exterior ring and zero or more LineString interior rings.
• MultiPolygon: A collection of Polygons.
• Rect: An axis-aligned bounded rectangle represented by minimum and maximum Coords.
• Triangle: A bounded area represented by three Coord vertices.
• GeometryCollection: A collection of Geometrys.
• Geometry: An enumeration of all the above geometry types.