Allow -1.0 as unlimited for default_radius value (#6599)

CHANGELOG.md

@@ -10,6 +10,8 @@
     - NodeJS:
       - CHANGED: Use node-api instead of NAN. [#6452](https://github.com/Project-OSRM/osrm-backend/pull/6452)
     - Misc:
+      - ADDED: Add support for "unlimited" to be passed as a value for the default-radius and max-matching-radius flags. [#6599](https://github.com/Project-OSRM/osrm-backend/pull/6599)
+      - CHANGED: Allow -1.0 as unlimited for default_radius value. [#6599](https://github.com/Project-OSRM/osrm-backend/pull/6599)
       - CHANGED: keep libosrm* in the docker image for downstream linking [#6602](https://github.com/Project-OSRM/osrm-backend/pull/6602)
       - CHANGED: Move vector in CSVFilesParser instead copying it. [#6470](https://github.com/Project-OSRM/osrm-backend/pull/6470)
       - REMOVED: Get rid of unused functions in util/json_util.hpp. [#6446](https://github.com/Project-OSRM/osrm-backend/pull/6446)

include/engine/engine_config.hpp

@@ -83,7 +83,7 @@ struct EngineConfig final
     int max_locations_map_matching = -1;
     double max_radius_map_matching = -1.0;
     int max_results_nearest = -1;
-    boost::optional<double> default_radius;
+    boost::optional<double> default_radius = -1.0;
     int max_alternatives = 3; // set an arbitrary upper bound; can be adjusted by user
     bool use_shared_memory = true;
     boost::filesystem::path memory_file;

include/engine/geospatial_query.hpp

@@ -72,7 +72,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
             [this, &max_distance, &max_results, input_coordinate](const std::size_t num_results,
                                                                   const CandidateSegment &segment) {
                 return (max_results && num_results >= *max_results) ||
-                       (max_distance &&
+                       (max_distance && max_distance != -1.0 &&
                         CheckSegmentDistance(input_coordinate, segment, *max_distance));
             });
 
@@ -163,7 +163,8 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                 auto distance = GetSegmentDistance(input_coordinate, segment);
                 auto further_than_big_component = distance > big_component_distance;
                 auto no_more_candidates = has_big_component && further_than_big_component;
-                auto too_far_away = max_distance && distance > *max_distance;
+                auto too_far_away =
+                    max_distance && max_distance != -1.0 && distance > *max_distance;
 
                 // Time to terminate the search when:
                 // 1. We've found a node from a big component and the next candidate is further away

include/nodejs/node_osrm_support.hpp

@@ -317,9 +317,16 @@ inline engine_config_ptr argumentsToEngineConfig(const Napi::CallbackInfo &args)
         ThrowError(args.Env(), "max_alternatives must be an integral number");
         return engine_config_ptr();
     }
-    if (!default_radius.IsUndefined() && !default_radius.IsNumber())
+    if (!max_radius_map_matching.IsUndefined() && max_radius_map_matching.IsString() &&
+        max_radius_map_matching.ToString().Utf8Value() != "unlimited")
     {
-        ThrowError(args.Env(), "default_radius must be an integral number");
+        ThrowError(args.Env(), "max_radius_map_matching must be unlimited or an integral number");
+        return engine_config_ptr();
+    }
+    if (!default_radius.IsUndefined() && default_radius.IsString() &&
+        default_radius.ToString().Utf8Value() != "unlimited")
+    {
+        ThrowError(args.Env(), "default_radius must be unlimited or an integral number");
         return engine_config_ptr();
     }
 
@@ -337,10 +344,17 @@ inline engine_config_ptr argumentsToEngineConfig(const Napi::CallbackInfo &args)
         engine_config->max_results_nearest = max_results_nearest.ToNumber().Int32Value();
     if (max_alternatives.IsNumber())
         engine_config->max_alternatives = max_alternatives.ToNumber().Int32Value();
+
     if (max_radius_map_matching.IsNumber())
         engine_config->max_radius_map_matching = max_radius_map_matching.ToNumber().DoubleValue();
+    else if (max_radius_map_matching.IsString() &&
+             max_radius_map_matching.ToString().Utf8Value() == "unlimited")
+        engine_config->max_radius_map_matching = -1.0;
+
     if (default_radius.IsNumber())
         engine_config->default_radius = default_radius.ToNumber().DoubleValue();
+    else if (default_radius.IsString() && default_radius.ToString().Utf8Value() == "unlimited")
+        engine_config->default_radius = -1.0;
 
     return engine_config;
 }

src/engine/engine_config.cpp

@@ -13,13 +13,15 @@ bool EngineConfig::IsValid() const
         return v == -1 || v > limit;
     };
 
-    const bool limits_valid = unlimited_or_more_than(max_locations_distance_table, 2) &&
+    const bool limits_valid =
-                              unlimited_or_more_than(max_locations_map_matching, 2) &&
+        unlimited_or_more_than(max_locations_distance_table, 2) &&
-                              unlimited_or_more_than(max_radius_map_matching, 0) &&
+        unlimited_or_more_than(max_locations_map_matching, 2) &&
-                              unlimited_or_more_than(max_locations_trip, 2) &&
+        unlimited_or_more_than(max_radius_map_matching, 0) &&
-                              unlimited_or_more_than(max_locations_viaroute, 2) &&
+        unlimited_or_more_than(max_locations_trip, 2) &&
-                              unlimited_or_more_than(max_results_nearest, 0) &&
+        unlimited_or_more_than(max_locations_viaroute, 2) &&
-                              max_alternatives >= 0;
+        unlimited_or_more_than(max_results_nearest, 0) &&
+        (!default_radius.has_value() || unlimited_or_more_than(*default_radius, 0)) &&
+        max_alternatives >= 0;
 
     return ((use_shared_memory && all_path_are_empty) || (use_mmap && storage_config.IsValid()) ||
             storage_config.IsValid()) &&

src/engine/plugins/match.cpp

@@ -181,7 +181,7 @@ Status MatchPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
     if (tidied.parameters.radiuses.empty())
     {
         search_radiuses.resize(tidied.parameters.coordinates.size(),
-                               default_radius.has_value()
+                               default_radius.has_value() && *default_radius != -1.0
                                    ? *default_radius
                                    : routing_algorithms::DEFAULT_GPS_PRECISION * RADIUS_MULTIPLIER);
     }
@@ -199,7 +199,7 @@ Status MatchPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                 }
                 else
                 {
-                    return default_radius.has_value()
+                    return default_radius.has_value() && *default_radius != -1.0
                                ? *default_radius
                                : routing_algorithms::DEFAULT_GPS_PRECISION * RADIUS_MULTIPLIER;
                 }

src/tools/routed.cpp

@@ -12,6 +12,7 @@
 #include <boost/algorithm/string/case_conv.hpp>
 #include <boost/any.hpp>
 #include <boost/filesystem.hpp>
+#include <boost/optional/optional_io.hpp>
 #include <boost/program_options.hpp>
 
 #include <cstdlib>
@@ -70,6 +71,33 @@ std::istream &operator>>(std::istream &in, EngineConfig::Algorithm &algorithm)
 }
 } // namespace osrm::engine
 
+// overload validate for the double type to allow "unlimited" as an input
+namespace boost
+{
+void validate(boost::any &v, const std::vector<std::string> &values, double *, double)
+{
+    boost::program_options::validators::check_first_occurrence(v);
+    const std::string &s = boost::program_options::validators::get_single_string(values);
+
+    if (s == "unlimited")
+    {
+        v = -1.0;
+    }
+    else
+    {
+        try
+        {
+            v = std::stod(s);
+        }
+        catch (const std::invalid_argument &)
+        {
+            throw boost::program_options::validation_error(
+                boost::program_options::validation_error::invalid_option_value);
+        }
+    }
+}
+} // namespace boost
+
 // generate boost::program_options object for the routing part
 inline unsigned generateServerProgramOptions(const int argc,
                                              const char *argv[],
@@ -149,7 +177,7 @@ inline unsigned generateServerProgramOptions(const int argc,
          value<double>(&config.max_radius_map_matching)->default_value(-1.0),
          "Max. radius size supported in map matching query. Default: unlimited.") //
         ("default-radius",
-         value<boost::optional<double>>(&config.default_radius),
+         value<boost::optional<double>>(&config.default_radius)->default_value(-1.0),
          "Default radius size for queries. Default: unlimited.");
 
     // hidden options, will be allowed on command line, but will not be shown to the user

test/nodejs/index.js

@@ -118,10 +118,17 @@ test('constructor: takes a default_radius argument', function(assert) {
     assert.ok(osrm);
 });
 
+test('constructor: takes a default_radius unlimited argument', function(assert) {
+    assert.plan(1);
+    var osrm = new OSRM({algorithm: 'MLD', path: monaco_mld_path, default_radius: 'unlimited'});
+    assert.ok(osrm);
+});
+
 test('constructor: throws if default_radius is not a number', function(assert) {
-    assert.plan(2);
+    assert.plan(3);
-    assert.throws(function() { new OSRM({algorithm: 'MLD', path: monaco_mld_path, default_radius: 'abc'}); }, /default_radius must be an integral number/, 'Does not accept string');
+    assert.throws(function() { new OSRM({algorithm: 'MLD', path: monaco_mld_path, default_radius: 'abc'}); }, /default_radius must be unlimited or an integral number/, 'Does not accept invalid string');
     assert.ok(new OSRM({algorithm: 'MLD', path: monaco_mld_path, default_radius: 1}), 'Does accept number');
+    assert.ok(new OSRM({algorithm: 'MLD', path: monaco_mld_path, default_radius: 'unlimited'}), 'Does accept unlimited');
 });
 
 test('constructor: parses custom limits', function(assert) {
@@ -135,6 +142,7 @@ test('constructor: parses custom limits', function(assert) {
         max_locations_map_matching: 1,
         max_results_nearest: 1,
         max_alternatives: 1,
+        default_radius: 1
     });
     assert.ok(osrm);
 });
@@ -150,7 +158,8 @@ test('constructor: throws on invalid custom limits', function(assert) {
             max_locations_distance_table: false,
             max_locations_map_matching: 'a lot',
             max_results_nearest: null,
-            max_alternatives: '10'
+            max_alternatives: '10',
+            default_radius: '10'
         })
     });
 });