Add some basic custom impl from intersects

Author: cookiedan42

geo/CHANGES.md

@@ -7,6 +7,7 @@
 - LOF algorithm efficiency improvements due to caching kth distance
 - Add DBSCAN clustering algorithm implementation
 - Add `distance_within` method with default impl for any geometry that implements `Distance`, with similar semantics to the PostGIS [ST_DWithin](https://postgis.net/docs/ST_DWithin.html) function
+- Add `Covers` trait, a simplification of `Contains` in which geometries in the boundary are considered to be Covered
 
 ## 0.31.0 - 2025-09-01
 

geo/Cargo.toml

@@ -56,6 +56,10 @@ harness = false
 name = "contains"
 harness = false
 
+[[bench]]
+name = "covers"
+harness = false
+
 [[bench]]
 name = "convex_hull"
 harness = false

geo/benches/covers.rs

@@ -0,0 +1,43 @@
+use criterion::{Criterion, 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)));
+        });
+    });
+}
+
+criterion_group!(benches, rect_covers, linestring_covers_point,);
+criterion_main!(benches);

geo/src/algorithm/covers/coord.rs

@@ -0,0 +1,23 @@
+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)
+    }
+}
+
+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>
+]);

geo/src/algorithm/covers/geometry.rs

@@ -1,16 +1,7 @@
 use super::Covers;
+use crate::GeoFloat;
 use crate::geometry::*;
 use crate::geometry_delegate_impl;
-use crate::{GeoFloat, GeoNum};
-
-impl<T> Covers<Coord<T>> for Geometry<T>
-where
-    T: GeoFloat,
-{
-    fn covers(&self, coord: &Coord<T>) -> bool {
-        self.covers(&Point::from(*coord))
-    }
-}
 
 impl<T> Covers<Point<T>> for Geometry<T>
 where
@@ -106,18 +97,7 @@ impl<T> Covers<Geometry<T>> for Geometry<T>
 where
     T: GeoFloat,
 {
-    fn covers(&self, other: &Geometry<T>) -> bool {
-        match other {
-            Geometry::Point(geom) => self.covers(geom),
-            Geometry::Line(geom) => self.covers(geom),
-            Geometry::LineString(geom) => self.covers(geom),
-            Geometry::Polygon(geom) => self.covers(geom),
-            Geometry::MultiPoint(geom) => self.covers(geom),
-            Geometry::MultiLineString(geom) => self.covers(geom),
-            Geometry::MultiPolygon(geom) => self.covers(geom),
-            Geometry::GeometryCollection(geom) => self.covers(geom),
-            Geometry::Rect(geom) => self.covers(geom),
-            Geometry::Triangle(geom) => self.covers(geom),
-        }
+    geometry_delegate_impl! {
+        fn covers(&self, other: &Geometry<T>) -> bool;
     }
 }

geo/src/algorithm/covers/geometry_collection.rs

@@ -1,24 +1,14 @@
-use super::{impl_covers_from_relate, impl_covers_geometry_for, Covers};
+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<T> Covers<Coord<T>> for GeometryCollection<T>
-where
-    T: GeoFloat,
-{
-    fn covers(&self, rhs: &Coord<T>) -> bool {
-        self.iter().any(|geometry| geometry.covers(rhs))
-    }
-}
-
-impl<T> Covers<Point<T>> for GeometryCollection<T>
-where
-    T: GeoFloat,
-{
-    fn covers(&self, point: &Point<T>) -> bool {
-        self.covers(&point.0)
-    }
-}
-
-impl_covers_from_relate!(GeometryCollection<T>, [Line<T>, LineString<T>, Polygon<T>, MultiPoint<T>, MultiLineString<T>, MultiPolygon<T>, GeometryCollection<T>, Rect<T>, Triangle<T>]);
+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>);

geo/src/algorithm/covers/line.rs

@@ -1,28 +1,12 @@
-use super::{impl_covers_from_relate, Covers};
-use crate::{geometry::*, Intersects};
-use crate::{GeoFloat, GeoNum};
+use super::{Covers, impl_covers_from_intersects};
+use crate::GeoNum;
+use crate::geometry::*;
 
