MultiGeometry binary predicate support.

ci/test_notebooks.sh

@@ -48,7 +48,7 @@ for nb in $(find . -name "*.ipynb"); do
         echo "--------------------------------------------------------------------------------"
     else
         nvidia-smi
-        ${NBTEST} ${nbBasename}
+        ${NBTEST} ${nb}
     fi
 done
 

python/cuspatial/cuspatial/core/binpreds/feature_contains.py

@@ -6,6 +6,7 @@
 
 from cuspatial.core.binpreds.basic_predicates import (
     _basic_contains_count,
+    _basic_equals_all,
     _basic_equals_any,
     _basic_equals_count,
     _basic_intersects,
@@ -154,31 +155,56 @@ def _preprocess(self, lhs, rhs):
         return _basic_equals_any(lhs, rhs)
 
 
+class MultiPointMultiPointContains(BinPred):
+    def _preprocess(self, lhs, rhs):
+        return _basic_equals_all(rhs, lhs)
+
+
 class LineStringPointContains(BinPred):
     def _preprocess(self, lhs, rhs):
         intersects = _basic_intersects(lhs, rhs)
-        equals = _basic_equals_any(lhs, rhs)
+        equals = _basic_equals_count(lhs, rhs) == rhs.sizes
         return intersects & ~equals
 
 
 class LineStringLineStringContainsPredicate(BinPred):
     def _preprocess(self, lhs, rhs):
+        # rhs_self_intersection is rhs where all colinear segments
+        # are compacted into a single segment. This is necessary
+        # because the intersection of lhs and rhs below will
+        # compact colinear segments into a single segment, so
+        # vertices in rhs will be lost and not countable.
+        # Consider the following example:
+        # lhs = [(0, 0), (1, 1)]
+        # rhs = [(0, 0), (0.5, 0.5), (1, 1)]
+        # The intersection of lhs and rhs is [(0, 0), (1, 1)].
+        # rhs is contained by lhs if all of the vertices in the
+        # intersection are in rhs. However, the intersection
+        # does not contain the vertex (0.5, 0.5) in the original rhs.
+        rhs_self_intersection = _basic_intersects_pli(rhs, rhs)
+        rhs_no_segments = _points_and_lines_to_multipoints(
+            rhs_self_intersection[1], rhs_self_intersection[0]
+        )
+        # Now intersect lhs and rhs and collect only the segments.
         pli = _basic_intersects_pli(lhs, rhs)
-        points = _points_and_lines_to_multipoints(pli[1], pli[0])
-        # Every point in B must be in the intersection
-        equals = _basic_equals_count(rhs, points) == rhs.sizes
+        lines = _pli_lines_to_multipoints(pli)
+        # Every segment in B must be in the intersection segments.
+        equals = (
+            _basic_equals_count(lines, rhs_no_segments)
+            == rhs_no_segments.sizes
+        )
         return equals
 
 
 """DispatchDict listing the classes to use for each combination of
     left and right hand side types. """
 DispatchDict = {
     (Point, Point): PointPointContains,
-    (Point, MultiPoint): ImpossiblePredicate,
+    (Point, MultiPoint): MultiPointMultiPointContains,
     (Point, LineString): ImpossiblePredicate,
     (Point, Polygon): ImpossiblePredicate,
-    (MultiPoint, Point): NotImplementedPredicate,
-    (MultiPoint, MultiPoint): NotImplementedPredicate,
+    (MultiPoint, Point): MultiPointMultiPointContains,
+    (MultiPoint, MultiPoint): MultiPointMultiPointContains,
     (MultiPoint, LineString): NotImplementedPredicate,
     (MultiPoint, Polygon): NotImplementedPredicate,
     (LineString, Point): LineStringPointContains,

python/cuspatial/cuspatial/core/binpreds/feature_contains_properly.py

@@ -8,6 +8,7 @@
 
 from cuspatial.core.binpreds.basic_predicates import (
     _basic_equals_all,
+    _basic_equals_count,
     _basic_intersects,
 )
 from cuspatial.core.binpreds.binpred_interface import (
@@ -185,6 +186,11 @@ def _preprocess(self, lhs, rhs):
         return _basic_intersects(lhs, rhs)
 
 
+class MultiPointMultiPointContainsProperly(BinPred):
+    def _preprocess(self, lhs, rhs):
+        return _basic_equals_count(rhs, lhs) == rhs.sizes
+
+
 class LineStringLineStringContainsProperly(BinPred):
     def _preprocess(self, lhs, rhs):
         count = _basic_equals_all(lhs, rhs)
@@ -195,11 +201,11 @@ def _preprocess(self, lhs, rhs):
     left and right hand side types. """
 DispatchDict = {
     (Point, Point): ContainsProperlyByIntersection,
-    (Point, MultiPoint): ContainsProperlyByIntersection,
+    (Point, MultiPoint): MultiPointMultiPointContainsProperly,
     (Point, LineString): ImpossiblePredicate,
     (Point, Polygon): ImpossiblePredicate,
-    (MultiPoint, Point): NotImplementedPredicate,
-    (MultiPoint, MultiPoint): NotImplementedPredicate,
+    (MultiPoint, Point): MultiPointMultiPointContainsProperly,
+    (MultiPoint, MultiPoint): MultiPointMultiPointContainsProperly,
     (MultiPoint, LineString): NotImplementedPredicate,
     (MultiPoint, Polygon): NotImplementedPredicate,
     (LineString, Point): ContainsProperlyByIntersection,

python/cuspatial/cuspatial/core/binpreds/feature_covers.py

@@ -37,15 +37,18 @@ class CoversPredicateBase(EqualsPredicateBase):
     pass
 
 
+class MultiPointMultiPointCovers(BinPred):
+    def _preprocess(self, lhs, rhs):
+        # A multipoint A covers another multipoint B iff
+        # every point in B is in A.
+        return lhs.contains(rhs)
+
+
 class LineStringLineStringCovers(BinPred):
     def _preprocess(self, lhs, rhs):
         # A linestring A covers another linestring B iff
         # no point in B is outside of A.
-        pli = _basic_intersects_pli(lhs, rhs)
-        points = _points_and_lines_to_multipoints(pli[1], pli[0])
-        # Every point in B must be in the intersection
-        equals = _basic_equals_count(rhs, points) == rhs.sizes
-        return equals
+        return lhs.contains(rhs)
 
 
 class PolygonPointCovers(BinPred):
@@ -83,11 +86,11 @@ def _preprocess(self, lhs, rhs):
 
 DispatchDict = {
     (Point, Point): CoversPredicateBase,
-    (Point, MultiPoint): NotImplementedPredicate,
+    (Point, MultiPoint): MultiPointMultiPointCovers,
     (Point, LineString): ImpossiblePredicate,
     (Point, Polygon): ImpossiblePredicate,
-    (MultiPoint, Point): NotImplementedPredicate,
-    (MultiPoint, MultiPoint): NotImplementedPredicate,
+    (MultiPoint, Point): MultiPointMultiPointCovers,
+    (MultiPoint, MultiPoint): MultiPointMultiPointCovers,
     (MultiPoint, LineString): NotImplementedPredicate,
     (MultiPoint, Polygon): NotImplementedPredicate,
     (LineString, Point): LineStringPointIntersects,

python/cuspatial/cuspatial/core/binpreds/feature_crosses.py

@@ -17,7 +17,9 @@
     Point,
     Polygon,
     _false_series,
-    _points_and_lines_to_multipoints,
+    _lines_to_boundary_multipoints,
+    _pli_lines_to_multipoints,
+    _pli_points_to_multipoints,
 )
 
 
@@ -43,13 +45,23 @@ def _compute_predicate(self, lhs, rhs, preprocessor_result):
         # they intersect, and none of the points of the
         # intersection are in the boundary of the other
         pli = _basic_intersects_pli(rhs, lhs)
-        intersections = _points_and_lines_to_multipoints(pli[1], pli[0])
-        equals_lhs_count = _basic_equals_count(intersections, lhs)
-        equals_rhs_count = _basic_equals_count(intersections, rhs)
-        equals_lhs = equals_lhs_count != intersections.sizes
-        equals_rhs = equals_rhs_count != intersections.sizes
-        equals = equals_lhs & equals_rhs
-        return equals
+        points = _pli_points_to_multipoints(pli)
+        lines = _pli_lines_to_multipoints(pli)
+        # Optimization: only compute the subsequent boundaries and equalities
+        # of indexes that contain point intersections and do not contain line
+        # intersections.
+        lhs_boundary = _lines_to_boundary_multipoints(lhs)
+        rhs_boundary = _lines_to_boundary_multipoints(rhs)
+        lhs_boundary_matches = _basic_equals_count(points, lhs_boundary)
+        rhs_boundary_matches = _basic_equals_count(points, rhs_boundary)
+        lhs_crosses = lhs_boundary_matches != points.sizes
+        rhs_crosses = rhs_boundary_matches != points.sizes
+        crosses = (
+            (points.sizes > 0)
+            & (lhs_crosses & rhs_crosses)
+            & (lines.sizes == 0)
+        )
+        return crosses
 
 
 class LineStringPolygonCrosses(BinPred):

python/cuspatial/cuspatial/core/binpreds/feature_disjoint.py

@@ -74,11 +74,11 @@ def _preprocess(self, lhs, rhs):
 
 DispatchDict = {
     (Point, Point): PointPointDisjoint,
-    (Point, MultiPoint): NotImplementedPredicate,
+    (Point, MultiPoint): PointPointDisjoint,
     (Point, LineString): PointLineStringDisjoint,
     (Point, Polygon): PointPolygonDisjoint,
-    (MultiPoint, Point): NotImplementedPredicate,
-    (MultiPoint, MultiPoint): NotImplementedPredicate,
+    (MultiPoint, Point): PointPointDisjoint,
+    (MultiPoint, MultiPoint): PointPointDisjoint,
     (MultiPoint, LineString): NotImplementedPredicate,
     (MultiPoint, Polygon): LineStringPolygonDisjoint,
     (LineString, Point): LineStringPointDisjoint,

python/cuspatial/cuspatial/core/binpreds/feature_equals.py

@@ -10,6 +10,7 @@
 from cudf import Series
 
 import cuspatial
+from cuspatial.core.binpreds.basic_predicates import _basic_equals_all
 from cuspatial.core.binpreds.binpred_interface import (
     BinPred,
     EqualsOpResult,
@@ -289,6 +290,16 @@ def _postprocess(self, lhs, rhs, op_result):
         return result
 
 
+class PointMultiPointEquals(BinPred):
+    def _preprocess(self, lhs, rhs):
+        return _basic_equals_all(rhs, lhs)
+
+
+class MultiPointPointEquals(BinPred):
+    def _preprocess(self, lhs, rhs):
+        return _basic_equals_all(lhs, rhs)
+
+
 class MultiPointMultiPointEquals(PolygonComplexEquals):
     def _compute_predicate(self, lhs, rhs, point_indices):
         lengths_equal = self._offset_equals(
@@ -306,30 +317,8 @@ def _compute_predicate(self, lhs, rhs, point_indices):
 
 
 class LineStringLineStringEquals(PolygonComplexEquals):
-    def _compute_predicate(self, lhs, rhs, preprocessor_result):
-        """Linestrings can be compared either forward or reversed. We need
-        to compare both directions."""
-        lengths_equal = self._offset_equals(
-            lhs.lines.part_offset, rhs.lines.part_offset
-        )
-        lhs_lengths_equal = lhs[lengths_equal]
-        rhs_lengths_equal = rhs[lengths_equal]
-        lhs_reversed = self._reverse_linestrings(
-            lhs_lengths_equal.lines.xy, lhs_lengths_equal.lines.part_offset
-        )
-        forward_result = self._vertices_equals(
-            lhs_lengths_equal.lines.xy, rhs_lengths_equal.lines.xy
-        )
-        reverse_result = self._vertices_equals(
-            lhs_reversed, rhs_lengths_equal.lines.xy
-        )
-        result = forward_result | reverse_result
-        original_point_indices = cudf.Series(
-            lhs_lengths_equal.point_indices
-        ).replace(cudf.Series(lhs_lengths_equal.index))
-        return self._postprocess(
-            lhs, rhs, EqualsOpResult(result, original_point_indices)
-        )
+    def _preprocess(self, lhs, rhs):
+        return lhs.contains(rhs) & rhs.contains(lhs)
 
 
 class LineStringPointEquals(EqualsPredicateBase):
@@ -349,10 +338,10 @@ def _preprocess(self, lhs, rhs):
 """DispatchDict for Equals operations."""
 DispatchDict = {
     (Point, Point): EqualsPredicateBase,
-    (Point, MultiPoint): NotImplementedPredicate,
+    (Point, MultiPoint): PointMultiPointEquals,
     (Point, LineString): ImpossiblePredicate,
     (Point, Polygon): EqualsPredicateBase,
-    (MultiPoint, Point): NotImplementedPredicate,
+    (MultiPoint, Point): MultiPointPointEquals,
     (MultiPoint, MultiPoint): MultiPointMultiPointEquals,
     (MultiPoint, LineString): NotImplementedPredicate,
     (MultiPoint, Polygon): NotImplementedPredicate,

python/cuspatial/cuspatial/core/binpreds/feature_intersects.py

@@ -8,6 +8,7 @@
 from cuspatial.core.binops.intersection import pairwise_linestring_intersection
 from cuspatial.core.binpreds.basic_predicates import (
     _basic_contains_any,
+    _basic_equals_count,
     _basic_intersects,
 )
 from cuspatial.core.binpreds.binpred_interface import (
@@ -111,6 +112,11 @@ def _preprocess(self, lhs, rhs):
         return super()._preprocess(rhs, lhs)
 
 
+class MultiPointMultiPointIntersects(BinPred):
+    def _preprocess(self, lhs, rhs):
+        return _basic_equals_count(lhs, rhs) > 0
+
+
 class LineStringPolygonIntersects(BinPred):
     def _preprocess(self, lhs, rhs):
         return _basic_contains_any(rhs, lhs)
@@ -132,11 +138,11 @@ def _preprocess(self, lhs, rhs):
 """ Type dispatch dictionary for intersects binary predicates. """
 DispatchDict = {
     (Point, Point): IntersectsByEquals,
-    (Point, MultiPoint): NotImplementedPredicate,
+    (Point, MultiPoint): MultiPointMultiPointIntersects,
     (Point, LineString): PointLineStringIntersects,
     (Point, Polygon): PointPolygonIntersects,
-    (MultiPoint, Point): NotImplementedPredicate,
-    (MultiPoint, MultiPoint): NotImplementedPredicate,
+    (MultiPoint, Point): MultiPointMultiPointIntersects,
+    (MultiPoint, MultiPoint): MultiPointMultiPointIntersects,
     (MultiPoint, LineString): NotImplementedPredicate,
     (MultiPoint, Polygon): NotImplementedPredicate,
     (LineString, Point): LineStringPointIntersects,

python/cuspatial/cuspatial/core/binpreds/feature_overlaps.py

@@ -4,6 +4,8 @@
 
 from cuspatial.core.binpreds.basic_predicates import (
     _basic_contains_properly_any,
+    _basic_equals_count,
+    _basic_intersects_pli,
 )
 from cuspatial.core.binpreds.binpred_interface import (
     BinPred,
@@ -17,6 +19,7 @@
     Point,
     Polygon,
     _false_series,
+    _pli_lines_to_multipoints,
 )
 from cuspatial.utils.column_utils import has_same_geometry
 
@@ -39,6 +42,15 @@ class OverlapsPredicateBase(EqualsPredicateBase):
     pass
 
 
+class LineStringLineStringOverlaps(BinPred):
+    def _preprocess(self, lhs, rhs):
+        pli = _basic_intersects_pli(lhs, rhs)
+        lines = _pli_lines_to_multipoints(pli)
+        lhs_not_equal = _basic_equals_count(lhs, lines) != lhs.sizes
+        rhs_not_equal = _basic_equals_count(rhs, lines) != rhs.sizes
+        return (lines.sizes > 0) & lhs_not_equal & rhs_not_equal
+
+
 class PolygonPolygonOverlaps(BinPred):
     def _preprocess(self, lhs, rhs):
         contains_lhs = lhs.contains(rhs)
@@ -85,7 +97,7 @@ def _postprocess(self, lhs, rhs, op_result):
     (MultiPoint, Polygon): ImpossiblePredicate,
     (LineString, Point): ImpossiblePredicate,
     (LineString, MultiPoint): ImpossiblePredicate,
-    (LineString, LineString): ImpossiblePredicate,
+    (LineString, LineString): LineStringLineStringOverlaps,
     (LineString, Polygon): ImpossiblePredicate,
     (Polygon, Point): OverlapsPredicateBase,
     (Polygon, MultiPoint): OverlapsPredicateBase,

python/cuspatial/cuspatial/core/binpreds/feature_touches.py

@@ -8,7 +8,6 @@
     _basic_contains_count,
     _basic_contains_properly_any,
     _basic_equals_all,
-    _basic_equals_any,
     _basic_equals_count,
     _basic_intersects,
     _basic_intersects_count,
@@ -47,7 +46,12 @@ class TouchesPredicateBase(ContainsPredicate):
     """
 
     def _preprocess(self, lhs, rhs):
-        return _basic_equals_any(lhs, rhs)
+        return _basic_equals_count(lhs, rhs) == rhs.sizes
+
+
+class PointLineStringTouches(BinPred):
+    def _preprocess(self, lhs, rhs):
+        return _basic_equals_count(rhs, lhs) == lhs.sizes
 
 
 class PointPolygonTouches(ContainsPredicate):
@@ -147,11 +151,11 @@ def _preprocess(self, lhs, rhs):
 
 DispatchDict = {
     (Point, Point): ImpossiblePredicate,
-    (Point, MultiPoint): TouchesPredicateBase,
-    (Point, LineString): TouchesPredicateBase,
+    (Point, MultiPoint): ImpossiblePredicate,
+    (Point, LineString): PointLineStringTouches,
     (Point, Polygon): PointPolygonTouches,
-    (MultiPoint, Point): TouchesPredicateBase,
-    (MultiPoint, MultiPoint): TouchesPredicateBase,
+    (MultiPoint, Point): ImpossiblePredicate,
+    (MultiPoint, MultiPoint): ImpossiblePredicate,
     (MultiPoint, LineString): TouchesPredicateBase,
     (MultiPoint, Polygon): TouchesPredicateBase,
     (LineString, Point): TouchesPredicateBase,