multipoint_range.cuh

Go to the documentation of this file.

/*
 * 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/cuda_utils.hpp>
#include <cuspatial/traits.hpp>
#include <cuspatial/types.hpp>
 
#include <thrust/iterator/counting_iterator.h>
 
namespace cuspatial {
 
template <typename GeometryIterator, typename VecIterator>
class multipoint_range {
 public:
  using geometry_it_t = GeometryIterator;
  using point_it_t    = VecIterator;
  using index_t       = iterator_value_type<geometry_it_t>;
  using point_t       = iterator_value_type<point_it_t>;
  using element_t     = iterator_vec_base_type<point_it_t>;
 
  CUSPATIAL_HOST_DEVICE multipoint_range(GeometryIterator geometry_begin,
                                         GeometryIterator geometry_end,
                                         VecIterator points_begin,
                                         VecIterator points_end);
 
  CUSPATIAL_HOST_DEVICE auto num_multipoints();
 
  CUSPATIAL_HOST_DEVICE auto num_points();
 
  CUSPATIAL_HOST_DEVICE auto size() { return num_multipoints(); }
 
  CUSPATIAL_HOST_DEVICE auto multipoint_begin();
 
  CUSPATIAL_HOST_DEVICE auto multipoint_end();
 
  CUSPATIAL_HOST_DEVICE auto begin() { return multipoint_begin(); }
 
  CUSPATIAL_HOST_DEVICE auto end() { return multipoint_end(); }
 
  CUSPATIAL_HOST_DEVICE auto point_begin();
 
  CUSPATIAL_HOST_DEVICE auto point_end();
 
  CUSPATIAL_HOST_DEVICE auto offsets_begin();
 
  CUSPATIAL_HOST_DEVICE auto offsets_end();
 
  template <typename IndexType>
  CUSPATIAL_HOST_DEVICE auto geometry_idx_from_point_idx(IndexType point_idx) const;
 
  template <typename IndexType>
  CUSPATIAL_HOST_DEVICE auto operator[](IndexType idx);
 
  template <typename IndexType>
  CUSPATIAL_HOST_DEVICE auto point(IndexType idx);
 
  CUSPATIAL_HOST_DEVICE bool is_single_point_range();
 
 protected:
  GeometryIterator _geometry_begin;
  GeometryIterator _geometry_end;
  VecIterator _points_begin;
  VecIterator _points_end;
};
 
template <typename GeometryIteratorDiffType,
          typename VecIteratorDiffType,
          typename GeometryIterator,
          typename VecIterator>
multipoint_range<GeometryIterator, VecIterator> make_multipoint_range(
  GeometryIteratorDiffType num_multipoints,
  GeometryIterator geometry_begin,
  VecIteratorDiffType num_points,
  VecIterator point_begin)
{
  return multipoint_range<GeometryIterator, VecIterator>{
    geometry_begin, geometry_begin + num_multipoints + 1, point_begin, point_begin + num_points};
}
 
template <typename IntegerRange, typename PointRange>
auto make_multipoint_range(IntegerRange geometry_offsets, PointRange points)
{
  return multipoint_range(
    geometry_offsets.begin(), geometry_offsets.end(), points.begin(), points.end());
}
 
template <collection_type_id Type,
          typename T,
          typename IndexType,
          CUSPATIAL_ENABLE_IF(Type == collection_type_id::SINGLE),
          typename GeometryColumnView>
auto make_multipoint_range(GeometryColumnView const& points_column)
{
  CUSPATIAL_EXPECTS(points_column.geometry_type() == geometry_type_id::POINT,
                    "Must be POINT geometry type.");
  auto geometry_iter    = thrust::make_counting_iterator(0);
  auto const& points_xy = points_column.child();  // Ignores x-y offset {0, 2, 4...}
 
  auto points_it = make_vec_2d_iterator(points_xy.template begin<T>());
 
  return multipoint_range(geometry_iter,
                          thrust::next(geometry_iter, points_column.size() + 1),
                          points_it,
                          points_it + points_xy.size() / 2);
}
 
template <collection_type_id Type,
          typename T,
          typename IndexType,
          CUSPATIAL_ENABLE_IF(Type == collection_type_id::MULTI),
          typename GeometryColumnView>
auto make_multipoint_range(GeometryColumnView const& points_column)
{
  CUSPATIAL_EXPECTS(points_column.geometry_type() == geometry_type_id::POINT,
                    "Must be POINT geometry type.");
  auto const& geometry_offsets = points_column.offsets();
  auto const& points_xy        = points_column.child().child(1);  // Ignores x-y offset {0, 2, 4...}
 
  auto points_it = make_vec_2d_iterator(points_xy.template begin<T>());
 
  return multipoint_range(geometry_offsets.template begin<IndexType>(),
                          geometry_offsets.template end<IndexType>(),
                          points_it,
                          points_it + points_xy.size() / 2);
};
 
}  // namespace cuspatial
 
#include <cuspatial/detail/range/multipoint_range.cuh>