multipolygon_range.cuh

转到此文件的文档。

/*
 * Copyright (c) 2023-2024, 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
 *
 * https://apache.ac.cn/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/detail/range/enumerate_range.cuh>
#include <cuspatial/geometry/vec_2d.hpp>
#include <cuspatial/traits.hpp>
#include <cuspatial/types.hpp>
 
#include <rmm/cuda_stream_view.hpp>
 
#include <thrust/pair.h>
 
namespace cuspatial {


template <typename GeometryIterator,
 typename PartIterator,
 typename RingIterator,
 typename VecIterator>
class multipolygon_range {
 public
 using geometry_it_t = GeometryIterator;
 using part_it_t = PartIterator;
 using ring_it_t = RingIterator;
 using point_it_t = VecIterator;
 using point_t = iterator_value_type<VecIterator>;
 
 using index_t = iterator_value_type<GeometryIterator>;
 using element_t = iterator_vec_base_type<VecIterator>;
 
 multipolygon_range(GeometryIterator geometry_begin,
 GeometryIterator geometry_end,
 PartIterator part_begin,
 PartIterator part_end,
 RingIterator ring_begin,
 RingIterator ring_end,
 VecIterator points_begin,
 VecIterator points_end);

 CUSPATIAL_HOST_DEVICE auto size() { return num_multipolygons(); }

 CUSPATIAL_HOST_DEVICE auto num_multipolygons();

 CUSPATIAL_HOST_DEVICE auto num_polygons();

 CUSPATIAL_HOST_DEVICE auto num_rings();

 CUSPATIAL_HOST_DEVICE auto num_points();

 CUSPATIAL_HOST_DEVICE auto multipolygon_begin();

 CUSPATIAL_HOST_DEVICE auto multipolygon_end();

 CUSPATIAL_HOST_DEVICE auto begin() { return multipolygon_begin(); }

 CUSPATIAL_HOST_DEVICE auto end() { return multipolygon_end(); }

 CUSPATIAL_HOST_DEVICE auto point_begin();

 CUSPATIAL_HOST_DEVICE auto point_end();

 CUSPATIAL_HOST_DEVICE auto geometry_offset_begin() { return _geometry_begin; }

 CUSPATIAL_HOST_DEVICE auto geometry_offset_end() { return _geometry_end; }

 CUSPATIAL_HOST_DEVICE auto part_offset_begin() { return _part_begin; }

 CUSPATIAL_HOST_DEVICE auto part_offset_end() { return _part_end; }

 CUSPATIAL_HOST_DEVICE auto ring_offset_begin() { return _ring_begin; }

 CUSPATIAL_HOST_DEVICE auto ring_offset_end() { return _ring_end; }

 template <typename IndexType>
 CUSPATIAL_HOST_DEVICE auto ring_idx_from_point_idx(IndexType point_idx);

 template <typename IndexType>
 CUSPATIAL_HOST_DEVICE auto part_idx_from_ring_idx(IndexType ring_idx);

 template <typename IndexType>
 CUSPATIAL_HOST_DEVICE auto geometry_idx_from_part_idx(IndexType part_idx);

 template <typename IndexType>
 CUSPATIAL_HOST_DEVICE auto operator[](IndexType multipolygon_idx);

 CUSPATIAL_HOST_DEVICE auto multipolygon_point_count_begin();
 CUSPATIAL_HOST_DEVICE auto multipolygon_point_count_end();

 CUSPATIAL_HOST_DEVICE auto multipolygon_ring_count_begin();
 CUSPATIAL_HOST_DEVICE auto multipolygon_ring_count_end();

 auto _segments(rmm::cuda_stream_view);


 CUSPATIAL_HOST_DEVICE auto as_multipoint_range();

 CUSPATIAL_HOST_DEVICE auto as_multilinestring_range();
 
 protected
 GeometryIterator _geometry_begin;
 GeometryIterator _geometry_end;
 PartIterator _part_begin;
 PartIterator _part_end;
 RingIterator _ring_begin;
 RingIterator _ring_end;
 VecIterator _point_begin;
 VecIterator _point_end;
 
 private
 template <typename IndexType1, typename IndexType2>
 CUSPATIAL_HOST_DEVICE bool is_valid_segment_id(IndexType1 segment_idx, IndexType2 ring_idx);
};

template <typename GeometryIteratorDiffType,
 typename PartIteratorDiffType,
 typename RingIteratorDiffType,
 typename VecIteratorDiffType,
 typename GeometryIterator,
 typename PartIterator,
 typename RingIterator,
 typename VecIterator>
multipolygon_range<GeometryIterator, PartIterator, RingIterator, VecIterator>
make_multipolygon_range(GeometryIteratorDiffType num_multipolygons,
 GeometryIterator geometry_begin,
 PartIteratorDiffType num_polygons,
 PartIterator part_begin,
 RingIteratorDiffType num_rings,
 RingIterator ring_begin,
 VecIteratorDiffType num_points,
 VecIterator point_begin)
{
 return multipolygon_range{
 geometry_begin,
 thrust::next(geometry_begin, num_multipolygons + 1),
 part_begin,
 thrust::next(part_begin, num_polygons + 1),
 ring_begin,
 thrust::next(ring_begin, num_rings + 1),
 point_begin,
 thrust::next(point_begin, num_points),
  };
}

template <collection_type_id Type,
 typename T,
 typename IndexType,
 typename GeometryColumnView,
 CUSPATIAL_ENABLE_IF(Type == collection_type_id::SINGLE)>
auto make_multipolygon_range(GeometryColumnView const& polygons_column)
{
 CUSPATIAL_EXPECTS(polygons_column.geometry_type() == geometry_type_id::POLYGON,
 "必须是多边形几何类型。");
 auto geometry_iter = thrust::make_counting_iterator(0);
 auto const& part_offsets = polygons_column.offsets();
 auto const& ring_offsets = polygons_column.child().child(0);
 auto const& points_xy =
 polygons_column.child().child(1).child(1); // 忽略 x-y 偏移量 {0, 2, 4...}
 
 auto points_it = make_vec_2d_iterator(points_xy.template begin<T>());
 
 return multipolygon_range(geometry_iter,
 geometry_iter + part_offsets.size(),
 part_offsets.template begin<IndexType>(),
 part_offsets.template end<IndexType>(),
 ring_offsets.template begin<IndexType>(),
 ring_offsets.template end<IndexType>(),
 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_multipolygon_range(GeometryColumnView const& polygons_column)
{
 CUSPATIAL_EXPECTS(polygons_column.geometry_type() == geometry_type_id::POLYGON,
 "必须是多边形几何类型。");
 auto const& geometry_offsets = polygons_column.offsets();
 auto const& part_offsets = polygons_column.child().child(0);
 auto const& ring_offsets = polygons_column.child().child(1).child(0);
 auto const& points_xy =
 polygons_column.child().child(1).child(1).child(1); // 忽略 x-y 偏移量 {0, 2, 4...}
 
 auto points_it = make_vec_2d_iterator(points_xy.template begin<T>());
 
 return multipolygon_range(geometry_offsets.template begin<IndexType>(),
 geometry_offsets.template end<IndexType>(),
 part_offsets.template begin<IndexType>(),
 part_offsets.template end<IndexType>(),
 ring_offsets.template begin<IndexType>(),
 ring_offsets.template end<IndexType>(),
 points_it,
 points_it + points_xy.size() / 2);
};

 
} // namespace cuspatial
 
#include <cuspatial/detail/range/multipolygon_range.cuh>