Polygon in Rect performance improvements

Author: michel-kraemer

geo/CHANGES.md

@@ -6,6 +6,8 @@
   * <https://github.com/georust/geo/pull/1159>
 * Fix issue in Debug impl for AffineTransform where yoff is shown instead of xoff
   * <https://github.com/georust/geo/pull/1191>
+* `Polygon` in `Rect` performance improvements.
+  * <https://github.com/georust/geo/pull/1192>
 
 ## 0.28.0
 

geo/benches/contains.rs

@@ -1,6 +1,6 @@
 use criterion::{criterion_group, criterion_main, Criterion};
 use geo::contains::Contains;
-use geo::{point, polygon, Line, Point, Polygon, Triangle};
+use geo::{coord, point, polygon, Line, Point, Polygon, Rect, Triangle};
 
 fn criterion_benchmark(c: &mut Criterion) {
     c.bench_function("point in simple polygon", |bencher| {
@@ -128,6 +128,23 @@ fn criterion_benchmark(c: &mut Criterion) {
             assert!(!criterion::black_box(&triangle).contains(criterion::black_box(&point)));
         });
     });
+
+    c.bench_function("Rect contains polygon", |bencher| {
+        let polygon = polygon![
+            (x: 150., y: 350.),
+            (x: 100., y: 350.),
+            (x: 210., y: 160.),
+            (x: 290., y: 350.),
+            (x: 250., y: 350.),
+            (x: 200., y: 250.),
+            (x: 150., y: 350.),
+        ];
+        let rect = Rect::new(coord! { x: 90., y: 150. }, coord! { x: 300., y: 360. });
+
+        bencher.iter(|| {
+            assert!(criterion::black_box(&rect).contains(criterion::black_box(&polygon)));
+        });
+    });
 }
 
 criterion_group!(benches, criterion_benchmark);

geo/src/algorithm/contains/mod.rs

@@ -95,6 +95,7 @@ pub(crate) use impl_contains_geometry_for;
 mod test {
     use crate::line_string;
     use crate::Contains;
+    use crate::Relate;
     use crate::{coord, Coord, Line, LineString, MultiPolygon, Point, Polygon, Rect, Triangle};
 
     #[test]
@@ -555,4 +556,148 @@ mod test {
         let pt: Point = (0.5, 0.5).into();
         assert!(!tri.contains(&pt));
     }
+
+    #[test]
+    fn rect_contains_polygon() {
+        let rect = Rect::new(coord! { x: 90., y: 150. }, coord! { x: 300., y: 360. });
+        let poly = Polygon::new(
+            line_string![
+                (x: 150., y: 350.),
+                (x: 100., y: 350.),
+                (x: 210., y: 160.),
+                (x: 290., y: 350.),
+                (x: 250., y: 350.),
+                (x: 200., y: 250.),
+                (x: 150., y: 350.),
+            ],
+            vec![],
+        );
+        assert_eq!(rect.contains(&poly), rect.relate(&poly).is_contains());
+    }
+
+    #[test]
+    fn rect_contains_touching_polygon() {
+        let rect = Rect::new(coord! { x: 90., y: 150. }, coord! { x: 300., y: 360. });
+        let touching_poly = Polygon::new(
+            line_string![
+                (x: 150., y: 350.),
+                (x: 90.,  y: 350.),
+                (x: 210., y: 160.),
+                (x: 290., y: 350.),
+                (x: 250., y: 350.),
+                (x: 200., y: 250.),
+                (x: 150., y: 350.),
+            ],
+            vec![],
+        );
+        assert_eq!(
+            rect.contains(&touching_poly),
+            rect.relate(&touching_poly).is_contains()
+        );
+
+        let touching_rect = Rect::new(coord! { x: 90., y: 200. }, coord! { x: 200., y: 300. });
+        assert_eq!(
+            rect.contains(&touching_rect),
+            rect.relate(&touching_rect).is_contains()
+        );
+    }
+
+    #[test]
+    fn rect_contains_empty_polygon() {
+        let rect = Rect::new(coord! { x: 90., y: 150. }, coord! { x: 300., y: 360. });
+        let empty_poly = Polygon::new(line_string![], vec![]);
+        assert_eq!(
+            rect.contains(&empty_poly),
+            rect.relate(&empty_poly).is_contains()
+        );
+    }
+
+    #[test]
+    fn rect_contains_polygon_empty_area() {
+        let rect = Rect::new(coord! { x: 90., y: 150. }, coord! { x: 300., y: 360. });
+        let empty_poly = Polygon::new(
+            line_string![
+                (x: 100., y: 200.),
+                (x: 100., y: 200.),
+                (x: 100., y: 200.),
+                (x: 100., y: 200.),
+            ],
+            vec![],
+        );
+        assert_eq!(
+            rect.contains(&empty_poly),
+            rect.relate(&empty_poly).is_contains()
+        );
+    }
+
+    #[test]
+    fn rect_contains_rect_polygon() {
+        let rect = Rect::new(coord! { x: 90., y: 150. }, coord! { x: 300., y: 360. });
+        let rect_poly = rect.clone().to_polygon();
+        assert_eq!(
+            rect.contains(&rect_poly),
+            rect.relate(&rect_poly).is_contains()
+        );
+    }
+
+    #[test]
+    fn rect_contains_polygon_in_boundary() {
+        let rect = Rect::new(coord! { x: 90. , y: 150. }, coord! { x: 300., y: 360. });
+        let poly_one_border =
+            Rect::new(coord! { x: 90. , y: 150. }, coord! { x: 90., y: 360. }).to_polygon();
+        assert_eq!(
+            rect.contains(&poly_one_border),
+            rect.relate(&poly_one_border).is_contains()
+        );
+
+        let poly_two_borders = Polygon::new(
+            line_string![
+                (x: 90., y: 150.),
+                (x: 300., y: 150.),
+                (x: 90., y: 150.),
+                (x: 90., y: 360.),
+                (x: 90., y: 150.),
+            ],
+            vec![],
+        );
+        assert_eq!(
+            rect.contains(&poly_two_borders),
+            rect.relate(&poly_two_borders).is_contains()
+        );
+    }
+
+    #[test]
+    fn rect_empty_contains_polygon() {
+        let rect = Rect::new(coord! { x: 90. , y: 150. }, coord! { x: 90., y: 150. });
+        let poly = Polygon::new(
+            line_string![
+                (x: 150., y: 350.),
+                (x: 100., y: 350.),
+                (x: 210., y: 160.),
+                (x: 290., y: 350.),
+                (x: 250., y: 350.),
+                (x: 200., y: 250.),
+                (x: 150., y: 350.),
+            ],
+            vec![],
+        );
+        assert_eq!(rect.contains(&poly), rect.relate(&poly).is_contains());
+
+        let rect_poly = rect.clone().to_polygon();
+        assert_eq!(
+            rect.contains(&rect_poly),
+            rect.relate(&rect_poly).is_contains()
+        );
+    }
+
+    #[test]
+    fn rect_contains_point() {
+        let rect = Rect::new(coord! { x: 90., y: 150. }, coord! { x: 300., y: 360. });
+
+        let point1 = Point::new(100., 200.);
+        assert_eq!(rect.contains(&point1), rect.relate(&point1).is_contains());
+
+        let point2 = Point::new(90., 200.);
+        assert_eq!(rect.contains(&point2), rect.relate(&point2).is_contains());
+    }
 }

