boost_mirror/geometry
1
0
Fork 0
mirror of https://github.com/boostorg/geometry.git synced 2025-05-09 15:14:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1368 from awulkiew/fix/rtree_strategies

Browse Source 
fix: pass umbrella strategies in rtree spatial predicates
This commit is contained in:
Adam Wulkiewicz 2025-01-20 22:58:18 +01:00 committed by GitHub
commit eeeb75a917
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
4 changed files with 178 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
include/boost/geometry/index/detail/predicates.hpp
View File

@ -174,9 +174,9 @@ template <>
struct spatial_predicate_call<predicates::contains_tag>
{
template <typename G1, typename G2, typename S>
static inline bool apply(G1 const& g1, G2 const& g2, S const&)
static inline bool apply(G1 const& g1, G2 const& g2, S const& s)
{
return geometry::within(g2, g1);
return geometry::within(g2, g1, s);
}
};
@ -184,9 +184,9 @@ template <>
struct spatial_predicate_call<predicates::covered_by_tag>
{
template <typename G1, typename G2, typename S>
static inline bool apply(G1 const& g1, G2 const& g2, S const&)
static inline bool apply(G1 const& g1, G2 const& g2, S const& s)
{
return geometry::covered_by(g1, g2);
return geometry::covered_by(g1, g2, s);
}
};
@ -194,9 +194,9 @@ template <>
struct spatial_predicate_call<predicates::covers_tag>
{
template <typename G1, typename G2, typename S>
static inline bool apply(G1 const& g1, G2 const& g2, S const&)
static inline bool apply(G1 const& g1, G2 const& g2, S const& s)
{
return geometry::covered_by(g2, g1);
return geometry::covered_by(g2, g1, s);
}
};
@ -204,41 +204,9 @@ template <>
struct spatial_predicate_call<predicates::disjoint_tag>
{
template <typename G1, typename G2, typename S>
static inline bool apply(G1 const& g1, G2 const& g2, S const&)
{
return geometry::disjoint(g1, g2);
}
};
// TEMP: used to implement CS-specific intersects predicate for certain
// combinations of geometries until umbrella strategies are implemented
template
<
typename G1, typename G2,
typename Tag1 = tag_t<G1>,
typename Tag2 = tag_t<G2>
>
struct spatial_predicate_intersects
{
template <typename S>
static inline bool apply(G1 const& g1, G2 const& g2, S const&)
{
return geometry::intersects(g1, g2);
}
};
// TEMP: used in within and relate
template <typename G1, typename G2>
struct spatial_predicate_intersects<G1, G2, box_tag, point_tag>
{
static inline bool apply(G1 const& g1, G2 const& g2, default_strategy const&)
{
return geometry::intersects(g1, g2);
}
template <typename S>
static inline bool apply(G1 const& g1, G2 const& g2, S const& s)
{
return geometry::intersects(g1, g2, s);
return geometry::disjoint(g1, g2, s);
}
};
@ -248,7 +216,7 @@ struct spatial_predicate_call<predicates::intersects_tag>
template <typename G1, typename G2, typename S>
static inline bool apply(G1 const& g1, G2 const& g2, S const& s)
{
return spatial_predicate_intersects<G1, G2>::apply(g1, g2, s);
return geometry::intersects(g1, g2, s);
}
};
@ -256,9 +224,9 @@ template <>
struct spatial_predicate_call<predicates::overlaps_tag>
{
template <typename G1, typename G2, typename S>
static inline bool apply(G1 const& g1, G2 const& g2, S const&)
static inline bool apply(G1 const& g1, G2 const& g2, S const& s)
{
return geometry::overlaps(g1, g2);
return geometry::overlaps(g1, g2, s);
}
};
@ -266,9 +234,9 @@ template <>
struct spatial_predicate_call<predicates::touches_tag>
{
template <typename G1, typename G2, typename S>
static inline bool apply(G1 const& g1, G2 const& g2, S const&)
static inline bool apply(G1 const& g1, G2 const& g2, S const& s)
{
return geometry::touches(g1, g2);
return geometry::touches(g1, g2, s);
}
};
@ -276,9 +244,9 @@ template <>
struct spatial_predicate_call<predicates::within_tag>
{
template <typename G1, typename G2, typename S>
static inline bool apply(G1 const& g1, G2 const& g2, S const&)
static inline bool apply(G1 const& g1, G2 const& g2, S const& s)
{
return geometry::within(g1, g2);
return geometry::within(g1, g2, s);
}
};

