Header-only polygon_bounding_boxes and linestring_bounding_boxes, make_geometry_id_iterator utility, and box<T> class.

cpp/include/cuspatial/experimental/detail/bounding_box.cuh

@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <cuspatial/experimental/iterator_factory.cuh>
 #include <cuspatial/traits.hpp>
 #include <cuspatial/vec_2d.hpp>
 
@@ -33,32 +34,24 @@ namespace detail {
 
 template <typename T>
 struct point_bounding_box {
-  using point_tuple = thrust::tuple<cuspatial::vec_2d<T>, cuspatial::vec_2d<T>>;
-
   vec_2d<T> box_offset{};
 
   CUSPATIAL_HOST_DEVICE point_bounding_box(T expansion_radius = T{0})
     : box_offset{expansion_radius, expansion_radius}
   {
   }
 
-  inline __host__ __device__ point_tuple operator()(vec_2d<T> const& point)
+  inline CUSPATIAL_HOST_DEVICE box<T> operator()(vec_2d<T> const& point)
   {
-    return point_tuple{point - box_offset, point + box_offset};
+    return box<T>{point - box_offset, point + box_offset};
   }
 };
 
 template <typename T>
 struct box_minmax {
-  using point_tuple = thrust::tuple<cuspatial::vec_2d<T>, cuspatial::vec_2d<T>>;
-
-  inline __host__ __device__ point_tuple operator()(point_tuple const& a, point_tuple const& b)
+  inline CUSPATIAL_HOST_DEVICE box<T> operator()(box<T> const& a, box<T> const& b)
   {
-    // structured binding doesn't seem to work with thrust::tuple
-    vec_2d<T> p1, p2, p3, p4;
-    thrust::tie(p1, p2) = a;
-    thrust::tie(p3, p4) = b;
-    return {box_min(box_min(p1, p2), p3), box_max(box_max(p1, p2), p4)};
+    return {box_min(box_min(a.v1, a.v2), b.v1), box_max(box_max(a.v1, a.v2), b.v2)};
   }
 };
 

cpp/include/cuspatial/experimental/detail/linestring_bounding_boxes.cuh

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2022, 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/experimental/bounding_box.cuh>
+#include <cuspatial/experimental/iterator_factory.cuh>
+#include <cuspatial/traits.hpp>
+
+#include <rmm/cuda_stream_view.hpp>
+#include <rmm/device_vector.hpp>
+#include <rmm/exec_policy.hpp>
+
+#include <thrust/gather.h>
+#include <thrust/scan.h>
+#include <thrust/scatter.h>
+
+namespace cuspatial {
+
+template <class LinestringOffsetIterator,
+          class VertexIterator,
+          class BoundingBoxIterator,
+          class T,
+          class IndexT>
+BoundingBoxIterator linestring_bounding_boxes(LinestringOffsetIterator linestring_offsets_first,
+                                              LinestringOffsetIterator linestring_offsets_last,
+                                              VertexIterator linestring_vertices_first,
+                                              VertexIterator linestring_vertices_last,
+                                              BoundingBoxIterator bounding_boxes_first,
+                                              T expansion_radius,
+                                              rmm::cuda_stream_view stream)
+{
+  static_assert(is_floating_point<T>(), "Only floating point polygon vertices supported");
+
+  static_assert(is_same<vec_2d<T>, iterator_value_type<VertexIterator>>(),
+                "Input vertices must be cuspatial::vec_2d");
+
+  static_assert(cuspatial::is_integral<iterator_value_type<LinestringOffsetIterator>>(),
+                "Offset iterators must have integral value type.");
+
+  // GeoArrow: Number of linestrings is number of offsets minus one.
+  auto const num_linestrings = std::distance(linestring_offsets_first, linestring_offsets_last) - 1;
+  auto const num_vertices    = std::distance(linestring_vertices_first, linestring_vertices_last);
+
+  if (num_linestrings == 0 || num_vertices == 0) { return bounding_boxes_first; }
+
+  auto vertex_ids_iter =
+    make_geometry_id_iterator<IndexT>(linestring_offsets_first, linestring_offsets_last);
+
+  return point_bounding_boxes(vertex_ids_iter,
+                              vertex_ids_iter + num_vertices,
+                              linestring_vertices_first,
+                              bounding_boxes_first,
+                              expansion_radius,
+                              stream);
+}
+}  // namespace cuspatial

cpp/include/cuspatial/experimental/detail/polygon_bounding_boxes.cuh

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2022, 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/experimental/bounding_box.cuh>
+#include <cuspatial/experimental/iterator_factory.cuh>
+#include <cuspatial/traits.hpp>
+
+#include <rmm/cuda_stream_view.hpp>
+#include <rmm/device_vector.hpp>
+#include <rmm/exec_policy.hpp>
+
+#include <thrust/gather.h>
+#include <thrust/scan.h>
+#include <thrust/scatter.h>
+
+namespace cuspatial {
+
+template <class PolygonOffsetIterator,
+          class RingOffsetIterator,
+          class VertexIterator,
+          class BoundingBoxIterator,
+          class T,
+          class IndexT>
+BoundingBoxIterator polygon_bounding_boxes(PolygonOffsetIterator polygon_offsets_first,
+                                           PolygonOffsetIterator polygon_offsets_last,
+                                           RingOffsetIterator polygon_ring_offsets_first,
+                                           RingOffsetIterator polygon_ring_offsets_last,
+                                           VertexIterator polygon_vertices_first,
+                                           VertexIterator polygon_vertices_last,
+                                           BoundingBoxIterator bounding_boxes_first,
+                                           T expansion_radius,
+                                           rmm::cuda_stream_view stream)
+{
+  static_assert(is_floating_point<T>(), "Only floating point polygon vertices supported");
+
+  static_assert(is_same<vec_2d<T>, iterator_value_type<VertexIterator>>(),
+                "Input vertices must be cuspatial::vec_2d");
+
+  static_assert(cuspatial::is_integral<iterator_value_type<PolygonOffsetIterator>,
+                                       iterator_value_type<RingOffsetIterator>>(),
+                "OffsetIterators must have integral value type.");
+
+  auto const num_polys = std::distance(polygon_offsets_first, polygon_offsets_last) - 1;
+  auto const num_rings = std::distance(polygon_ring_offsets_first, polygon_ring_offsets_last) - 1;
+  auto const num_vertices = std::distance(polygon_vertices_first, polygon_vertices_last);
+
+  CUSPATIAL_EXPECTS(num_rings >= num_polys, "Each polygon must have at least one ring");
+
+  CUSPATIAL_EXPECTS(num_vertices >= num_polys * 3, "Each ring must have at least three vertices");
+
+  if (num_polys == 0 || num_rings == 0 || num_vertices == 0) { return bounding_boxes_first; }
+
+  auto vertex_ids_iter = make_geometry_id_iterator<IndexT>(
+    polygon_offsets_first, polygon_offsets_last, polygon_ring_offsets_first);
+
+  return point_bounding_boxes(vertex_ids_iter,
+                              vertex_ids_iter + num_vertices,
+                              polygon_vertices_first,
+                              bounding_boxes_first,
+                              expansion_radius,
+                              stream);
+}
+}  // namespace cuspatial

cpp/include/cuspatial/experimental/geometry/box.hpp

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2022, 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/vec_2d.hpp>
+
+namespace cuspatial {
+
+/**
+ * @addtogroup types
+ * @{
+ */
+
+/**
+ * @brief A generic axis-aligned box type.
+ *
+ * @tparam T the base type for the coordinates
+ * @tparam Vertex the vector type to use for vertices, vec_2d<T> by default
+ */
+template <typename T, typename Vertex = cuspatial::vec_2d<T>>
+class alignas(sizeof(Vertex)) box {
+ public:
+  using value_type = T;
+  Vertex v1;
+  Vertex v2;
+};
+
+// deduction guide, enables CTAD
+template <typename T>
+box(vec_2d<T> a, vec_2d<T> b) -> box<T, vec_2d<T>>;
+
+/**
+ * @} // end of doxygen group
+ */
+
+}  // namespace cuspatial

cpp/include/cuspatial/experimental/geometry/segment.cuh

@@ -21,21 +21,37 @@
 
 namespace cuspatial {
 
-template <typename T>
-class segment {
+/**
+ * @addtogroup types
+ * @{
+ */
+
+/**
+ * @brief A generic segment type.
+ *
+ * @tparam T the base type for the coordinates
+ * @tparam Vertex the vector type to use for vertices, vec_2d<T> by default
+ */
+
+template <typename T, typename Vertex = cuspatial::vec_2d<T>>
+class alignas(sizeof(Vertex)) segment {
  public:
   using value_type = T;
-  vec_2d<T> first;
-  vec_2d<T> second;
+  Vertex v1;
+  Vertex v2;
 
   /// Return a copy of segment, translated by `v`.
-  segment<T> CUSPATIAL_HOST_DEVICE translate(vec_2d<T> const& v) const
+  segment<T> CUSPATIAL_HOST_DEVICE translate(Vertex const& v) const
   {
-    return segment<T>{first + v, second + v};
+    return segment<T>{v1 + v, v2 + v};
   }
 
   /// Return the geometric center of segment.
-  vec_2d<T> CUSPATIAL_HOST_DEVICE center() const { return midpoint(first, second); }
+  Vertex CUSPATIAL_HOST_DEVICE center() const { return midpoint(v1, v2); }
 };
 
+// deduction guide, enables CTAD
+template <typename T>
+segment(vec_2d<T> a, vec_2d<T> b) -> segment<T, vec_2d<T>>;
+
 }  // namespace cuspatial