-impl<T> Covers<Coord<T>> for Line<T>
-where
-    T: GeoFloat,
-    Self: Covers<Point<T>>,
-{
-    fn covers(&self, rhs: &Coord<T>) -> bool {
-        self.covers(&Point::new(rhs.x, rhs.y))
-    }
-}
-
-impl<T> Covers<Point<T>> for Line<T>
-where
-    T: GeoFloat,
-{
-    fn covers(&self, rhs: &Point<T>) -> bool {
-        self.intersects(rhs)
-    }
-}
-impl_covers_from_relate!(Line<T>, [MultiPoint<T>]);
-impl_covers_from_relate!(Line<T>, [Line<T>]);
-impl_covers_from_relate!(Line<T>, [ LineString<T>,  MultiLineString<T>]);
-impl_covers_from_relate!(Line<T>, [ Rect<T>, Triangle<T>]);
-impl_covers_from_relate!(Line<T>, [Polygon<T>,  MultiPolygon<T>]);
-impl_covers_from_relate!(Line<T>, [Geometry<T>, GeometryCollection<T>]);
+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>
+]);

geo/src/algorithm/covers/line_string.rs

@@ -1,35 +1,46 @@
-use super::{impl_covers_from_relate, Covers};
-use crate::geometry::*;
+use super::{Covers, impl_covers_from_intersects, impl_covers_from_relate};
+use crate::{Contains, HasDimensions, geometry::*};
 use crate::{GeoFloat, GeoNum};
 
-impl<T> Covers<Coord<T>> for LineString<T>
+impl_covers_from_intersects!(LineString<T>, [Point<T>, MultiPoint<T>]);
+
+impl<T> Covers<Line<T>> for LineString<T>
 where
