Use estimates for NoRoute in table requests

CHANGELOG.md

@@ -2,6 +2,7 @@
   - Changes from 5.19.0:
     - Table:
       - CHANGED: switch to pre-calculated distances for table responses for large speedup and 10% memory increase. [#5251](https://github.com/Project-OSRM/osrm-backend/pull/5251)
+      - ADDED: new parameter `fallback_speed` which will fill `null` cells with estimated value [#5257](https://github.com/Project-OSRM/osrm-backend/pull/5257)
     - Features:
       - ADDED: direct mmapping of datafiles is now supported via the `--mmap` switch. [#5242](https://github.com/Project-OSRM/osrm-backend/pull/5242)
       - REMOVED: the previous `--memory_file` switch is now deprecated and will fallback to `--mmap` [#5242](https://github.com/Project-OSRM/osrm-backend/pull/5242)

docs/http.md

@@ -236,8 +236,9 @@ In addition to the [general options](#general-options) the following options are
 |------------|--------------------------------------------------|---------------------------------------------|
 |sources     |`{index};{index}[;{index} ...]` or `all` (default)|Use location with given index as source.     |
 |destinations|`{index};{index}[;{index} ...]` or `all` (default)|Use location with given index as destination.|
-|annotations |`duration` (default), `distance`, or `duration,distance`|Return the requested table or tables in response. Note that computing the `distances` table is currently only implemented for CH. If `annotations=distance` or `annotations=duration,distance` is requested when running a MLD router, a `NotImplemented` error will be returned.
-|
+|annotations |`duration` (default), `distance`, or `duration,distance`|Return the requested table or tables in response. Note that computing the `distances` table is currently only implemented for CH. If `annotations=distance` or `annotations=duration,distance` is requested when running a MLD router, a `NotImplemented` error will be returned. |
+|fallback_speed|`double > 0`|If no route found between a source/destination pair, calculate the as-the-crow-flies distance, then use this speed to estimate duration.|
+|fallback_coordinate|`input` (default), or `snapped`| When using a `fallback_speed`, use the user-supplied coordinate (`input`), or the snapped location (`snapped`) for calculating distances.|
 
 Unlike other array encoded options, the length of `sources` and `destinations` can be **smaller or equal**
 to number of input locations;

docs/nodejs/api.md

@@ -129,6 +129,8 @@ tables. Optionally returns distance table.
     -   `options.destinations` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** An array of `index` elements (`0 <= integer <
         #coordinates`) to use location with given index as destination. Default is to use all.
     -   `options.approaches` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
+    -   `options.fallback_speed` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Replace `null` responses in result with as-the-crow-flies estimates based on `fallback_speed`.  Value is in metres/second.
+    -   `options.fallback_coordinate` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Either `input` (default) or `snapped`.  If using a `fallback_speed`, use either the user-supplied coordinate (`input`), or the snapped coordinate (`snapped`) for calculating the as-the-crow-flies diestance between two points.
 -   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**
 
 **Examples**

features/testbot/distance_matrix.feature

@@ -595,3 +595,75 @@ Feature: Basic Distance Matrix
             | d | 1478.9 | 1579  | 1779.1 | 0      | 1280.1 | 882.5  |
             | e | 198.8  | 298.9 | 499    | 710.3  | 0      | 1592.8 |
             | f | 596.4  | 696.5 | 896.6  | 1107.9 | 397.6  | 0      |
+
+
+    Scenario: Testbot - Filling in noroutes with estimates (defaults to input coordinate location)
+        Given a grid size of 300 meters
+        Given the extract extra arguments "--small-component-size 4"
+        Given the query options
+            | fallback_speed | 5 |
+        Given the node map
+            """
+            a b   f h 1
+            d e   g i
+            """
+
+        And the ways
+            | nodes |
+            | abeda |
+            | fhigf |
+
+        When I request a travel distance matrix I should get
+            |   | a      | b      | f     | 1      |
+            | a | 0      | 300.2  | 900.7 | 1501.1 |
+            | b | 300.2  | 0      | 600.5 | 1200.9 |
+            | f | 900.7  | 600.5  | 0     | 302.2  |
+            | 1 | 1501.1 | 1200.9 | 300.2 | 0      |
+
+    Scenario: Testbot - Filling in noroutes with estimates - use input coordinate
+        Given a grid size of 300 meters
+        Given the extract extra arguments "--small-component-size 4"
+        Given the query options
+            | fallback_speed | 5 |
+            | fallback_coordinate | input |
+        Given the node map
+            """
+            a b   f h 1
+            d e   g i
+            """
+
+        And the ways
+            | nodes |
+            | abeda |
+            | fhigf |
+
+        When I request a travel distance matrix I should get
+            |   | a      | b      | f     | 1      |
+            | a | 0      | 300.2  | 900.7 | 1501.1 |
+            | b | 300.2  | 0      | 600.5 | 1200.9 |
+            | f | 900.7  | 600.5  | 0     | 302.2  |
+            | 1 | 1501.1 | 1200.9 | 300.2 | 0      |
+
+    Scenario: Testbot - Filling in noroutes with estimates - use snapped coordinate
+        Given a grid size of 300 meters
+        Given the extract extra arguments "--small-component-size 4"
+        Given the query options
+            | fallback_speed | 5 |
+            | fallback_coordinate | snapped |
+        Given the node map
+            """
+            a b   f h 1
+            d e   g i
+            """
+
+        And the ways
+            | nodes |
+            | abeda |
+            | fhigf |
+
+        When I request a travel distance matrix I should get
+            |   | a      | b     | f     | 1      |
+            | a | 0      | 300.2 | 900.7 | 1200.9 |
+            | b | 300.2  | 0     | 600.5 | 900.7  |
+            | f | 900.7  | 600.5 | 0     | 302.2  |
+            | 1 | 1200.9 | 900.7 | 300.2 | 0      |

features/testbot/duration_matrix.feature

@@ -510,3 +510,74 @@ Feature: Basic Duration Matrix
             |   |   a   |
             | a |   0   |
             | b | 24.1  |
+
+    Scenario: Testbot - Filling in noroutes with estimates (defaults to input coordinate location)
+        Given a grid size of 300 meters
+        Given the extract extra arguments "--small-component-size 4"
+        Given the query options
+            | fallback_speed | 5 |
+        Given the node map
+            """
+            a b   f h 1
+            d e   g i
+            """
+
+        And the ways
+            | nodes |
+            | abeda |
+            | fhigf |
+
+        When I request a travel time matrix I should get
+            |   | a  | b  | f  | 1  |
+            | a | 0  | 30 | 18 | 30 |
+            | b | 30 | 0  | 12 | 24 |
+            | f | 18 | 12 | 0  | 30 |
+            | 1 | 30 | 24 | 30 | 0  |
+
+    Scenario: Testbot - Filling in noroutes with estimates - use input coordinate
+        Given a grid size of 300 meters
+        Given the extract extra arguments "--small-component-size 4"
+        Given the query options
+            | fallback_speed | 5 |
+            | fallback_coordinate | input |
+        Given the node map
+            """
+            a b   f h 1
+            d e   g i
+            """
+
+        And the ways
+            | nodes |
+            | abeda |
+            | fhigf |
+
+        When I request a travel time matrix I should get
+            |   | a  | b  | f  | 1  |
+            | a | 0  | 30 | 18 | 30 |
+            | b | 30 | 0  | 12 | 24 |
+            | f | 18 | 12 | 0  | 30 |
+            | 1 | 30 | 24 | 30 | 0  |
+
+    Scenario: Testbot - Filling in noroutes with estimates - use snapped coordinate
+        Given a grid size of 300 meters
+        Given the extract extra arguments "--small-component-size 4"
+        Given the query options
+            | fallback_speed | 5 |
+            | fallback_coordinate | snapped |
+        Given the node map
+            """
+            a b   f h 1
+            d e   g i
+            """
+
+        And the ways
+            | nodes |
+            | abeda |
+            | fhigf |
+
+        When I request a travel time matrix I should get
+            |   | a  | b  | f  | 1  |
+            | a | 0  | 30 | 18 | 24 |
+            | b | 30 | 0  | 12 | 18 |
+            | f | 18 | 12 | 0  | 30 |
+            | 1 | 24 | 18 | 30 | 0  |

include/engine/api/table_parameters.hpp

@@ -59,6 +59,15 @@ struct TableParameters : public BaseParameters
 {
     std::vector<std::size_t> sources;
     std::vector<std::size_t> destinations;
+    double fallback_speed = 0;
+
+    enum class FallbackCoordinateType
+    {
+        Input = 0,
+        Snapped = 1
+    };
+
+    FallbackCoordinateType fallback_coordinate_type = FallbackCoordinateType::Input;
 
     enum class AnnotationsType
     {
@@ -90,6 +99,19 @@ struct TableParameters : public BaseParameters
     {
     }
 
+    template <typename... Args>
+    TableParameters(std::vector<std::size_t> sources_,
+                    std::vector<std::size_t> destinations_,
+                    const AnnotationsType annotations_,
+                    double fallback_speed_,
+                    FallbackCoordinateType fallback_coordinate_type_,
+                    Args... args_)
+        : BaseParameters{std::forward<Args>(args_)...}, sources{std::move(sources_)},
+          destinations{std::move(destinations_)}, fallback_speed{fallback_speed_},
+          fallback_coordinate_type{fallback_coordinate_type_}, annotations{annotations_}
+    {
+    }
+
     bool IsValid() const
     {
         if (!BaseParameters::IsValid())
@@ -117,6 +139,9 @@ struct TableParameters : public BaseParameters
         if (std::any_of(begin(destinations), end(destinations), not_in_range))
             return false;
 
+        if (fallback_speed < 0)
+            return false;
+
         return true;
     }
 };

include/nodejs/node_osrm_support.hpp

@@ -1183,6 +1183,52 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
         }
     }
 
+    if (obj->Has(Nan::New("fallback_speed").ToLocalChecked()))
+    {
+        auto fallback_speed = obj->Get(Nan::New("fallback_speed").ToLocalChecked());
+
+        if (!fallback_speed->IsNumber())
+        {
+            Nan::ThrowError("fallback_speed must be a number");
+            return table_parameters_ptr();
+        }
+        else if (fallback_speed->NumberValue() < 0)
+        {
+            Nan::ThrowError("fallback_speed must be > 0");
+            return table_parameters_ptr();
+        }
+
+        params->fallback_speed = static_cast<double>(fallback_speed->NumberValue());
+    }
+
+    if (obj->Has(Nan::New("fallback_coordinate").ToLocalChecked()))
+    {
+        auto fallback_coordinate = obj->Get(Nan::New("fallback_coordinate").ToLocalChecked());
+
+        if (!fallback_coordinate->IsString())
+        {
+            Nan::ThrowError("fallback_coordinate must be a string: [input, snapped]");
+            return table_parameters_ptr();
+        }
+
+        std::string fallback_coordinate_str = *v8::String::Utf8Value(fallback_coordinate);
+
+        if (fallback_coordinate_str == "snapped")
+        {
+            params->fallback_coordinate_type =
+                osrm::TableParameters::FallbackCoordinateType::Snapped;
+        }
+        else if (fallback_coordinate_str == "input")
+        {
+            params->fallback_coordinate_type = osrm::TableParameters::FallbackCoordinateType::Input;
+        }
+        else
+        {
+            Nan::ThrowError("'fallback_coordinate' param must be one of [input, snapped]");
+            return table_parameters_ptr();
+        }
+    }
+
     return params;
 }
 

include/server/api/base_parameters_grammar.hpp

@@ -178,6 +178,8 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
     qi::rule<Iterator, Signature> base_rule;
     qi::rule<Iterator, Signature> query_rule;
 
+    qi::real_parser<double, json_policy> double_;
+
   private:
     qi::rule<Iterator, Signature> bearings_rule;
     qi::rule<Iterator, Signature> radiuses_rule;
@@ -195,7 +197,6 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
     qi::rule<Iterator, unsigned char()> base64_char;
     qi::rule<Iterator, std::string()> polyline_chars;
     qi::rule<Iterator, double()> unlimited_rule;
-    qi::real_parser<double, json_policy> double_;
 
     qi::symbols<char, engine::Approach> approach_type;
 };

include/server/api/table_parameter_grammar.hpp

@@ -48,10 +48,24 @@ struct TableParametersGrammar : public BaseParametersGrammar<Iterator, Signature
             (qi::lit("all") |
              (size_t_ % ';')[ph::bind(&engine::api::TableParameters::sources, qi::_r1) = qi::_1]);
 
+        fallback_speed_rule =
+            qi::lit("fallback_speed=") >
+            (double_)[ph::bind(&engine::api::TableParameters::fallback_speed, qi::_r1) = qi::_1];
+
+        fallback_coordinate_type.add("input",
+                                     engine::api::TableParameters::FallbackCoordinateType::Input)(
+            "snapped", engine::api::TableParameters::FallbackCoordinateType::Snapped);
+
         table_rule = destinations_rule(qi::_r1) | sources_rule(qi::_r1);
 
-        root_rule = BaseGrammar::query_rule(qi::_r1) > -qi::lit(".json") >
-                    -('?' > (table_rule(qi::_r1) | base_rule(qi::_r1)) % '&');
+        root_rule =
+            BaseGrammar::query_rule(qi::_r1) > -qi::lit(".json") >
+            -('?' > (table_rule(qi::_r1) | base_rule(qi::_r1) | fallback_speed_rule(qi::_r1) |
+                     (qi::lit("fallback_coordinate=") >
+                      fallback_coordinate_type
+                          [ph::bind(&engine::api::TableParameters::fallback_coordinate_type,
+                                    qi::_r1) = qi::_1])) %
+                        '&');
     }
 
     TableParametersGrammar(qi::rule<Iterator, Signature> &root_rule_) : BaseGrammar(root_rule_)
@@ -73,13 +87,19 @@ struct TableParametersGrammar : public BaseParametersGrammar<Iterator, Signature
     qi::rule<Iterator, Signature> base_rule;
 
   private:
+    using json_policy = no_trailing_dot_policy<double, 'j', 's', 'o', 'n'>;
+
     qi::rule<Iterator, Signature> root_rule;
     qi::rule<Iterator, Signature> table_rule;
     qi::rule<Iterator, Signature> sources_rule;
     qi::rule<Iterator, Signature> destinations_rule;
+    qi::rule<Iterator, Signature> fallback_speed_rule;
     qi::rule<Iterator, std::size_t()> size_t_;
     qi::symbols<char, engine::api::TableParameters::AnnotationsType> annotations;
     qi::rule<Iterator, engine::api::TableParameters::AnnotationsType()> annotations_list;
+    qi::symbols<char, engine::api::TableParameters::FallbackCoordinateType>
+        fallback_coordinate_type;
+    qi::real_parser<double, json_policy> double_;
 };
 }
 }

