Merge pull request #1433 from cookiedan42/covers-base

Covers base

Author: urschrei

geo-benches/Cargo.toml

@@ -55,6 +55,11 @@ name = "contains_properly"
 path = "src/contains_properly.rs"
 harness = false
 
+[[bench]]
+name = "covers"
+path = "src/covers.rs"
+harness = false
+
 [[bench]]
 name = "convex_hull"
 path = "src/convex_hull.rs"

geo-benches/src/covers.rs

@@ -0,0 +1,89 @@
+use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
+use geo::algorithm::{Contains, Covers};
+use geo::{Convert, wkt};
+use geo::{coord, geometry::*};
+
+fn rect_covers(c: &mut Criterion) {
+    c.bench_function("rect covers line", |bencher| {
+        let rect = Rect::new(coord! { x: 0., y: 0. }, coord! { x: 10., y: 10. });
+        let line = Line::new(coord! { x: 5., y: 5. }, coord! { x: 7., y: 7. });
+        bencher.iter(|| {
+            assert!(criterion::black_box(&rect).covers(criterion::black_box(&line)));
+        });
+    });
+
+    c.bench_function("rect contains line", |bencher| {
+        let rect = Rect::new(coord! { x: 0., y: 0. }, coord! { x: 10., y: 10. });
+        let line = Line::new(coord! { x: 5., y: 5. }, coord! { x: 7., y: 7. });
+        bencher.iter(|| {
+            assert!(criterion::black_box(&rect).contains(criterion::black_box(&line)));
+        });
+    });
+}
+
+fn linestring_covers_point(c: &mut Criterion) {
+    c.bench_function("linestring covers point", |bencher| {
+        let ls: LineString<f64> = wkt! {LINESTRING(0 0, 10 0, 10 10, 0 10)}.convert();
+        let pt: Point<f64> = wkt! {POINT(5 10)}.convert();
+        bencher.iter(|| {
+            assert!(criterion::black_box(&ls).covers(criterion::black_box(&pt)));
+        });
+    });
+
+    c.bench_function("linestring contains point", |bencher| {
+        let ls: LineString<f64> = wkt! {LINESTRING(0 0, 10 0, 10 10, 0 10)}.convert();
+        let pt: Point<f64> = wkt! {POINT(5 10)}.convert();
+        bencher.iter(|| {
+            assert!(criterion::black_box(&ls).contains(criterion::black_box(&pt)));
+        });
+    });
+}
+
+// bench a method derived from intersects
+fn rect_linestring_scaling(c: &mut Criterion) {
+    fn make_outer_rect(n: i32) -> Rect<f64> {
+        Rect::new(coord! {x:0,y:0}, coord! {x:n,y:3}).convert()
+    }
+    fn make_inner_ls(n: i32) -> LineString<f64> {
+        LineString::new((1..n).map(|i: i32| coord! {x:i,y:(1+i%2)}).collect()).convert()
+    }
+
+    {
+        // create two polygons, both of  of n+2 sides and no holes
+        let mut group = c.benchmark_group("covers rect linestring scaling");
+
+        // trait is faster for small polygons, but relate overtakes from around 700*700 boundary segment checks
+        for i in [10, 1_000, 100_000] {
+            group.throughput(Throughput::Elements(i as u64));
+
+            let inner_poly = make_inner_ls(i);
+            let outer_poly = make_outer_rect(i);
+
+            group.bench_with_input(
+                BenchmarkId::new("covers trait", i),
+                &(&outer_poly, &inner_poly),
+                |bencher, &(a, b)| {
+                    bencher.iter(|| assert!(a.covers(b)));
+                },
+            );
+
+            // contains delegates this to relate
+            group.bench_with_input(
+                BenchmarkId::new("contains trait", i),
+                &(&outer_poly, &inner_poly),
+                |bencher, &(a, b)| {
+                    bencher.iter(|| assert!(a.contains(b)));
+                },
+            );
+        }
+        group.finish();
+    }
+}
+
+criterion_group!(
+    benches,
+    rect_covers,
+    linestring_covers_point,
+    rect_linestring_scaling
+);
+criterion_main!(benches);

geo/CHANGES.md

@@ -19,6 +19,9 @@
   - BREAKING: The `concave_hull` method now has no `concavity` parameter.  
   - Add `concave_hull_with_options` method which requires `ConcaveHullOptions` as a parameter with `concavity` and `length_threshold` options.
   - <https://github.com/georust/geo/pull/1442>