2
index/test/rtree/CMakeLists.txt
View File

@ -1,4 +1,5 @@
# Boost.Geometry
# Copyright (c) 2025 Adam Wulkiewicz, Lodz, Poland.
# Copyright (c) 2024, Oracle and/or its affiliates.
# Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
# Use, modification and distribution is subject to the Boost Software License,
@ -13,6 +14,7 @@ foreach(item IN ITEMS
rtree_move_pack
rtree_non_cartesian
rtree_values
rtree_with_strategies
#compile-fail rtree_values_invalid
)
boost_geometry_add_unit_test("index" ${item})

3
index/test/rtree/Jamfile
View File

@ -1,6 +1,6 @@
# Boost.Geometry Index
#
# Copyright (c) 2011-2016 Adam Wulkiewicz, Lodz, Poland.
# Copyright (c) 2011-2025 Adam Wulkiewicz, Lodz, Poland.
#
# Use, modification and distribution is subject to the Boost Software License,
# Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@ -19,5 +19,6 @@ test-suite boost-geometry-index-rtree
[ run rtree_move_pack.cpp ]
[ run rtree_non_cartesian.cpp ]
[ run rtree_values.cpp ]
[ compile rtree_with_strategies.cpp ]
[ compile-fail rtree_values_invalid.cpp ]
;

160
index/test/rtree/rtree_with_strategies.cpp Normal file
View File

