Apply a global radius limit when bearing filtering is in use.

This should effectively prevent traversing the whole RTree accidentally when a highly specific bearing is supplied.
The assumption is that anyone who can supply a bearing should also already have a pretty good idea of the coordinate they want.

Author: danpat

include/engine/engine_config.hpp

@@ -53,6 +53,9 @@ namespace engine
  *  - Match
  *  - Nearest
  *
+ * You can restrict the coordinate search radius when a bearing is supplied.  This helps
+ * prevent the rtree search expanding if a very narrow bearing filter is supplied.
+ *
  * In addition, shared memory can be used for datasets loaded with osrm-datastore.
  *
  * \see OSRM, StorageConfig
@@ -61,13 +64,16 @@ struct EngineConfig final
 {
     bool IsValid() const;
 
+    constexpr static const int UNLIMITED = -1;
+
     storage::StorageConfig storage_config;
-    int max_locations_trip = -1;
-    int max_locations_viaroute = -1;
-    int max_locations_distance_table = -1;
-    int max_locations_map_matching = -1;
-    int max_results_nearest = -1;
-    int max_radius_nearest = -1; // in meters
+    int max_locations_trip = UNLIMITED;
+    int max_locations_viaroute = UNLIMITED;
+    int max_locations_distance_table = UNLIMITED;
+    int max_locations_map_matching = UNLIMITED;
+    int max_results_nearest = UNLIMITED;
+
+    double max_radius_when_bearings = UNLIMITED; // in meters
 
     bool use_shared_memory = true;
 };

include/engine/plugins/match.hpp

@@ -27,8 +27,9 @@ class MatchPlugin : public BasePlugin
     static const constexpr double DEFAULT_GPS_PRECISION = 5;
     static const constexpr double RADIUS_MULTIPLIER = 3;
 
-    MatchPlugin(datafacade::BaseDataFacade &facade_, const int max_locations_map_matching)
-        : BasePlugin(facade_), map_matching(&facade_, heaps, DEFAULT_GPS_PRECISION),
+    MatchPlugin(datafacade::BaseDataFacade &facade_, const int max_locations_map_matching,
+                const double max_radius_when_bearings_)
+        : BasePlugin(facade_, max_radius_when_bearings_), map_matching(&facade_, heaps, DEFAULT_GPS_PRECISION),
           shortest_path(&facade_, heaps), max_locations_map_matching(max_locations_map_matching)
     {
     }

include/engine/plugins/nearest.hpp

@@ -16,14 +16,13 @@ class NearestPlugin final : public BasePlugin
 {
   public:
     explicit NearestPlugin(datafacade::BaseDataFacade &facade,
-                           const int max_results,
-                           const int max_radius);
+                           const int max_results_nearest,
+                           const double max_radius_when_bearings);
 
     Status HandleRequest(const api::NearestParameters &params, util::json::Object &result);
 
   private:
     const int max_results;
-    const int max_radius;
 };
 }
 }

include/engine/plugins/plugin_base.hpp

@@ -5,6 +5,7 @@
 #include "engine/datafacade/datafacade_base.hpp"
 #include "engine/phantom_node.hpp"
 #include "engine/status.hpp"
+#include "engine/engine_config.hpp"
 
 #include "util/coordinate.hpp"
 #include "util/coordinate_calculation.hpp"
@@ -27,7 +28,8 @@ class BasePlugin
 {
   protected:
     datafacade::BaseDataFacade &facade;
-    BasePlugin(datafacade::BaseDataFacade &facade_) : facade(facade_) {}
+    const double max_radius_when_bearings;
+    BasePlugin(datafacade::BaseDataFacade &facade_, const double max_radius_when_bearings_) : facade(facade_), max_radius_when_bearings(max_radius_when_bearings_) {}
 
     bool CheckAllCoordinates(const std::vector<util::Coordinate> &coordinates)
     {
@@ -37,6 +39,19 @@ class BasePlugin
             });
     }
 
