fix: pass umbrella strategies in rtree spatial predicates

include/boost/geometry/index/detail/predicates.hpp

@@ -174,71 +174,39 @@ 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);
     }
 };
 
 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);
     }
 };
 
 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);
     }
 };
 
 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,37 +216,37 @@ 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);
     }
 };
 
 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);
     }
 };
 
 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);
     }
 };
 
 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);
     }
 };
 

index/test/rtree/CMakeLists.txt

@@ -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})

index/test/rtree/Jamfile

@@ -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 ]
     ;

index/test/rtree/rtree_with_strategies.cpp

@@ -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;
+}