@ -0,0 +1,160 @@
// Boost.Geometry Index
// Unit Test
// Copyright (c) 2025 Adam Wulkiewicz, Lodz, Poland.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <vector>
#define BOOST_GEOMETRY_INDEX_DETAIL_EXPERIMENTAL_PREDICATES
#include <geometry_index_test_common.hpp>
#include <boost/geometry/geometries/register/point.hpp>
#include <boost/geometry/geometries/register/box.hpp>
#include <boost/geometry/geometries/register/segment.hpp>
struct point { double x, y; };
struct box { point mi, ma; };
struct segment { point first, second; };
BOOST_GEOMETRY_REGISTER_POINT_2D(point, double, cs::undefined, x, y)
BOOST_GEOMETRY_REGISTER_BOX(box, point, mi, ma)
BOOST_GEOMETRY_REGISTER_SEGMENT(segment, point, first, second)
template <typename QueryValue, typename Rtree>
constexpr bool is_bp_or_bb_v = (bg::util::is_box<QueryValue>::value
&& bg::util::is_point<typename Rtree::value_type>::value)
|| (bg::util::is_box<QueryValue>::value
&& bg::util::is_box<typename Rtree::value_type>::value);
template <typename QueryValue, typename Rtree>
constexpr bool is_pb_or_bb_v = (bg::util::is_point<QueryValue>::value
&& bg::util::is_box<typename Rtree::value_type>::value)
|| (bg::util::is_box<QueryValue>::value
&& bg::util::is_box<typename Rtree::value_type>::value);
template <typename QueryValue, typename Rtree>
constexpr bool is_pp_or_bb_v = (bg::util::is_point<QueryValue>::value
&& bg::util::is_point<typename Rtree::value_type>::value)
|| (bg::util::is_box<QueryValue>::value
&& bg::util::is_box<typename Rtree::value_type>::value);
template
<
typename QueryValue, typename Rtree,
std::enable_if_t<is_bp_or_bb_v<QueryValue, Rtree>, int> = 0
>
void test_queries_bp_bb(Rtree const& rtree)
{
// These predicates use algorithms that are not implemented for
// some geometry combinations
std::vector<typename Rtree::value_type> values;
rtree.query(bgi::covered_by(QueryValue{}), std::back_inserter(values));
rtree.query(bgi::disjoint(QueryValue{}), std::back_inserter(values));
rtree.query(bgi::within(QueryValue{}), std::back_inserter(values));
}
template
<
typename QueryValue, typename Rtree,
std::enable_if_t<(!is_bp_or_bb_v<QueryValue, Rtree>), int> = 0
>
void test_queries_bp_bb(Rtree const& ) {}
template
<
typename QueryValue, typename Rtree,
std::enable_if_t<is_pb_or_bb_v<QueryValue, Rtree>, int> = 0
>
void test_queries_pb_bb(Rtree const& rtree)
{
// These predicates use algorithms that are not implemented for
// some geometry combinations
std::vector<typename Rtree::value_type> values;
rtree.query(bgi::contains(QueryValue{}), std::back_inserter(values));
rtree.query(bgi::covers(QueryValue{}), std::back_inserter(values));
}
template
<
typename QueryValue, typename Rtree,
std::enable_if_t<(!is_pb_or_bb_v<QueryValue, Rtree>), int> = 0
>
void test_queries_pb_bb(Rtree const& ) {}
template
<
typename QueryValue, typename Rtree,
std::enable_if_t<is_pp_or_bb_v<QueryValue, Rtree>, int> = 0
>
void test_queries_pp_bb(Rtree const& rtree)
{
// These predicates use algorithms that are not implemented for
// some geometry combinations
std::vector<typename Rtree::value_type> values;
rtree.query(bgi::overlaps(QueryValue{}), std::back_inserter(values));
rtree.query(bgi::touches(QueryValue{}), std::back_inserter(values));
}
template
<
typename QueryValue, typename Rtree,
std::enable_if_t<(!is_pp_or_bb_v<QueryValue, Rtree>), int> = 0
>
void test_queries_pp_bb(Rtree const& ) {}
template <typename QueryValue, typename Rtree>
void test_queries(Rtree const& rtree)
{
std::vector<typename Rtree::value_type> values;
rtree.query(bgi::intersects(QueryValue{}), std::back_inserter(values));
rtree.query(bgi::nearest(QueryValue{}, 1), std::back_inserter(values));
test_queries_bp_bb<QueryValue>(rtree);
test_queries_pb_bb<QueryValue>(rtree);
test_queries_pp_bb<QueryValue>(rtree);
}
template <typename Value, typename Params, typename Strategies>
void test_strategies()
{
std::vector<Value> values;
bgi::rtree<Value, bgi::parameters<Params, Strategies>> rtree{values};
rtree.insert(Value{});
rtree.remove(Value{});
test_queries<point>(rtree);
test_queries<box>(rtree);
test_queries<segment>(rtree);
}
template <typename Value, typename Params>
void test_params()
{
test_strategies<Value, Params, bg::strategies::index::cartesian<>>();
test_strategies<Value, Params, bg::strategies::cartesian<>>();
test_strategies<Value, Params, bg::strategies::index::spherical<>>();
test_strategies<Value, Params, bg::strategies::spherical<>>();
test_strategies<Value, Params, bg::strategies::index::geographic<>>();
test_strategies<Value, Params, bg::strategies::geographic<>>();
}
template <typename Value>
void test_value()
{
test_params<Value, bgi::linear<4>>();
test_params<Value, bgi::quadratic<4>>();
test_params<Value, bgi::rstar<4>>();
}
int test_main(int, char* [])
{
test_value<point>();
test_value<box>();
test_value<segment>();
return 0;
}