src/engine/plugins/table.cpp

@@ -4,6 +4,7 @@
 #include "engine/api/table_parameters.hpp"
 #include "engine/routing_algorithms/many_to_many.hpp"
 #include "engine/search_engine_data.hpp"
+#include "util/coordinate_calculation.hpp"
 #include "util/json_container.hpp"
 #include "util/string_util.hpp"
 
@@ -94,6 +95,41 @@ Status TablePlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
         return Error("NoTable", "No table found", result);
     }
 
+    // Scan table for null results - if any exist, replace with distance estimates
+    if (params.fallback_speed > 0)
+    {
+        for (std::size_t row = 0; row < num_sources; row++)
+        {
+            for (std::size_t column = 0; column < num_destinations; column++)
+            {
+                const auto &table_index = row * num_sources + column;
+                if (result_tables_pair.first[table_index] == MAXIMAL_EDGE_DURATION)
+                {
+                    const auto &source =
+                        snapped_phantoms[params.sources.empty() ? row : params.sources[row]];
+                    const auto &destination =
+                        snapped_phantoms[params.destinations.empty() ? column
+                                                                     : params.destinations[column]];
+
+                    auto distance_estimate =
+                        params.fallback_coordinate_type ==
+                                api::TableParameters::FallbackCoordinateType::Input
+                            ? util::coordinate_calculation::fccApproximateDistance(
+                                  source.input_location, destination.input_location)
+                            : util::coordinate_calculation::fccApproximateDistance(
+                                  source.location, destination.location);
+
+                    result_tables_pair.first[table_index] =
+                        distance_estimate / (double)params.fallback_speed;
+                    if (!result_tables_pair.second.empty())
+                    {
+                        result_tables_pair.second[table_index] = distance_estimate;
+                    }
+                }
+            }
+        }
+    }
+
     api::TableAPI table_api{facade, params};
     table_api.MakeResponse(result_tables_pair, snapped_phantoms, result);