+    bool CheckAllRadiuses(const api::BaseParameters &parameters)
+    {
+        if (parameters.bearings.empty()) return true;
+
+        if (max_radius_when_bearings == EngineConfig::UNLIMITED) return true;
+
+        return !std::any_of(
+                std::begin(parameters.radiuses), std::end(parameters.radiuses),
+                [this](const auto &radius) {
+                    return radius && *radius > max_radius_when_bearings;
+                });
+    }
+
     Status Error(const std::string &code,
                  const std::string &message,
                  util::json::Object &json_result) const
@@ -137,7 +152,7 @@ class BasePlugin
             {
                 phantom_nodes[i] =
                     facade.NearestPhantomNodesInRange(parameters.coordinates[i],
-                                                      radiuses[i],
+                                                      max_radius_when_bearings != EngineConfig::UNLIMITED ? std::min(radiuses[i], max_radius_when_bearings) : radiuses[i],
                                                       parameters.bearings[i]->bearing,
                                                       parameters.bearings[i]->range);
             }
@@ -181,16 +196,27 @@ class BasePlugin
                 {
                     phantom_nodes[i] = facade.NearestPhantomNodes(parameters.coordinates[i],
                                                                   number_of_results,
-                                                                  *parameters.radiuses[i],
+                                                                  max_radius_when_bearings != EngineConfig::UNLIMITED ? std::min(*parameters.radiuses[i],max_radius_when_bearings) : *parameters.radiuses[i],
                                                                   parameters.bearings[i]->bearing,
                                                                   parameters.bearings[i]->range);
                 }
                 else
                 {
-                    phantom_nodes[i] = facade.NearestPhantomNodes(parameters.coordinates[i],
-                                                                  number_of_results,
-                                                                  parameters.bearings[i]->bearing,
-                                                                  parameters.bearings[i]->range);
+                    if (max_radius_when_bearings != EngineConfig::UNLIMITED)
+                    {
+                        phantom_nodes[i] = facade.NearestPhantomNodes(parameters.coordinates[i],
+                                                                      number_of_results,
+                                                                      parameters.bearings[i]->bearing,
+                                                                      parameters.bearings[i]->range);
+                    }
+                    else
+                    {
+                        phantom_nodes[i] = facade.NearestPhantomNodes(parameters.coordinates[i],
+                                                                      number_of_results,
+                                                                      max_radius_when_bearings,
+                                                                      parameters.bearings[i]->bearing,
+                                                                      parameters.bearings[i]->range);
+                    }
                 }
             }
             else
@@ -242,17 +268,29 @@ class BasePlugin
                     phantom_node_pairs[i] =
                         facade.NearestPhantomNodeWithAlternativeFromBigComponent(
                             parameters.coordinates[i],
-                            *parameters.radiuses[i],
+                            max_radius_when_bearings != EngineConfig::UNLIMITED ? std::min(*parameters.radiuses[i],max_radius_when_bearings) : *parameters.radiuses[i],
                             parameters.bearings[i]->bearing,
                             parameters.bearings[i]->range);
                 }
                 else
                 {
-                    phantom_node_pairs[i] =
-                        facade.NearestPhantomNodeWithAlternativeFromBigComponent(
-                            parameters.coordinates[i],
-                            parameters.bearings[i]->bearing,
-                            parameters.bearings[i]->range);
+                    if (max_radius_when_bearings == EngineConfig::UNLIMITED)
+                    {
+                        phantom_node_pairs[i] =
+                            facade.NearestPhantomNodeWithAlternativeFromBigComponent(
+                                parameters.coordinates[i],
+                                parameters.bearings[i]->bearing,
+                                parameters.bearings[i]->range);
+                    }
+                    else
+                    {
+                        phantom_node_pairs[i] =
+                            facade.NearestPhantomNodeWithAlternativeFromBigComponent(
+                                parameters.coordinates[i],
+                                max_radius_when_bearings,
+                                parameters.bearings[i]->bearing,
+                                parameters.bearings[i]->range);
+                    }
                 }
             }
             else