-    T: GeoFloat,
-    Self: Covers<Point<T>>,
+    T: GeoNum,
 {
-    fn covers(&self, rhs: &Coord<T>) -> bool {
-        self.covers(&Point::new(rhs.x, rhs.y))
+    fn covers(&self, rhs: &Line<T>) -> bool {
+        if rhs.start == rhs.end {
+            self.covers(&rhs.start)
+        } else {
+            self.contains(rhs)
+        }
     }
 }
-impl_covers_from_relate!(LineString<T>, [Point<T>, MultiPoint<T>]);
-impl_covers_from_relate!(LineString<T>, [Line<T>]);
-impl_covers_from_relate!(LineString<T>, [ LineString<T>,  MultiLineString<T>]);
-impl_covers_from_relate!(LineString<T>, [ Rect<T>, Triangle<T>]);
-impl_covers_from_relate!(LineString<T>, [Polygon<T>,  MultiPolygon<T>]);
-impl_covers_from_relate!(LineString<T>, [Geometry<T>, GeometryCollection<T>]);
 
-impl<T> Covers<Coord<T>> for MultiLineString<T>
+impl<T> Covers<LineString<T>> for LineString<T>
 where
-    T: GeoFloat,
-    Self: Covers<Point<T>>,
+    T: GeoNum,
 {
-    fn covers(&self, rhs: &Coord<T>) -> bool {
-        self.covers(&Point::new(rhs.x, rhs.y))
+    fn covers(&self, rhs: &LineString<T>) -> bool {
+        if self.is_empty() || rhs.is_empty() {
+            return false;
+        }
+        rhs.lines().all(|l| self.covers(&l))
     }
 }
-impl_covers_from_relate!(MultiLineString<T>, [Point<T>, MultiPoint<T>]);
-impl_covers_from_relate!(MultiLineString<T>, [Line<T>]);
-impl_covers_from_relate!(MultiLineString<T>, [ LineString<T>,  MultiLineString<T>]);
-impl_covers_from_relate!(MultiLineString<T>, [ Rect<T>, Triangle<T>]);
-impl_covers_from_relate!(MultiLineString<T>, [Polygon<T>,  MultiPolygon<T>]);
-impl_covers_from_relate!(MultiLineString<T>, [Geometry<T>, GeometryCollection<T>]);
+
+impl_covers_from_relate!(LineString<T>, [
+MultiLineString<T>,
+Rect<T>, Triangle<T>,
+Polygon<T>,  MultiPolygon<T>,
+Geometry<T>, GeometryCollection<T>
+]);
+
+impl_covers_from_intersects!(MultiLineString<T>, [Point<T>, MultiPoint<T>]);
+impl_covers_from_relate!(MultiLineString<T>, [
+Line<T>,
+LineString<T>,  MultiLineString<T>,
+Rect<T>, Triangle<T>,
+Polygon<T>,  MultiPolygon<T>,
+Geometry<T>, GeometryCollection<T>
+]);

geo/src/algorithm/covers/mod.rs

@@ -1,9 +1,9 @@
-/// Checks if `rhs` is completely contained within `self`.
-/// More formally, the interior of `rhs` has non-empty
-/// (set-theoretic) intersection but neither the interior,
-/// nor the boundary of `rhs` intersects the exterior of
-/// `self`. In other words, the [DE-9IM] intersection matrix
-/// of `(rhs, self)` is `T*F**F***`.
+/// Checks if every point in `rhs` lies inside `self`.
+/// (i.e. intersects the interior or boundary of) `self`.
+/// Equivalently, tests that no point of `other` lies outside (in the exterior of) `self`
+/// In other words, the [DE-9IM] intersection matrix
+/// of `(rhs, self)` matches one of the following patterns:
+/// `[T*****FF*], [*T****FF*], [***T**FF*], [****T*FF*]`
 ///
 /// [DE-9IM]: https://en.wikipedia.org/wiki/DE-9IM
 ///
@@ -32,13 +32,19 @@
 /// // Point in Polygon
 /// assert!(polygon.covers(&point!(x: 1., y: 1.)));
 /// ```
+///
+/// # Performance Note
+/// Much of this trait is currently implemented by delegating to the Relate trait.
+/// Custom Contains implementations might be faster if you need speed   
+///
 pub trait Covers<Rhs = Self> {
     fn covers(&self, rhs: &Rhs) -> bool;
 }
 
+pub(crate) mod coord;
 pub(crate) mod line_string;
-pub(crate)mod point;
-pub(crate)mod polygon;
+pub(crate) mod point;
+pub(crate) mod polygon;
 
 pub(crate) mod line;
 pub(crate) mod rect;
@@ -64,23 +70,54 @@ macro_rules! impl_covers_from_relate {
 }
 pub(crate) use impl_covers_from_relate;
 
+// returns true if all coords of rhs intersects with self
+// always valid if self is Point, Line or Convex Polygon (Rect/Triangle)
+// always valid if other is Point or MultiPoint
+macro_rules! impl_covers_from_intersects {
+
+    (Coord<T>,  [$($target:ty),*]) => {
+
+        $(
+            impl<T> Covers<$target> for Coord<T>
+            where
+                T: GeoNum,
+                Self: $crate::algorithm::Intersects<Coord<T>>,
+            {
+                fn covers(&self, target: &$target) -> bool {
+                    use $crate::CoordsIter;
+                    use $crate::algorithm::Intersects;
+                    use $crate::algorithm::HasDimensions;
+                    if HasDimensions::is_empty(target) {
+                        return false;
+                    }
+                    target.coords_iter().all(|pt| self.intersects(&pt))
+                }
+            }
+        )*
+    };
 
-macro_rules! impl_covers_convex_poly {
     ($for:ty,  [$($target:ty),*]) => {
+
         $(
             impl<T> Covers<$target> for $for
             where
                 T: GeoNum,
-                Self: Intersects<Coord<T>>,
+                Self: $crate::algorithm::Intersects<Coord<T>>,
             {
                 fn covers(&self, target: &$target) -> bool {
+                    use $crate::CoordsIter;
+                    use $crate::algorithm::Intersects;
+                    use $crate::algorithm::HasDimensions;
+                    if HasDimensions::is_empty(self) || HasDimensions::is_empty(target){
+                        return false;
+                    }
                     target.coords_iter().all(|pt| self.intersects(&pt))
                 }
             }
         )*
     };
 }
-pub(crate) use impl_covers_convex_poly;
+pub(crate) use impl_covers_from_intersects;
 
 macro_rules! impl_covers_geometry_for {
     ($geom_type: ty) => {
@@ -113,9 +150,8 @@ pub(crate) use impl_covers_geometry_for;
 
 #[cfg(test)]
 mod test {
-    use crate::line_string;
     use crate::Covers;
-    use crate::Relate;
+    use crate::line_string;
     use crate::*;
 
     #[test]