Python API for pairwise_polygon_distance

python/cuspatial/cuspatial/__init__.py

@@ -12,6 +12,7 @@
     pairwise_point_linestring_distance,
     pairwise_point_linestring_nearest_points,
     pairwise_point_polygon_distance,
+    pairwise_polygon_distance,
     point_in_polygon,
     points_in_spatial_window,
     polygon_bounding_boxes,

python/cuspatial/cuspatial/_lib/cpp/distance/polygon_distance.pxd

@@ -0,0 +1,17 @@
+# Copyright (c) 2023, NVIDIA CORPORATION.
+
+from libcpp.memory cimport unique_ptr
+
+from cudf._lib.cpp.column.column cimport column
+
+from cuspatial._lib.cpp.column.geometry_column_view cimport (
+    geometry_column_view,
+)
+
+
+cdef extern from "cuspatial/distance/polygon_distance.hpp" \
+        namespace "cuspatial" nogil:
+    cdef unique_ptr[column] pairwise_polygon_distance(
+        const geometry_column_view & lhs,
+        const geometry_column_view & rhs
+    ) except +

python/cuspatial/cuspatial/_lib/distance.pyx

@@ -25,6 +25,9 @@ from cuspatial._lib.cpp.distance.point_linestring_distance cimport (
 from cuspatial._lib.cpp.distance.point_polygon_distance cimport (
     pairwise_point_polygon_distance as c_pairwise_point_polygon_distance,
 )
+from cuspatial._lib.cpp.distance.polygon_distance cimport (
+    pairwise_polygon_distance as c_pairwise_polygon_distance,
+)
 from cuspatial._lib.cpp.optional cimport optional
 from cuspatial._lib.cpp.types cimport collection_type_id, geometry_type_id
 from cuspatial._lib.types cimport collection_type_py_to_c
@@ -172,3 +175,26 @@ def pairwise_linestring_polygon_distance(
         ))
 
     return Column.from_unique_ptr(move(c_result))
+
+
+def pairwise_polygon_distance(Column lhs, Column rhs):
+    cdef shared_ptr[geometry_column_view] c_lhs = \
+        make_shared[geometry_column_view](
+            lhs.view(),
+            collection_type_id.MULTI,
+            geometry_type_id.POLYGON)
+
+    cdef shared_ptr[geometry_column_view] c_rhs = \
+        make_shared[geometry_column_view](
+            rhs.view(),
+            collection_type_id.MULTI,
+            geometry_type_id.POLYGON)
+
+    cdef unique_ptr[column] c_result
+
+    with nogil:
+        c_result = move(c_pairwise_polygon_distance(
+            c_lhs.get()[0], c_rhs.get()[0]
+        ))
+
+    return Column.from_unique_ptr(move(c_result))

python/cuspatial/cuspatial/core/spatial/__init__.py

@@ -9,6 +9,7 @@
     pairwise_point_distance,
     pairwise_point_linestring_distance,
     pairwise_point_polygon_distance,
+    pairwise_polygon_distance,
 )
 from .filtering import points_in_spatial_window
 from .indexing import quadtree_on_points
@@ -32,6 +33,7 @@
     "pairwise_point_polygon_distance",
     "pairwise_point_linestring_distance",
     "pairwise_point_linestring_nearest_points",
+    "pairwise_polygon_distance",
     "polygon_bounding_boxes",
     "linestring_bounding_boxes",
     "point_in_polygon",

python/cuspatial/cuspatial/core/spatial/distance.py

@@ -12,6 +12,7 @@
     pairwise_point_distance as cpp_pairwise_point_distance,
     pairwise_point_linestring_distance as c_pairwise_point_linestring_distance,
     pairwise_point_polygon_distance as c_pairwise_point_polygon_distance,
