Column API for linestring-polygon distance

cpp/CMakeLists.txt

@@ -134,6 +134,7 @@ add_library(cuspatial
     src/spatial/point_distance.cu
     src/spatial/point_linestring_distance.cu
     src/spatial/point_polygon_distance.cu
+    src/spatial/linestring_polygon_distance.cu
     src/spatial/point_linestring_nearest_points.cu
     src/spatial/sinusoidal_projection.cu
     src/trajectory/derive_trajectories.cu

cpp/include/cuspatial/distance/linestring_polygon_distance.hpp

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2023, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cuspatial/column/geometry_column_view.hpp>
+
+#include <cudf/column/column_view.hpp>
+
+#include <optional>
+
+namespace cuspatial {
+
+/**
+ * @ingroup distance
+ * @brief Compute pairwise (multi)linestring-to-(multi)polygon Cartesian distance
+ *
+ * @param multilinestrings Geometry column of multilinestrings
+ * @param multipolygons Geometry column of multipolygons
+ * @param mr Device memory resource used to allocate the returned column.
+ * @return Column of distances between each pair of input geometries, same type as input coordinate
+ * types.
+ *
+ * @throw cuspatial::logic_error if `multilinestrings` and `multipolygons` have different coordinate
+ * types.
+ * @throw cuspatial::logic_error if `multilinestrings` is not a linestring column and
+ * `multipolygons` is not a polygon column.
+ * @throw cuspatial::logic_error if input column sizes mismatch.
+ */
+
+std::unique_ptr<cudf::column> pairwise_linestring_polygon_distance(
+  geometry_column_view const& multilinestrings,
+  geometry_column_view const& multipolygons,
+  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
+
+}  // namespace cuspatial

cpp/include/cuspatial/experimental/detail/ranges/multipoint_range.cuh

@@ -54,10 +54,11 @@ struct to_multipoint_functor {
 }  // namespace detail
 
 template <typename GeometryIterator, typename VecIterator>
-multipoint_range<GeometryIterator, VecIterator>::multipoint_range(GeometryIterator geometry_begin,
-                                                                  GeometryIterator geometry_end,
-                                                                  VecIterator points_begin,
-                                                                  VecIterator points_end)
+CUSPATIAL_HOST_DEVICE multipoint_range<GeometryIterator, VecIterator>::multipoint_range(
+  GeometryIterator geometry_begin,
+  GeometryIterator geometry_end,
+  VecIterator points_begin,
+  VecIterator points_end)
   : _geometry_begin(geometry_begin),
     _geometry_end(geometry_end),
     _points_begin(points_begin),

cpp/include/cuspatial/experimental/ranges/multipoint_range.cuh

@@ -57,10 +57,10 @@ class multipoint_range {
   /**
    * @brief Construct a new multipoint array object
    */
-  multipoint_range(GeometryIterator geometry_begin,
-                   GeometryIterator geometry_end,
-                   VecIterator points_begin,
-                   VecIterator points_end);
+  CUSPATIAL_HOST_DEVICE multipoint_range(GeometryIterator geometry_begin,
+                                         GeometryIterator geometry_end,
+                                         VecIterator points_begin,
+                                         VecIterator points_end);
   /**
    * @brief Returns the number of multipoints in the array.
    */

cpp/src/spatial/linestring_polygon_distance.cu

@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2023, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "../utility/iterator.hpp"
+#include "../utility/multi_geometry_dispatch.hpp"
+
+#include <cudf/column/column.hpp>
+#include <cudf/column/column_device_view.cuh>
+#include <cudf/column/column_factories.hpp>
+#include <cudf/column/column_view.hpp>
+#include <cudf/copying.hpp>
+#include <cudf/types.hpp>
+#include <cudf/utilities/traits.hpp>
+#include <cudf/utilities/type_dispatcher.hpp>
+
+#include <rmm/cuda_stream_view.hpp>
+
+#include <cuspatial/column/geometry_column_view.hpp>
+#include <cuspatial/detail/iterator.hpp>
+#include <cuspatial/error.hpp>
+#include <cuspatial/experimental/iterator_factory.cuh>
+#include <cuspatial/experimental/linestring_polygon_distance.cuh>
+#include <cuspatial/experimental/ranges/multilinestring_range.cuh>
+#include <cuspatial/experimental/ranges/multipolygon_range.cuh>
+#include <cuspatial/types.hpp>
+
+#include <thrust/iterator/counting_iterator.h>
+
+#include <memory>
+#include <type_traits>
+
+namespace cuspatial {
+
+namespace detail {
+
+namespace {
+
+template <collection_type_id is_multi_linestring, collection_type_id is_multi_polygon>
+struct pairwise_linestring_polygon_distance_impl {
+  using SizeType = cudf::device_span<cudf::size_type const>::size_type;
+
+  template <typename T, CUDF_ENABLE_IF(std::is_floating_point_v<T>)>
+  std::unique_ptr<cudf::column> operator()(geometry_column_view const& multilinestrings,
+                                           geometry_column_view const& multipolygons,
+                                           rmm::cuda_stream_view stream,
+                                           rmm::mr::device_memory_resource* mr)
+  {
+    auto multilinestrings_range =
+      make_multilinestring_range<is_multi_linestring, T, cudf::size_type>(multilinestrings);
+    auto multipolygons_range =
+      make_multipolygon_range<is_multi_polygon, T, cudf::size_type>(multipolygons);
+
+    auto output = cudf::make_numeric_column(multilinestrings.coordinate_type(),
+                                            multilinestrings.size(),
+                                            cudf::mask_state::UNALLOCATED,
+                                            stream,
+                                            mr);
+
+    cuspatial::pairwise_linestring_polygon_distance(
+      multilinestrings_range, multipolygons_range, output->mutable_view().begin<T>(), stream);
+    return output;
+  }
+
+  template <typename T, CUDF_ENABLE_IF(!std::is_floating_point_v<T>), typename... Args>
+  std::unique_ptr<cudf::column> operator()(Args&&...)
+
+  {
+    CUSPATIAL_FAIL("linestring-polygon distance API only supports floating point coordinates.");
+  }
+};
+
+}  // namespace
+
+template <collection_type_id is_multi_linestring, collection_type_id is_multi_polygon>
+struct pairwise_linestring_polygon_distance {
+  std::unique_ptr<cudf::column> operator()(geometry_column_view const& multilinestrings,
+                                           geometry_column_view const& multipolygons,
+                                           rmm::cuda_stream_view stream,
+                                           rmm::mr::device_memory_resource* mr)
+  {
+    return cudf::type_dispatcher(
+      multilinestrings.coordinate_type(),
+      pairwise_linestring_polygon_distance_impl<is_multi_linestring, is_multi_polygon>{},
+      multilinestrings,
+      multipolygons,
+      stream,
+      mr);
+  }
+};
+
+}  // namespace detail
+
+std::unique_ptr<cudf::column> pairwise_linestring_polygon_distance(
+  geometry_column_view const& multilinestrings,
+  geometry_column_view const& multipolygons,
+  rmm::mr::device_memory_resource* mr)
+{
+  CUSPATIAL_EXPECTS(multilinestrings.geometry_type() == geometry_type_id::LINESTRING &&
+                      multipolygons.geometry_type() == geometry_type_id::POLYGON,
+                    "Unexpected input geometry types.");
+
+  CUSPATIAL_EXPECTS(multilinestrings.coordinate_type() == multipolygons.coordinate_type(),
+                    "Input geometries must have the same coordinate data types.");
+
+  return multi_geometry_double_dispatch<detail::pairwise_linestring_polygon_distance>(
+    multilinestrings.collection_type(),
+    multipolygons.collection_type(),
+    multilinestrings,
+    multipolygons,
+    rmm::cuda_stream_default,
+    mr);
+}
+
+}  // namespace cuspatial

cpp/tests/CMakeLists.txt

@@ -90,6 +90,9 @@ ConfigureTest(LINESTRING_DISTANCE_TEST
 ConfigureTest(POINT_POLYGON_DISTANCE_TEST
     spatial/point_polygon_distance_test.cpp)
 
+ConfigureTest(LINESTRING_POLYGON_DISTANCE_TEST
+    spatial/linestring_polygon_distance_test.cpp)
+
 ConfigureTest(LINESTRING_INTERSECTION_TEST
     spatial/linestring_intersection_test.cpp)