include/engine/plugins/table.hpp

@@ -19,7 +19,8 @@ class TablePlugin final : public BasePlugin
 {
   public:
     explicit TablePlugin(datafacade::BaseDataFacade &facade,
-                         const int max_locations_distance_table);
+                         const int max_locations_distance_table,
+                         const double max_radius_when_bearings);
 
     Status HandleRequest(const api::TableParameters &params, util::json::Object &result);
 

include/engine/plugins/tile.hpp

@@ -24,7 +24,7 @@ namespace plugins
 class TilePlugin final : public BasePlugin
 {
   public:
-    TilePlugin(datafacade::BaseDataFacade &facade) : BasePlugin(facade) {}
+    TilePlugin(datafacade::BaseDataFacade &facade) : BasePlugin(facade, EngineConfig::UNLIMITED) {}
 
     Status HandleRequest(const api::TileParameters &parameters, std::string &pbf_buffer);
 };

include/engine/plugins/trip.hpp

@@ -38,9 +38,11 @@ class TripPlugin final : public BasePlugin
                                      const std::vector<NodeID> &trip);
 
   public:
-    explicit TripPlugin(datafacade::BaseDataFacade &facade_, const int max_locations_trip_)
-        : BasePlugin(facade_), shortest_path(&facade_, heaps), duration_table(&facade_, heaps),
-          max_locations_trip(max_locations_trip_)
+    explicit TripPlugin(datafacade::BaseDataFacade &facade_,
+                        const int max_locations_trip_,
+                        const double max_radius_when_bearings_)
+        : BasePlugin(facade_, max_radius_when_bearings_), shortest_path(&facade_, heaps),
+          duration_table(&facade_, heaps), max_locations_trip(max_locations_trip_)
     {
     }
 

include/engine/plugins/viaroute.hpp

@@ -32,10 +32,12 @@ class ViaRoutePlugin final : public BasePlugin
     routing_algorithms::ShortestPathRouting<datafacade::BaseDataFacade> shortest_path;
     routing_algorithms::AlternativeRouting<datafacade::BaseDataFacade> alternative_path;
     routing_algorithms::DirectShortestPathRouting<datafacade::BaseDataFacade> direct_shortest_path;
-    int max_locations_viaroute;
+    const int max_locations_viaroute;
 
   public:
-    explicit ViaRoutePlugin(datafacade::BaseDataFacade &facade, int max_locations_viaroute);
+    explicit ViaRoutePlugin(datafacade::BaseDataFacade &facade,
+                            const int max_locations_viaroute,
+                            const double max_radius_when_bearings);
 
     Status HandleRequest(const api::RouteParameters &route_parameters,
                          util::json::Object &json_result);

src/engine/engine.cpp

@@ -144,12 +144,11 @@ Engine::Engine(EngineConfig &config)
     // Register plugins
     using namespace plugins;
 
-    route_plugin = create<ViaRoutePlugin>(*query_data_facade, config.max_locations_viaroute);
-    table_plugin = create<TablePlugin>(*query_data_facade, config.max_locations_distance_table);
-    nearest_plugin = create<NearestPlugin>(
-        *query_data_facade, config.max_results_nearest, config.max_radius_nearest);
-    trip_plugin = create<TripPlugin>(*query_data_facade, config.max_locations_trip);
-    match_plugin = create<MatchPlugin>(*query_data_facade, config.max_locations_map_matching);
+    route_plugin = create<ViaRoutePlugin>(*query_data_facade, config.max_locations_viaroute, config.max_radius_when_bearings);
+    table_plugin = create<TablePlugin>(*query_data_facade, config.max_locations_distance_table, config.max_radius_when_bearings);
+    nearest_plugin = create<NearestPlugin>(*query_data_facade, config.max_results_nearest, config.max_radius_when_bearings);
+    trip_plugin = create<TripPlugin>(*query_data_facade, config.max_locations_trip, config.max_radius_when_bearings);
+    match_plugin = create<MatchPlugin>(*query_data_facade, config.max_locations_map_matching, config.max_radius_when_bearings);
     tile_plugin = create<TilePlugin>(*query_data_facade);
 }
 