+    pairwise_polygon_distance as c_pairwise_polygon_distance,
 )
 from cuspatial._lib.hausdorff import (
     directed_hausdorff_distance as cpp_directed_hausdorff_distance,
@@ -555,6 +556,59 @@ def pairwise_linestring_polygon_distance(
     )
 
 
+def pairwise_polygon_distance(polygons1: GeoSeries, polygons2: GeoSeries):
+    """Compute distance between pairs of (multi)polygons and (multi)polygons
+    The distance between a (multi)polygon and a (multi)polygon
+    is defined as the shortest distance between every edge of the
+    (multi)polygon pair. If the multipolygon and multipolygon intersects,
+    the distance is 0.
+
+    This algorithm computes distance pairwise. The ith row in the result is
+    the distance between the ith (multi)polygon in `polygons1` and the ith
+    (multi)polygon in `polygons2`.
+
+    Parameters
+    ----------
+    polygons1 : GeoSeries
+        The (multi)polygons to compute the distance from.
+    polygons2 : GeoSeries
+        The (multi)polygons to compute the distance from.
+    Returns
+    -------
+    distance : cudf.Series
+
+    Notes
+    -----
+    The input `GeoSeries` must contain a single type geometry.
+    For example, `polygons1` series cannot contain both points and
+    polygons.
+
+    Examples
+    --------
+    Compute distance between a point and a polygon:
+    """
+
+    if len(polygons1) != len(polygons2):
+        raise ValueError("Unmatched input geoseries length.")
+
+    if len(polygons1) == 0:
+        return cudf.Series(dtype=polygons1.lines.xy.dtype)
+
+    if not contains_only_polygons(polygons1):
+        raise ValueError("`polygons1` array must contain only polygons")
+
+    if not contains_only_polygons(polygons2):
+        raise ValueError("`polygons2` array must contain only polygons")
+
+    # Handle slicing and aligns in geoseries
+    polygon1_column = polygons1.polygons.column()
+    polygon2_column = polygons2.polygons.column()
+
+    return Series._from_data(
+        {None: c_pairwise_polygon_distance(polygon1_column, polygon2_column)}
+    )
+
+
 def _flatten_point_series(
     points: GeoSeries,
 ) -> Tuple[

python/cuspatial/cuspatial/tests/spatial/distance/test_pairwise_polygon_distance.py

@@ -0,0 +1,149 @@
+import geopandas as gpd
+import pytest
+from shapely.geometry import MultiPolygon, Polygon
+
+import cudf
+from cudf.testing import assert_series_equal
+
+import cuspatial
+
+
+def test_polygon_empty():
+    lhs = cuspatial.GeoSeries.from_polygons_xy([], [0], [0], [0])
+    rhs = cuspatial.GeoSeries.from_polygons_xy([], [0], [0], [0])
+
+    got = cuspatial.pairwise_polygon_distance(lhs, rhs)
+
+    expect = cudf.Series([], dtype="f8")
+
+    assert_series_equal(got, expect)
+
+
+@pytest.mark.parametrize(
+    "polygons1",
+    [
+        [Polygon([(10, 11), (11, 10), (11, 11), (10, 11)])],
+        [
+            MultiPolygon(
+                [
+                    Polygon([(12, 10), (11, 10), (11, 11), (12, 10)]),
+                    Polygon([(11, 10), (12, 10), (11, 11), (11, 10)]),
+                ]
+            )
+        ],
+    ],
+)
+@pytest.mark.parametrize(
+    "polygons2",
+    [
+        [Polygon([(0, 1), (1, 0), (-1, 0), (0, 1)])],
+        [
+            MultiPolygon(
+                [
+                    Polygon([(-2, 0), (-1, 0), (-1, -1), (-2, 0)]),
+                    Polygon([(1, 0), (2, 0), (1, -1), (1, 0)]),
+                ]
+            )
+        ],
+    ],
+)
+def test_one_pair(polygons1, polygons2):
+    lhs = gpd.GeoSeries(polygons1)
+    rhs = gpd.GeoSeries(polygons2)
+
+    dlhs = cuspatial.GeoSeries(polygons1)
+    drhs = cuspatial.GeoSeries(polygons2)
+
+    expect = lhs.distance(rhs)
+    got = cuspatial.pairwise_polygon_distance(dlhs, drhs)
+
+    assert_series_equal(got, cudf.Series(expect))
+
+
+@pytest.mark.parametrize(
+    "polygons1",
+    [
+        [
+            Polygon([(0, 1), (1, 0), (-1, 0), (0, 1)]),
+            Polygon([(-4, -4), (-4, -5), (-5, -5), (-5, -4), (-5, -5)]),
+        ],
+        [
+            MultiPolygon(
+                [
+                    Polygon([(0, 1), (1, 0), (-1, 0), (0, 1)]),
+                    Polygon([(0, 1), (1, 0), (0, -1), (-1, 0), (0, 1)]),
+                ]
+            ),
+            MultiPolygon(
+                [
+                    Polygon(
+                        [(-4, -4), (-4, -5), (-5, -5), (-5, -4), (-5, -5)]
+                    ),
+                    Polygon([(-2, 0), (-2, -2), (0, -2), (0, 0), (-2, 0)]),
+                ]
+            ),
+        ],
+    ],
+)
+@pytest.mark.parametrize(
+    "polygons2",
+    [
+        [
+            Polygon([(0, 1), (1, 0), (-1, 0), (0, 1)]),
+            Polygon([(-4, -4), (-4, -5), (-5, -5), (-5, -4), (-5, -5)]),
+        ],
+        [
+            MultiPolygon(
+                [
+                    Polygon([(0, 1), (1, 0), (-1, 0), (0, 1)]),
+                    Polygon([(0, 1), (1, 0), (0, -1), (-1, 0), (0, 1)]),
+                ]
+            ),
+            MultiPolygon(
+                [
+                    Polygon(
+                        [(-4, -4), (-4, -5), (-5, -5), (-5, -4), (-5, -5)]
+                    ),
+                    Polygon([(-2, 0), (-2, -2), (0, -2), (0, 0), (-2, 0)]),
+                ]
+            ),
+        ],
+    ],
+)
+def test_two_pair(polygons1, polygons2):
+    lhs = gpd.GeoSeries(polygons1)
+    rhs = gpd.GeoSeries(polygons2)
+
+    dlhs = cuspatial.GeoSeries(polygons1)
+    drhs = cuspatial.GeoSeries(polygons2)
+
+    expect = lhs.distance(rhs)
+    got = cuspatial.pairwise_polygon_distance(dlhs, drhs)
+
+    assert_series_equal(got, cudf.Series(expect))
+
+
+def test_linestring_polygon_large(polygon_generator):
+    N = 100
+    polygons1 = gpd.GeoSeries(polygon_generator(N, 20.0, 5.0))
+    polygons2 = gpd.GeoSeries(polygon_generator(N, 10.0, 3.0))
+
+    dpolygons1 = cuspatial.from_geopandas(polygons1)
+    dpolygons2 = cuspatial.from_geopandas(polygons2)
+
+    expect = polygons1.distance(polygons2)
+    got = cuspatial.pairwise_polygon_distance(dpolygons1, dpolygons2)
+
+    assert_series_equal(got, cudf.Series(expect))
+
+
+def test_point_polygon_geoboundaries(naturalearth_lowres):
+    N = 50
+
+    lhs = naturalearth_lowres.geometry[:N].reset_index(drop=True)
+    rhs = naturalearth_lowres.geometry[N : 2 * N].reset_index(drop=True)
+    expect = lhs.distance(rhs)
+    got = cuspatial.pairwise_polygon_distance(
+        cuspatial.GeoSeries(lhs), cuspatial.GeoSeries(rhs)
+    )
+    assert_series_equal(cudf.Series(expect), got)