+- Add `Covers` trait to relate and as a standalone operation
+  - custom implementations for checking Geometries covered by `Rect`, `Triangle`, `Line`, `Point`, `Coord`
+  - custom implementations for checking Geometries covering `Point` and `MultiPoint`
 
 ## 0.31.0 - 2025-09-01
 

geo/src/algorithm/covers/coord.rs

@@ -0,0 +1,41 @@
+use super::{Covers, impl_covers_from_intersects};
+use crate::GeoNum;
+use crate::Intersects;
+use crate::geometry::*;
+
+impl<T, G> Covers<Coord<T>> for G
+where
+    T: GeoNum,
+    G: Intersects<Coord<T>>,
+{
+    fn covers(&self, rhs: &Coord<T>) -> bool {
+        self.intersects(rhs)
+    }
+}
+
+// valid because self is convex geometry
+// all exterior pts of RHS intersecting self means self covers RHS
+impl_covers_from_intersects!(Coord<T>, [
+Point<T>, MultiPoint<T>,
+Line<T>,
+LineString<T>, MultiLineString<T>,
+Rect<T>, Triangle<T>,
+Polygon<T>,  MultiPolygon<T>,
+Geometry<T>, GeometryCollection<T>
+]);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_rhs_empty() {
+        let s: Coord<f64> = Coord::zero();
+        assert!(!s.covers(&LineString::empty()));
+        assert!(!s.covers(&Polygon::empty()));
+        assert!(!s.covers(&MultiPoint::empty()));
+        assert!(!s.covers(&MultiLineString::empty()));
+        assert!(!s.covers(&MultiPolygon::empty()));
+        assert!(!s.covers(&GeometryCollection::empty()));
+    }
+}

geo/src/algorithm/covers/geometry.rs

@@ -0,0 +1,103 @@
+use super::Covers;
+use crate::GeoFloat;
+use crate::geometry::*;
+use crate::geometry_delegate_impl;
+
+impl<T> Covers<Point<T>> for Geometry<T>
+where
+    T: GeoFloat,
+{
+    geometry_delegate_impl! {
+        fn covers(&self, point: &Point<T>) -> bool;
+    }
+}
+
+impl<T> Covers<Line<T>> for Geometry<T>
+where
+    T: GeoFloat,
+{
+    geometry_delegate_impl! {
+        fn covers(&self, line: &Line<T>) -> bool;
+    }
+}
+
+impl<T> Covers<LineString<T>> for Geometry<T>
+where
+    T: GeoFloat,
+{
+    geometry_delegate_impl! {
+        fn covers(&self, line_string: &LineString<T>) -> bool;
+    }
+}
+
+impl<T> Covers<Polygon<T>> for Geometry<T>
+where
+    T: GeoFloat,
+{
+    geometry_delegate_impl! {
+        fn covers(&self, polygon: &Polygon<T>) -> bool;
+    }
+}
+
+impl<T> Covers<MultiPoint<T>> for Geometry<T>
+where
+    T: GeoFloat,
+{
+    geometry_delegate_impl! {
+        fn covers(&self, multi_point: &MultiPoint<T>) -> bool;
+    }
+}
+
+impl<T> Covers<MultiLineString<T>> for Geometry<T>
+where
+    T: GeoFloat,
+{
+    geometry_delegate_impl! {
+        fn covers(&self, multi_line_string: &MultiLineString<T>) -> bool;
+    }
+}
+
+impl<T> Covers<MultiPolygon<T>> for Geometry<T>
+where
+    T: GeoFloat,
+{
+    geometry_delegate_impl! {
+        fn covers(&self, multi_line_string: &MultiPolygon<T>) -> bool;
+    }
+}
+
+impl<T> Covers<GeometryCollection<T>> for Geometry<T>
+where
+    T: GeoFloat,
+{
+    geometry_delegate_impl! {
+        fn covers(&self, geometry_collection: &GeometryCollection<T>) -> bool;
+    }
+}
+
+impl<T> Covers<Rect<T>> for Geometry<T>
+where
+    T: GeoFloat,
+{
+    geometry_delegate_impl! {
+        fn covers(&self, rect: &Rect<T>) -> bool;
+    }
+}
+
+impl<T> Covers<Triangle<T>> for Geometry<T>
+where
+    T: GeoFloat,
+{
+    geometry_delegate_impl! {
+        fn covers(&self, triangle: &Triangle<T>) -> bool;
+    }
+}
+
+impl<T> Covers<Geometry<T>> for Geometry<T>
+where
+    T: GeoFloat,
+{
+    geometry_delegate_impl! {
+        fn covers(&self, other: &Geometry<T>) -> bool;
+    }
+}