src/engine/engine_config.cpp

@@ -24,8 +24,8 @@ bool EngineConfig::IsValid() const
                               unlimited_or_more_than(max_locations_map_matching, 2) &&
                               unlimited_or_more_than(max_locations_trip, 2) &&
                               unlimited_or_more_than(max_locations_viaroute, 2) &&
-                              unlimited_or_more_than(max_results_nearest, 1) &&
-                              unlimited_or_more_than(max_radius_nearest, 1);
+                              unlimited_or_more_than(max_results_nearest, 0) &&
+                              unlimited_or_more_than(max_radius_when_bearings, 0);
 
     return ((use_shared_memory && all_path_are_empty) || storage_config.IsValid()) && limits_valid;
 }

src/engine/plugins/match.cpp

@@ -123,6 +123,11 @@ Status MatchPlugin::HandleRequest(const api::MatchParameters &parameters,
         return Error("InvalidValue", "Invalid coordinate value.", json_result);
     }
 
+    if (!CheckAllRadiuses(parameters))
+    {
+        return Error("TooBig", "When using a bearing filter, the maximum search radius is limited to " + std::to_string(max_radius_when_bearings) + "m", json_result);
+    }
+
     // assuming radius is the standard deviation of a normal distribution
     // that models GPS noise (in this model), x3 should give us the correct
     // search radius with > 99% confidence

src/engine/plugins/nearest.cpp

@@ -19,8 +19,8 @@ namespace plugins
 
 NearestPlugin::NearestPlugin(datafacade::BaseDataFacade &facade,
                              const int max_results_,
-                             const int max_radius_)
-    : BasePlugin{facade}, max_results{max_results_}, max_radius{max_radius_}
+                             const double max_radius_when_bearing_)
+    : BasePlugin{facade, max_radius_when_bearing_}, max_results{max_results_}
 {
 }
 
@@ -37,37 +37,25 @@ Status NearestPlugin::HandleRequest(const api::NearestParameters &params,
         return Error("InvalidOptions", "Only one input coordinate is supported", json_result);
     }
 
-    // Artificially set and / or limit the params.radiuses array for GetPhantomNodes.
-    // This sets a limit on nearest queries with bearing and large number of results.
-
-    // params are const (read-only) but we have to constrain the radiuses afterwards.
-    // We want to keep the user-interface as is, so make a copy. Should be cheap.
-    auto constraint_params = params;
-
-    if (max_radius != -1)
+    if (max_results != -1 && params.number_of_results > boost::numeric_cast<unsigned>(max_results))
     {
-        const auto max_radius_m = static_cast<double>(max_radius);
-
-        if (constraint_params.radiuses.empty())
-            constraint_params.radiuses.push_back(boost::make_optional(max_radius_m));
-        else if (constraint_params.radiuses[0])
-            boost::algorithm::clamp(*constraint_params.radiuses[0], 0., max_radius_m);
+        return Error("TooBig", "Too many results requested, maximum is " + std::to_string(max_results), json_result);
     }
 
-    if (max_results != -1)
+    if (!CheckAllRadiuses(params))
     {
-        constraint_params.number_of_results = boost::algorithm::clamp(params.number_of_results, 0, max_results);
+        return Error("TooBig", "When using a bearing filter, the maximum search radius is limited to " + std::to_string(max_radius_when_bearings) + "m", json_result);
     }
 