geo/src/algorithm/contains/rect.rs

@@ -1,5 +1,7 @@
+use geo_types::CoordFloat;
+
 use super::{impl_contains_from_relate, impl_contains_geometry_for, Contains};
-use crate::geometry::*;
+use crate::{geometry::*, Area, CoordsIter, HasDimensions};
 use crate::{CoordNum, GeoFloat};
 
 // ┌──────────────────────────┐
@@ -41,5 +43,43 @@ where
     }
 }
 
-impl_contains_from_relate!(Rect<T>, [Line<T>, LineString<T>, Polygon<T>, MultiPoint<T>, MultiLineString<T>, MultiPolygon<T>, GeometryCollection<T>, Triangle<T>]);
+impl<T> Contains<Polygon<T>> for Rect<T>
+where
+    T: CoordFloat,
+{
+    fn contains(&self, rhs: &Polygon<T>) -> bool {
+        // the polygon must not be empty
+        if rhs.is_empty() {
+            return false;
+        }
+
+        // none of the polygon's points may lie outside the rectangle
+        let mut points_inside = 0;
+        for c in rhs.exterior_coords_iter() {
+            if c.x < self.min().x || c.x > self.max().x || c.y < self.min().y || c.y > self.max().y
+            {
+                return false;
+            }
+            if c.x > self.min().x && c.x < self.max().x && c.y > self.min().y && c.y < self.max().y
+            {
+                points_inside += 1;
+            }
+        }
+
+        // The polygon must not lie completely inside the rectangle's boundary.
+        // In other words: at least one point of the interior of the polygon
+        // must lie in the interior of the rectangle. Since we know that the
+        // rectangle is concave, we just need make sure that either at least
+        // one point of the polygon lies inside the rectangle's interior or
+        // that the polygon's interior is not empty, in which case it will
+        // definitely intersect with the rectangle's interior.
+        if points_inside == 0 && rhs.signed_area().is_zero() {
+            return false;
+        }
+
+        true
+    }
+}
+
+impl_contains_from_relate!(Rect<T>, [Line<T>, LineString<T>, MultiPoint<T>, MultiLineString<T>, MultiPolygon<T>, GeometryCollection<T>, Triangle<T>]);
 impl_contains_geometry_for!(Rect<T>);