geo/src/algorithm/covers/geometry_collection.rs

@@ -0,0 +1,52 @@
+use super::{Covers, impl_covers_from_relate, impl_covers_geometry_for};
+use crate::covers::impl_covers_from_intersects;
+use crate::geometry::*;
+use crate::{GeoFloat, GeoNum};
+
+impl_covers_from_intersects!(GeometryCollection<T>,[Point<T>,MultiPoint<T>]);
+impl_covers_from_relate!(GeometryCollection<T>, [
+Line<T>,
+LineString<T>, MultiLineString<T>,
+Rect<T>, Triangle<T>,
+Polygon<T>, MultiPolygon<T>,
+GeometryCollection<T>
+]);
+impl_covers_geometry_for!(GeometryCollection<T>);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::algorithm::convert::Convert;
+    use crate::wkt;
+
+    #[test]
+    fn test_rhs_empty() {
+        let s: GeometryCollection<f64> = wkt!(GEOMETRYCOLLECTION(POINT(0 0))).convert();
+        assert!(!s.covers(&LineString::empty()));
+        assert!(!s.covers(&Polygon::empty()));
+        assert!(!s.covers(&MultiPoint::empty()));
+        assert!(!s.covers(&MultiLineString::empty()));
+        assert!(!s.covers(&MultiPolygon::empty()));
+        assert!(!s.covers(&GeometryCollection::empty()));
+    }
+
+    #[test]
+    fn test_lhs_empty() {
+        let s: GeometryCollection<f64> = GeometryCollection::empty();
+
+        assert!(!s.covers(&wkt!(POINT(0 0)).convert()));
+        assert!(!s.covers(&wkt!(MULTIPOINT(0 0,1 1)).convert()));
+
+        assert!(!s.covers(&wkt!(LINE(0 0,1 1)).convert()));
+        assert!(!s.covers(&wkt!(LINESTRING(0 0,1 1)).convert()));
+        assert!(!s.covers(&wkt!(MULTILINESTRING((0 0,1 1),(2 2,3 3))).convert()));
+
+        assert!(!s.covers(&wkt!(POLYGON((0 0,1 1,1 0,0 0))).convert()));
+        assert!(!s.covers(&wkt!(MULTIPOLYGON(((0 0,1 0, 1 1,0 1, 0 0)))).convert()));
+        assert!(!s.covers(&wkt!(RECT(0 0, 1 1)).convert()));
+        assert!(!s.covers(&wkt!(TRIANGLE(0 0, 0 1, 1 1)).convert()));
+
+        assert!(!s.covers(&Into::<Geometry>::into(wkt!(POINT(0 0)).convert())));
+        assert!(!s.covers(&wkt!(GEOMETRYCOLLECTION(POINT(0 0))).convert()));
+    }
+}

geo/src/algorithm/covers/line.rs

@@ -0,0 +1,32 @@
+use super::{Covers, impl_covers_from_intersects};
+use crate::GeoNum;
+use crate::geometry::*;
+
+// valid because self is convex geometry
+// all exterior pts of RHS intersecting self means self covers RHS
+impl_covers_from_intersects!(Line<T>, [
+Point<T>, MultiPoint<T>,
+Line<T>,
+LineString<T>, MultiLineString<T>,
+Rect<T>, Triangle<T>,
+Polygon<T>,  MultiPolygon<T> ,
+Geometry<T>, GeometryCollection<T>
+]);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::algorithm::convert::Convert;
+    use crate::wkt;
+
+    #[test]
+    fn test_rhs_empty() {
+        let s: Line<f64> = wkt!(LINE(0 0,1 1)).convert();
+        assert!(!s.covers(&LineString::empty()));
+        assert!(!s.covers(&Polygon::empty()));
+        assert!(!s.covers(&MultiPoint::empty()));
+        assert!(!s.covers(&MultiLineString::empty()));
+        assert!(!s.covers(&MultiPolygon::empty()));
+        assert!(!s.covers(&GeometryCollection::empty()));
+    }
+}