-    auto phantom_nodes = GetPhantomNodes(constraint_params, constraint_params.number_of_results);
+    auto phantom_nodes = GetPhantomNodes(params, params.number_of_results);
 
     if (phantom_nodes.front().size() == 0)
     {
         return Error("NoSegment", "Could not find a matching segments for coordinate", json_result);
     }
     BOOST_ASSERT(phantom_nodes.front().size() > 0);
 
-    api::NearestAPI nearest_api(facade, constraint_params);
+    api::NearestAPI nearest_api(facade, params);
     nearest_api.MakeResponse(phantom_nodes, json_result);
 
     return Status::Ok;

src/engine/plugins/table.cpp

@@ -23,8 +23,8 @@ namespace engine
 namespace plugins
 {
 
-TablePlugin::TablePlugin(datafacade::BaseDataFacade &facade, const int max_locations_distance_table)
-    : BasePlugin{facade}, distance_table(&facade, heaps),
+TablePlugin::TablePlugin(datafacade::BaseDataFacade &facade, const int max_locations_distance_table, const double max_radius_when_bearings_)
+    : BasePlugin{facade, max_radius_when_bearings_}, distance_table(&facade, heaps),
       max_locations_distance_table(max_locations_distance_table)
 {
 }
@@ -58,6 +58,11 @@ Status TablePlugin::HandleRequest(const api::TableParameters &params, util::json
         return Error("TooBig", "Too many table coordinates", result);
     }
 
+    if (!CheckAllRadiuses(params))
+    {
+        return Error("TooBig", "When using a bearing filter, the maximum search radius is limited to " + std::to_string(max_radius_when_bearings) + "m", result);
+    }
+
     auto snapped_phantoms = SnapPhantomNodes(GetPhantomNodes(params));
     auto result_table = distance_table(snapped_phantoms, params.sources, params.destinations);
 

src/engine/plugins/trip.cpp

@@ -157,6 +157,11 @@ Status TripPlugin::HandleRequest(const api::TripParameters &parameters,
         return Error("InvalidValue", "Invalid coordinate value.", json_result);
     }
 
+    if (!CheckAllRadiuses(parameters))
+    {
+        return Error("TooBig", "When using a bearing filter, the maximum search radius is limited to " + std::to_string(max_radius_when_bearings) + "m", json_result);
+    }
+
     auto phantom_node_pairs = GetPhantomNodes(parameters);
     if (phantom_node_pairs.size() != parameters.coordinates.size())
     {

src/engine/plugins/viaroute.cpp

@@ -21,8 +21,8 @@ namespace engine
 namespace plugins
 {
 
-ViaRoutePlugin::ViaRoutePlugin(datafacade::BaseDataFacade &facade_, int max_locations_viaroute)
-    : BasePlugin(facade_), shortest_path(&facade_, heaps), alternative_path(&facade_, heaps),
+ViaRoutePlugin::ViaRoutePlugin(datafacade::BaseDataFacade &facade_, const int max_locations_viaroute, const double max_radius_when_bearings_)
+    : BasePlugin(facade_, max_radius_when_bearings_), shortest_path(&facade_, heaps), alternative_path(&facade_, heaps),
       direct_shortest_path(&facade_, heaps), max_locations_viaroute(max_locations_viaroute)
 {
 }
@@ -47,6 +47,11 @@ Status ViaRoutePlugin::HandleRequest(const api::RouteParameters &route_parameter
         return Error("InvalidValue", "Invalid coordinate value.", json_result);
     }
 
+    if (!CheckAllRadiuses(route_parameters))
+    {
+        return Error("TooBig", "When using a bearing filter, the maximum search radius is limited to " + std::to_string(max_radius_when_bearings) + "m", json_result);
+    }
+
     auto phantom_node_pairs = GetPhantomNodes(route_parameters);
     if (phantom_node_pairs.size() != route_parameters.coordinates.size())
     {