Make 5.15.0-rc.1

Correctly mark edges going to/from core with exclude flags
Add regression test from @fijemax
2018-01-11 18:25:36 +01:00 · 2018-01-11 12:46:49 +00:00 · 2018-01-11 12:46:49 +00:00 · 2018-01-10 11:31:24 +01:00 · 2018-01-08 12:09:33 +00:00 · 2018-01-08 12:28:20 +01:00
35 changed files with 693 additions and 68 deletions
@@ -12,7 +12,7 @@ notifications:

 branches:
  only:
-    - master
+    - 5.15
    # enable building tags
    - /^v\d+\.\d+(\.\d+)?(-\S*)?$/

@@ -1,12 +1,16 @@
-# UNRELEASED
+# 5.15.0 RC1
  - Changes from 5.14.3:
    - Bugfixes:
      - FIXED #4704: Fixed regression in bearings reordering introduced in 5.13 [#4704](https://github.com/Project-OSRM/osrm-backend/issues/4704)
+      - FIXED #4781: Fixed overflow exceptions in percent-encoding parsing
+      - FIXED #4770: Fixed exclude flags for single toll road scenario
    - Guidance:
      - CHANGED #4706: Guidance refactoring step to decouple intersection connectivity analysis and turn instructions generation [#4706](https://github.com/Project-OSRM/osrm-backend/pull/4706)

 # 5.14.3
  - Changes from 5.14.2:
+    - Features:
+      - Added a `waypoints` parameter to the match service plugin that accepts indices to input coordinates and treats only those points as waypoints in the response format.
    - Bugfixes:
      - FIXED #4754: U-Turn penalties are applied to straight turns.
      - FIXED #4756: Removed too restrictive road name check in the sliproad handler
@@ -114,7 +114,8 @@ sudo cmake --build . --target install

 ### Request Against the Demo Server

-Read the [API usage policy](https://github.com/Project-OSRM/osrm-backend/wiki/Api-usage-policy).
+Read the [API usage policy](https://github.com/Project-OSRM/osrm-backend/wiki/Demo-server).
+
 Simple query with instructions and alternatives on Berlin:

 ```
@@ -288,6 +288,7 @@ In addition to the [general options](#general-options) the following options are
 |radiuses    |`{radius};{radius}[;{radius} ...]`              |Standard deviation of GPS precision used for map matching. If applicable use GPS accuracy.|
 |gaps        |`split` (default), `ignore`                     |Allows the input track splitting based on huge timestamp gaps between points.             |
 |tidy        |`true`, `false` (default)                       |Allows the input track modification to obtain better matching quality for noisy tracks.   |
+|waypoints   | `{index};{index};{index}...`                   |Treats input coordinates indicated by given indices as waypoints in returned Match object. Default is to treat all input coordinates as waypoints.    |

 |Parameter   |Values                             |
 |------------|-----------------------------------|
@@ -208,16 +208,19 @@ The `process_turn` function is called for every possible turn in the network. Ba

 The following attributes can be read and set on the result in `process_turn`:

-Attribute          | Read/write? | Type    | Notes
-------------------|-------------|---------|------------------------------------------------------
-direction_modifier | Read        | Enum    | Geometry of turn. Defined in `include/extractor/guidance/turn_instruction.hpp`
-turn_type          | Read        | Enum    | Priority of turn. Defined in `include/extractor/guidance/turn_instruction.hpp`
-has_traffic_light  | Read        | Boolean | Is a traffic light present at this turn?
-source_restricted  | Read        | Boolean | Is it from a restricted access road? (See definition in `process_way`)
-target_restricted  | Read        | Boolean | Is it to a restricted access road? (See definition in `process_way`)
-angle              | Read        | Float   | Angle of turn in degrees (`0-360`: `0`=u-turn, `180`=straight on)
-duration           | Read/write  | Float   | Penalty to be applied for this turn (duration in deciseconds)
-weight             | Read/write  | Float   | Penalty to be applied for this turn (routing weight)
+Attribute            | Read/write? | Type    | Notes
+---------------------|-------------|---------|------------------------------------------------------
+angle                | Read        | Float   | Angle of turn in degrees (`0-360`: `0`=u-turn, `180`=straight on)
+number_of_roads      | Read        | Integer | Number of ways at the intersection of the turn
+is_u_turn            | Read        | Boolean | Is the turn a u-turn?
+has_traffic_light    | Read        | Boolean | Is a traffic light present at this turn?
+source_restricted    | Read        | Boolean | Is it from a restricted access road? (See definition in `process_way`)
+target_restricted    | Read        | Boolean | Is it to a restricted access road? (See definition in `process_way`)
+is_left_hand_driving | Read        | Boolean | Is left-hand traffic? 
+weight               | Read/write  | Float   | Penalty to be applied for this turn (routing weight)
+duration             | Read/write  | Float   | Penalty to be applied for this turn (duration in deciseconds)
+source_mode          | Read        | Enum    | Travel mode before the turn. Defined in `include/extractor/travel_mode.hpp`
+target_mode          | Read        | Enum    | Travel mode after the turn. Defined in `include/extractor/travel_mode.hpp`

 ## Guidance
 The guidance parameters in profiles are currently a work in progress. They can and will change.
@@ -393,7 +393,7 @@ Feature: Merge Segregated Roads
            """
              a
              |
-              b
+              b-----z
             / \
            c   h
            |   |
@@ -402,6 +402,9 @@ Feature: Merge Segregated Roads
            |   |
            |   |
            |   |
+            |   |
+            |   |
+            |   |
            d   g
             \ /
              e
@@ -410,18 +413,24 @@ Feature: Merge Segregated Roads
            """

        And the ways
-            | nodes | name | oneway |
-            | ab    | road | no     |
-            | ef    | road | no     |
-            | bcde  | road | yes    |
-            | eghb  | road | yes    |
+            | nodes | name  | oneway |
+            | ab    | road  | no     |
+            | ef    | road  | no     |
+            | bcde  | road  | yes    |
+            | eghb  | road  | yes    |
+            | bz    | cross | no  |
+
+        And the relations
+            | type        | way:from | way:to | node:via | restriction  |
+            | restriction | bz       | bcde   | b        | no_left_turn |

        When I route I should get
-            | waypoints | turns         | route     |
-            | a,f       | depart,arrive | road,road |
-            | c,f       | depart,arrive | road,road |
-            | f,a       | depart,arrive | road,road |
-            | g,a       | depart,arrive | road,road |
+            | waypoints | turns                    | route           |
+            | a,f       | depart,arrive            | road,road       |
+            | c,f       | depart,arrive            | road,road       |
+            | f,a       | depart,arrive            | road,road       |
+            | g,a       | depart,arrive            | road,road       |
+            | z,a       | depart,turn right,arrive | cross,road,road |

    Scenario: Traffic Island
        Given the node map
@@ -592,10 +601,10 @@ Feature: Merge Segregated Roads

        When I route I should get
            | waypoints | route          | turns                        |
-			| a,c       | germ,ober      | depart,arrive                |
-			| a,g       | germ,germ,germ | depart,continue right,arrive |
-			| a,1       | germ,germ,germ | depart,continue left,arrive  |
-			| d,g       | ober,germ,germ | depart,turn left,arrive      |
+            | a,c       | germ,ober      | depart,arrive                |
+            | a,g       | germ,germ,germ | depart,continue right,arrive |
+            | a,1       | germ,germ,germ | depart,continue left,arrive  |
+            | d,g       | ober,germ,germ | depart,turn left,arrive      |

    # https://www.openstreetmap.org/#map=19/51.32888/6.57059
    Scenario: Places in presence of oneways
@@ -627,16 +636,16 @@ Feature: Merge Segregated Roads
            | cf    | albrecht | yes    |

        When I route I should get
-            | waypoints | route                                       | turns                                                        |
-            | a,l       | schwert,albrecht,marianne,marianne          | depart,new name straight,turn left,arrive                    |
-            | a,j       | schwert,luise,luise                         | depart,turn right,arrive                                     |
-			| a,1       | schwert,albrecht,albrecht,albrecht          | depart,new name straight,continue uturn,arrive               |
-			| k,l       | marianne,marianne                           | depart,arrive                                                |
-            | k,j       | marianne,albrecht,luise,luise               | depart,turn left,turn left,arrive                            |
-            | k,d       | marianne,schwert,schwert                    | depart,turn right,arrive                                     |
-			| i,j       | luise,luise                                 | depart,arrive                                                |
-            | i,d       | luise,albrecht,schwert,schwert              | depart,turn left,turn straight,arrive                        |
-			| i,l       | luise,albrecht,marianne,marianne            | depart,turn left,turn left,arrive                            |
+            | waypoints | route                              | turns                                          |
+            | a,l       | schwert,albrecht,marianne,marianne | depart,new name straight,turn left,arrive      |
+            | a,j       | schwert,luise,luise                | depart,turn right,arrive                       |
+            | a,1       | schwert,albrecht,albrecht,albrecht | depart,new name straight,continue uturn,arrive |
+            | k,l       | marianne,marianne                  | depart,arrive                                  |
+            | k,j       | marianne,albrecht,luise,luise      | depart,turn left,turn left,arrive              |
+            | k,d       | marianne,schwert,schwert           | depart,turn right,arrive                       |
+            | i,j       | luise,luise                        | depart,arrive                                  |
+            | i,d       | luise,albrecht,schwert,schwert     | depart,turn left,turn straight,arrive          |
+            | i,l       | luise,albrecht,marianne,marianne   | depart,turn left,turn left,arrive              |

    # https://www.openstreetmap.org/#map=19/52.46339/13.40272
    Scenario: Do not merge links between segregated roads
@@ -150,7 +150,8 @@ module.exports = function () {
                    }
                    var ok = true;
                    var encodedResult = '',
-                        extendedTarget = '';
+                        extendedTarget = '',
+                        resultWaypoints = [];

                    var testSubMatching = (sub, si) => {
                        var testSubNode = (ni) => {
@@ -186,6 +187,29 @@ module.exports = function () {
                        });
                    }

+                    if (headers.has('waypoints')) {
+                        var got_loc = [];
+                        for (let i = 0; i < json.tracepoints.length; i++) {
+                            if (!json.tracepoints[i]) continue;
+                            if (json.tracepoints[i].waypoint_index != null)
+                                got_loc.push(json.tracepoints[i].location);
+                        }
+
+                        if (row.waypoints.length != got_loc.length)
+                            return cb(new Error(`Expected ${row.waypoints.length} waypoints, got ${got_loc.length}`));
+
+                        for (i = 0; i < row.waypoints.length; i++)
+                        {
+                            var want_node = this.findNodeByName(row.waypoints[i]);
+                            if (!this.FuzzyMatch.matchLocation(got_loc[i], want_node)) {
+                                resultWaypoints.push(util.format('? [%s,%s]', got_loc[i][0], got_loc[i][1]));
+                                ok = false;
+                            } else {
+                                resultWaypoints.push(row.waypoints[i]);
+                            }
+                        }
+                    }
+
                    if (ok) {
                        if (headers.has('matchings')) {
                            got.matchings = row.matchings;
@@ -194,7 +218,12 @@ module.exports = function () {
                        if (headers.has('timestamps')) {
                            got.timestamps = row.timestamps;
                        }
+
+                        if (headers.has('waypoints')) {
+                            got.waypoints = row.waypoints;
+                        }
                    } else {
+                        got.waypoints = resultWaypoints.join(';');
                        got.matchings = encodedResult;
                        row.matchings = extendedTarget;
                    }
@@ -0,0 +1,68 @@
+@routing @testbot @exclude
+Feature: Testbot - Exclude flags regression tests
+    Background:
+        Given the profile "testbot"
+
+    Scenario: Testbot - Exclude toll regression 1
+        Given the node map
+            """
+            a               g
+            .               .
+            b....d-$-$-e....f
+            .               .
+            c               h
+            """
+
+        And the ways
+            | nodes | highway  | toll | #               |
+            | ab    | primary  |      | always drivable |
+            | cb    | primary  |      | always drivable |
+            | bd    | primary  |      | always drivable |
+            | de    | motorway | yes  | not drivable for exclude=toll |
+            | ef    | primary  |      | always drivable |
+            | fg    | primary  |      | always drivable |
+            | fh    | primary  |      | always drivable |
+
+        Given the query options
+            | exclude | toll |
+
+        When I route I should get
+            | from | to | route         |
+            | a    | h  |               |
+            | a    | g  |               |
+            | g    | a  |               |
+            | d    | e  |               |
+
+    Scenario: Testbot - Exclude toll regression 2
+        Given the profile "testbot"
+
+        Given the node map
+            """
+            a               g
+            .               .
+            b....d-$-$-e....f
+            .               .
+            c               h..i
+            """
+
+        And the ways
+            | nodes | highway  | toll | #               |
+            | ab    | primary  |      | always drivable |
+            | cb    | primary  |      | always drivable |
+            | bd    | primary  |      | always drivable |
+            | de    | motorway | yes  | not drivable for exclude=toll |
+            | ef    | primary  |      | always drivable |
+            | fg    | primary  |      | always drivable |
+            | fh    | primary  |      | always drivable |
+            | hi    | primary  |      | always drivable |
+
+        Given the query options
+            | exclude | toll |
+
+        When I route I should get
+            | from | to | route         |
+            | a    | h  |               |
+            | a    | g  |               |
+            | g    | a  |               |
+            | d    | e  |               |
+            | d    | i  |               |
@@ -480,3 +480,126 @@ Feature: Basic Map Matching
            | trace | a:nodes     |
            | 12    | 1:2:3:4:5:6 |
            | 21    | 6:5:4:3:2:1 |
+
+
+    Scenario: Matching with waypoints param for start/end
+        Given the node map
+            """
+            a-----b---c
+                  |
+                  |
+                  d
+                  |
+                  |
+                  e
+            """
+        And the ways
+            | nodes | oneway |
+            | abc   | no     |
+            | bde   | no     |
+
+        Given the query options
+            | waypoints | 0;3   |
+
+        When I match I should get
+            | trace | code    | matchings | waypoints |
+            | abde  | Ok      | abde      | ae        |
+
+    Scenario: Matching with waypoints param that were tidied away
+        Given the node map
+            """
+            a - b - c - e
+                    |
+                    f
+                    |
+                    g
+            """
+        And the ways
+            | nodes | oneway |
+            | abce  | no     |
+            | cfg   | no     |
+
+        Given the query options
+            | tidy      | true    |
+            | waypoints | 0;2;5   |
+
+        When I match I should get
+            | trace  | code    | matchings | waypoints |
+            | abccfg | Ok      | abcfg     | acg       |
+
+    Scenario: Testbot - Map matching refuses to use waypoints with trace splitting
+        Given the node map
+            """
+            a b c d
+                e
+            """
+        Given the query options
+            | waypoints | 0;3   |
+
+        And the ways
+            | nodes | oneway |
+            | abcd  | no     |
+
+        When I match I should get
+            | trace | timestamps | code     |
+            | abcd  | 0 1 62 63  | NoMatch  |
+
+    Scenario: Testbot - Map matching invalid waypoints
+        Given the node map
+            """
+            a b c d
+                e
+            """
+        Given the query options
+            | waypoints | 0;4   |
+
+        And the ways
+            | nodes | oneway |
+            | abcd  | no     |
+
+        When I match I should get
+            | trace | code           |
+            | abcd  | InvalidOptions |
+
+    Scenario: Matching fail with waypoints param missing start/end
+        Given the node map
+            """
+            a-----b---c
+                  |
+                  |
+                  d
+                  |
+                  |
+                  e
+            """
+        And the ways
+            | nodes | oneway |
+            | abc   | no     |
+            | bde   | no     |
+
+        Given the query options
+            | waypoints | 1;3   |
+
+        When I match I should get
+            | trace | code         |
+            | abde  | InvalidValue |
+
+    Scenario: Testbot - Map matching with outlier that has no candidate and waypoint parameter
+        Given a grid size of 100 meters
+        Given the node map
+            """
+            a b c d
+
+                1
+            """
+
+        And the ways
+            | nodes | oneway |
+            | abcd  | no     |
+
+        Given the query options
+            | waypoints | 0;2;3   |
+
+        When I match I should get
+            | trace | timestamps | code    |
+            | ab1d  | 0 1 2 3    | NoMatch |
@@ -69,6 +69,11 @@ inline auto contractExcludableGraph(ContractorGraph contractor_graph_,
                });
            non_core_edges.resize(new_end - non_core_edges.begin());
            edge_container.Insert(std::move(non_core_edges));
+
+            for (const auto filter_index : util::irange<std::size_t>(0, filters.size()))
+            {
+                edge_container.Filter(filters[filter_index], filter_index);
+            }
        }

        // Extract core graph for further contraction
@@ -60,6 +60,25 @@ struct ContractedEdgeContainer
        flags.resize(edges.size(), ALL_FLAGS);
    }

+    void Filter(const std::vector<bool> &filter, std::size_t index)
+    {
+        BOOST_ASSERT(index < sizeof(MergedFlags) * CHAR_BIT);
+        const MergedFlags flag = 1 << index;
+
+        for (auto edge_index : util::irange<std::size_t>(0, edges.size()))
+        {
+            auto allowed = filter[edges[edge_index].source] && filter[edges[edge_index].target];
+            if (allowed)
+            {
+                flags[edge_index] |= flag;
+            }
+            else
+            {
+                flags[edge_index] &= ~flag;
+            }
+        }
+    }
+
    void Merge(std::vector<QueryEdge> new_edges)
    {
        BOOST_ASSERT(index < sizeof(MergedFlags) * CHAR_BIT);
@@ -6,6 +6,7 @@
 #include "util/query_heap.hpp"

 #include <tbb/enumerable_thread_specific.h>
+#include <tbb/parallel_for.h>

 #include <unordered_set>

@@ -86,6 +86,10 @@ class MatchAPI final : public RouteAPI
            for (auto point_index : util::irange(
                     0u, static_cast<unsigned>(sub_matchings[sub_matching_index].indices.size())))
            {
+                // tidied_to_original: index of the input coordinate that a tidied coordinate
+                // corresponds to
+                // sub_matching indices: index of the coordinate passed to map matching plugin that
+                // a matched node corresponds to
                trace_idx_to_matching_idx[tidy_result
                                              .tidied_to_original[sub_matchings[sub_matching_index]
                                                                      .indices[point_index]]] =
@@ -93,6 +97,7 @@ class MatchAPI final : public RouteAPI
            }
        }

+        std::size_t was_waypoint_idx = 0;
        for (auto trace_index : util::irange<std::size_t>(0UL, parameters.coordinates.size()))
        {
            if (tidy_result.can_be_removed[trace_index])
@@ -110,10 +115,18 @@ class MatchAPI final : public RouteAPI
                sub_matchings[matching_index.sub_matching_index].nodes[matching_index.point_index];
            auto waypoint = BaseAPI::MakeWaypoint(phantom);
            waypoint.values["matchings_index"] = matching_index.sub_matching_index;
-            waypoint.values["waypoint_index"] = matching_index.point_index;
            waypoint.values["alternatives_count"] =
                sub_matchings[matching_index.sub_matching_index]
                    .alternatives_count[matching_index.point_index];
+            if (tidy_result.was_waypoint[trace_index])
+            {
+                waypoint.values["waypoint_index"] = was_waypoint_idx;
+                was_waypoint_idx++;
+            }
+            else
+            {
+                waypoint.values["waypoint_index"] = util::json::Null();
+            }
            waypoints.values.push_back(std::move(waypoint));
        }

@@ -63,25 +63,40 @@ struct MatchParameters : public RouteParameters
                          RouteParameters::GeometriesType::Polyline,
                          RouteParameters::OverviewType::Simplified,
                          {}),
-          gaps(GapsType::Split), tidy(false)
+          gaps(GapsType::Split), tidy(false), waypoints()
    {
    }

    template <typename... Args>
    MatchParameters(std::vector<unsigned> timestamps_, GapsType gaps_, bool tidy_, Args... args_)
+        : MatchParameters(std::move(timestamps_), gaps_, tidy_, {}, std::forward<Args>(args_)...)
+    {
+    }
+
+    template <typename... Args>
+    MatchParameters(std::vector<unsigned> timestamps_,
+                    GapsType gaps_,
+                    bool tidy_,
+                    std::vector<std::size_t> waypoints_,
+                    Args... args_)
        : RouteParameters{std::forward<Args>(args_)...}, timestamps{std::move(timestamps_)},
-          gaps(gaps_), tidy(tidy_)
+          gaps(gaps_), tidy(tidy_), waypoints{std::move(waypoints_)}
    {
    }

    std::vector<unsigned> timestamps;
    GapsType gaps;
    bool tidy;
+    std::vector<std::size_t> waypoints;

    bool IsValid() const
    {
+        const auto valid_waypoints =
+            std::all_of(waypoints.begin(), waypoints.end(), [this](const auto &w) {
+                return w < coordinates.size();
+            });
        return RouteParameters::IsValid() &&
-               (timestamps.empty() || timestamps.size() == coordinates.size());
+               (timestamps.empty() || timestamps.size() == coordinates.size()) && valid_waypoints;
    }
 };
 }
@@ -37,6 +37,9 @@ struct Result
    Mask can_be_removed;
    // Maps the MatchParameter's original items to items which should not be removed.
    Mapping tidied_to_original;
+    // Masking the MatchParameter coordinates for items whose indices were present in the
+    // `waypoints` parameter.
+    Mask was_waypoint;
 };

 inline Result keep_all(const MatchParameters &params)
@@ -44,6 +47,15 @@ inline Result keep_all(const MatchParameters &params)
    Result result;

    result.can_be_removed.resize(params.coordinates.size(), false);
+    result.was_waypoint.resize(params.coordinates.size(), true);
+    if (!params.waypoints.empty())
+    {
+        for (const auto p : params.waypoints)
+        {
+            result.was_waypoint.set(p, false);
+        }
+        result.was_waypoint.flip();
+    }
    result.tidied_to_original.reserve(params.coordinates.size());
    for (std::size_t current = 0; current < params.coordinates.size(); ++current)
    {
@@ -61,6 +73,8 @@ inline Result keep_all(const MatchParameters &params)
        {
            result.parameters.coordinates.push_back(params.coordinates[i]);

+            if (result.was_waypoint[i])
+                result.parameters.waypoints.push_back(result.parameters.coordinates.size() - 1);
            if (!params.hints.empty())
                result.parameters.hints.push_back(params.hints[i]);

@@ -74,6 +88,8 @@ inline Result keep_all(const MatchParameters &params)
                result.parameters.timestamps.push_back(params.timestamps[i]);
        }
    }
+    if (params.waypoints.empty())
+        result.parameters.waypoints.clear();

    return result;
 }
@@ -85,6 +101,15 @@ inline Result tidy(const MatchParameters &params, Thresholds cfg = {15., 5})
    Result result;

    result.can_be_removed.resize(params.coordinates.size(), false);
+    result.was_waypoint.resize(params.coordinates.size(), true);
+    if (!params.waypoints.empty())
+    {
+        for (const auto p : params.waypoints)
+        {
+            result.was_waypoint.set(p, false);
+        }
+        result.was_waypoint.flip();
+    }

    result.tidied_to_original.push_back(0);

@@ -138,13 +163,14 @@ inline Result tidy(const MatchParameters &params, Thresholds cfg = {15., 5})

    // We have to filter parallel arrays that may be empty or the exact same size.
    // result.parameters contains an empty MatchParameters at this point: conditionally fill.
-
    for (std::size_t i = 0; i < result.can_be_removed.size(); ++i)
    {
        if (!result.can_be_removed[i])
        {
            result.parameters.coordinates.push_back(params.coordinates[i]);

+            if (result.was_waypoint[i])
+                result.parameters.waypoints.push_back(result.parameters.coordinates.size() - 1);
            if (!params.hints.empty())
                result.parameters.hints.push_back(params.hints[i]);

@@ -157,8 +183,17 @@ inline Result tidy(const MatchParameters &params, Thresholds cfg = {15., 5})
            if (!params.timestamps.empty())
                result.parameters.timestamps.push_back(params.timestamps[i]);
        }
+        else
+        {
+            // one of the coordinates meant to be used as a waypoint was marked for removal
+            // update the original waypoint index to the new representative coordinate
+            const auto last_idx = result.parameters.coordinates.size() - 1;
+            if (result.was_waypoint[i] && (result.parameters.waypoints.back() != last_idx))
+            {
+                result.parameters.waypoints.push_back(last_idx);
+            }
+        }
    }
-    BOOST_ASSERT(result.tidied_to_original.size() == result.parameters.coordinates.size());

    return result;
 }
@@ -7,11 +7,11 @@

 #include "engine/phantom_node.hpp"

-#include "osrm/coordinate.hpp"
-
+#include "util/coordinate.hpp"
 #include "util/guidance/entry_class.hpp"
 #include "util/guidance/turn_bearing.hpp"
 #include "util/guidance/turn_lanes.hpp"
+#include "util/integer_range.hpp"
 #include "util/typedefs.hpp"

 #include <vector>
@@ -102,6 +102,56 @@ struct InternalManyRoutesResult

    std::vector<InternalRouteResult> routes;
 };
+
+inline InternalRouteResult CollapseInternalRouteResult(const InternalRouteResult &leggy_result,
+                                                       const std::vector<bool> &is_waypoint)
+{
+    BOOST_ASSERT(leggy_result.is_valid());
+    BOOST_ASSERT(is_waypoint[0]);     // first and last coords
+    BOOST_ASSERT(is_waypoint.back()); // should always be waypoints
+    // Nothing to collapse! return result as is
+    if (leggy_result.unpacked_path_segments.size() == 1)
+        return leggy_result;
+
+    BOOST_ASSERT(leggy_result.segment_end_coordinates.size() > 1);
+
+    InternalRouteResult collapsed;
+    collapsed.shortest_path_weight = leggy_result.shortest_path_weight;
+    for (auto i : util::irange<std::size_t>(0, leggy_result.unpacked_path_segments.size()))
+    {
+        if (is_waypoint[i])
+        {
+            // start another leg vector
+            collapsed.unpacked_path_segments.push_back(leggy_result.unpacked_path_segments[i]);
+            // save new phantom node pair
+            collapsed.segment_end_coordinates.push_back(leggy_result.segment_end_coordinates[i]);
+            // save data about phantom nodes
+            collapsed.source_traversed_in_reverse.push_back(
+                leggy_result.source_traversed_in_reverse[i]);
+            collapsed.target_traversed_in_reverse.push_back(
+                leggy_result.target_traversed_in_reverse[i]);
+        }
+        else
+        // no new leg, collapse the next segment into the last leg
+        {
+            BOOST_ASSERT(!collapsed.unpacked_path_segments.empty());
+            auto &last_segment = collapsed.unpacked_path_segments.back();
+            // deduplicate last segment (needs to be checked for empty for the same node query edge
+            // case)
+            if (!last_segment.empty())
+                last_segment.pop_back();
+            // update target phantom node of leg
+            BOOST_ASSERT(!collapsed.segment_end_coordinates.empty());
+            collapsed.segment_end_coordinates.back().target_phantom =
+                leggy_result.segment_end_coordinates[i].target_phantom;
+            // copy path segments into current leg
+            last_segment.insert(last_segment.end(),
+                                leggy_result.unpacked_path_segments[i].begin(),
+                                leggy_result.unpacked_path_segments[i].end());
+        }
+    }
+    return collapsed;
+}
 }
 }

@@ -39,8 +39,8 @@ struct ExtractionTurn
    const bool is_left_hand_driving;
    double weight;
    double duration;
-    TravelMode source_mode;
-    TravelMode target_mode;
+    const TravelMode source_mode;
+    const TravelMode target_mode;
 };
 }
 }
@@ -12,7 +12,7 @@ namespace osrm
 {
 namespace util
 {
-class Coordinate;
+struct Coordinate;
 }

 namespace extractor
@@ -10,8 +10,6 @@

 #include <boost/optional/optional.hpp>

-#include <tbb/concurrent_vector.h>
-
 #include <string>
 #include <vector>

@@ -16,6 +16,7 @@

 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/range/iterator_range.hpp>
+
 #include <tbb/parallel_sort.h>

 #include <algorithm>
@@ -10,8 +10,9 @@
 #include "util/dynamic_graph.hpp"
 #include "util/typedefs.hpp"

+#include <tbb/blocked_range.h>
+#include <tbb/parallel_for.h>
 #include <tbb/parallel_reduce.h>
-#include <tbb/parallel_sort.h>

 #include <cstdint>

@@ -28,17 +28,31 @@ struct MatchParametersGrammar final : public RouteParametersGrammar<Iterator, Si

    MatchParametersGrammar() : BaseGrammar(root_rule)
    {
+#ifdef BOOST_HAS_LONG_LONG
+        if (std::is_same<std::size_t, unsigned long long>::value)
+            size_t_ = qi::ulong_long;
+        else
+            size_t_ = qi::ulong_;
+#else
+        size_t_ = qi::ulong_;
+#endif
+
        timestamps_rule =
            qi::lit("timestamps=") >
            (qi::uint_ %
             ';')[ph::bind(&engine::api::MatchParameters::timestamps, qi::_r1) = qi::_1];

+        waypoints_rule =
+            qi::lit("waypoints=") >
+            (size_t_ % ';')[ph::bind(&engine::api::MatchParameters::waypoints, qi::_r1) = qi::_1];
+
        gaps_type.add("split", engine::api::MatchParameters::GapsType::Split)(
            "ignore", engine::api::MatchParameters::GapsType::Ignore);

        root_rule =
            BaseGrammar::query_rule(qi::_r1) > -qi::lit(".json") >
            -('?' > (timestamps_rule(qi::_r1) | BaseGrammar::base_rule(qi::_r1) |
+                     waypoints_rule(qi::_r1) |
                     (qi::lit("gaps=") >
                      gaps_type[ph::bind(&engine::api::MatchParameters::gaps, qi::_r1) = qi::_1]) |
                     (qi::lit("tidy=") >
@@ -49,6 +63,8 @@ struct MatchParametersGrammar final : public RouteParametersGrammar<Iterator, Si
  private:
    qi::rule<Iterator, Signature> root_rule;
    qi::rule<Iterator, Signature> timestamps_rule;
+    qi::rule<Iterator, Signature> waypoints_rule;
+    qi::rule<Iterator, std::size_t()> size_t_;

    qi::symbols<char, engine::api::MatchParameters::GapsType> gaps_type;
 };
@@ -10,6 +10,7 @@

 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/iterator/reverse_iterator.hpp>
+
 #include <tbb/atomic.h>

 #include <array>
@@ -23,6 +23,7 @@
 #include <boost/format.hpp>
 #include <boost/iostreams/device/mapped_file.hpp>

+#include <tbb/blocked_range.h>
 #include <tbb/parallel_for.h>
 #include <tbb/parallel_sort.h>

@@ -1,6 +1,6 @@
 {
  "name": "osrm",
-  "version": "5.15.0-latest.4",
+  "version": "5.15.0-rc.1",
  "private": false,
  "description": "The Open Source Routing Machine is a high performance routing engine written in C++14 designed to run on OpenStreetMap data.",
  "dependencies": {
@@ -12,6 +12,7 @@

 #include <boost/assert.hpp>

+#include <tbb/blocked_range.h>
 #include <tbb/enumerable_thread_specific.h>
 #include <tbb/parallel_for.h>
 #include <tbb/parallel_invoke.h>
@@ -17,6 +17,7 @@
 #include <functional>
 #include <iterator>
 #include <memory>
+#include <set>
 #include <string>
 #include <vector>

@@ -174,6 +175,16 @@ Status MatchPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
        tidied = api::tidy::keep_all(parameters);
    }

+    // Error: first and last points should be waypoints
+    if (!parameters.waypoints.empty() &&
+        (tidied.parameters.waypoints[0] != 0 ||
+         tidied.parameters.waypoints.back() != (tidied.parameters.coordinates.size() - 1)))
+    {
+        return Error("InvalidValue",
+                     "First and last coordinates must be specified as waypoints.",
+                     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
@@ -229,6 +240,30 @@ Status MatchPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
        return Error("NoMatch", "Could not match the trace.", json_result);
    }

+    // trace was split, we don't support the waypoints parameter across multiple match objects
+    if (sub_matchings.size() > 1 && !parameters.waypoints.empty())
+    {
+        return Error("NoMatch", "Could not match the trace with the given waypoints.", json_result);
+    }
+
+    // Error: Check if user-supplied waypoints can be found in the resulting matches
+    {
+        std::set<std::size_t> tidied_waypoints(tidied.parameters.waypoints.begin(),
+                                               tidied.parameters.waypoints.end());
+        for (const auto &sm : sub_matchings)
+        {
+            std::for_each(sm.indices.begin(),
+                          sm.indices.end(),
+                          [&tidied_waypoints](const auto index) { tidied_waypoints.erase(index); });
+        }
+        if (!tidied_waypoints.empty())
+        {
+            return Error(
+                "NoMatch", "Requested waypoint parameter could not be matched.", json_result);
+        }
+    }
+
+    // each sub_route will correspond to a MatchObject
    std::vector<InternalRouteResult> sub_routes(sub_matchings.size());
    for (auto index : util::irange<std::size_t>(0UL, sub_matchings.size()))
    {
@@ -245,12 +280,31 @@ Status MatchPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
            BOOST_ASSERT(current_phantom_node_pair.target_phantom.IsValid());
            sub_routes[index].segment_end_coordinates.emplace_back(current_phantom_node_pair);
        }
-        // force uturns to be on, since we split the phantom nodes anyway and only have
-        // bi-directional
-        // phantom nodes for possible uturns
+        // force uturns to be on
+        // we split the phantom nodes anyway and only have bi-directional phantom nodes for
+        // possible uturns
        sub_routes[index] =
            algorithms.ShortestPathSearch(sub_routes[index].segment_end_coordinates, {false});
        BOOST_ASSERT(sub_routes[index].shortest_path_weight != INVALID_EDGE_WEIGHT);
+        if (!tidied.parameters.waypoints.empty())
+        {
+            std::vector<bool> waypoint_legs;
+            waypoint_legs.reserve(sub_matchings[index].indices.size());
+            for (unsigned i = 0, j = 0; i < sub_matchings[index].indices.size(); ++i)
+            {
+                auto current_wp = tidied.parameters.waypoints[j];
+                if (current_wp == sub_matchings[index].indices[i])
+                {
+                    waypoint_legs.push_back(true);
+                    ++j;
+                }
+                else
+                {
+                    waypoint_legs.push_back(false);
+                }
+            }
+            sub_routes[index] = CollapseInternalRouteResult(sub_routes[index], waypoint_legs);
+        }
    }

    api::MatchAPI match_api{facade, parameters, tidied};
@@ -365,7 +365,7 @@ Extractor::ParseOSMData(ScriptingEnvironment &scripting_environment,
    TIMER_START(parsing);

    { // Parse OSM header
-        osmium::io::Reader reader(input_file, osmium::osm_entity_bits::nothing);
+        osmium::io::Reader reader(input_file, pool, osmium::osm_entity_bits::nothing);
        osmium::io::Header header = reader.header();

        std::string generator = header.get("generator");
@@ -545,7 +545,7 @@ Extractor::ParseOSMData(ScriptingEnvironment &scripting_environment,

    { // Relations reading pipeline
        util::Log() << "Parse relations ...";
-        osmium::io::Reader reader(input_file, osmium::osm_entity_bits::relation, read_meta);
+        osmium::io::Reader reader(input_file, pool, osmium::osm_entity_bits::relation, read_meta);
        tbb::parallel_pipeline(
            num_threads, buffer_reader(reader) & buffer_relation_cache & buffer_storage_relation);
    }
@@ -553,6 +553,7 @@ Extractor::ParseOSMData(ScriptingEnvironment &scripting_environment,
    { // Nodes and ways reading pipeline
        util::Log() << "Parse ways and nodes ...";
        osmium::io::Reader reader(input_file,
+                                  pool,
                                  osmium::osm_entity_bits::node | osmium::osm_entity_bits::way |
                                      osmium::osm_entity_bits::relation,
                                  read_meta);
@@ -294,8 +294,12 @@ getIntersectionGeometries(const util::NodeBasedDynamicGraph &graph,

                lhs.perceived_bearing = lhs.initial_bearing = merge.second;
                rhs.perceived_bearing = rhs.initial_bearing = merge.second;
-                merged_edge_ids.insert(lhs.edge);
-                merged_edge_ids.insert(rhs.edge);
+
+                // Only one of the edges must be reversed, mark it as merged to remove from
+                // intersection view
+                BOOST_ASSERT(graph.GetEdgeData(lhs.edge).reversed ^
+                             graph.GetEdgeData(rhs.edge).reversed);
+                merged_edge_ids.insert(graph.GetEdgeData(lhs.edge).reversed ? lhs.edge : rhs.edge);
            }
        }
    }
@@ -19,8 +19,6 @@

 #include <osmium/osm.hpp>

-#include <tbb/parallel_for.h>
-
 #include <memory>
 #include <sstream>

@@ -2,8 +2,6 @@

 #include "util/permutation.hpp"

-#include <tbb/parallel_sort.h>
-
 namespace osrm
 {
 namespace partition
@@ -27,7 +27,8 @@ struct URLParser final : qi::grammar<Iterator, Into>
        using boost::spirit::repository::qi::iter_pos;

        alpha_numeral = qi::char_("a-zA-Z0-9");
-        percent_encoding = qi::char_('%') > qi::uint_parser<char, 16, 2, 2>()[qi::_val = qi::_1];
+        percent_encoding =
+            qi::char_('%') > qi::uint_parser<unsigned char, 16, 2, 2>()[qi::_val = qi::_1];
        polyline_chars = qi::char_("a-zA-Z0-9_.--[]{}@?|\\~`^") | percent_encoding;
        all_chars = polyline_chars | qi::char_("=,;:&().");

@@ -33,10 +33,11 @@
 #include <boost/interprocess/mapped_region.hpp>

 #include <tbb/blocked_range.h>
-#include <tbb/concurrent_unordered_map.h>
+#include <tbb/concurrent_vector.h>
 #include <tbb/enumerable_thread_specific.h>
-#include <tbb/parallel_for_each.h>
+#include <tbb/parallel_for.h>
 #include <tbb/parallel_invoke.h>
+#include <tbb/parallel_sort.h>

 #include <algorithm>
 #include <atomic>
@@ -0,0 +1,148 @@
+#include "engine/internal_route_result.hpp"
+#include "engine/phantom_node.hpp"
+
+#include <boost/test/test_case_template.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <algorithm>
+#include <iterator>
+#include <vector>
+
+BOOST_AUTO_TEST_SUITE(collapse_test)
+
+using namespace osrm;
+using namespace osrm::util;
+using namespace osrm::engine;
+
+BOOST_AUTO_TEST_CASE(unchanged_collapse_route_result)
+{
+    PhantomNode source;
+    PhantomNode target;
+    source.forward_segment_id = {1, true};
+    target.forward_segment_id = {6, true};
+    PathData pathy{2, 17, false, 2, 3, 4, 5, 0, {}, 4, 2, {}, 2, {1.0}, {1.0}, false};
+    PathData kathy{1, 16, false, 1, 2, 3, 4, 1, {}, 3, 1, {}, 1, {2.0}, {3.0}, false};
+    InternalRouteResult one_leg_result;
+    one_leg_result.unpacked_path_segments = {{pathy, kathy}};
+    one_leg_result.segment_end_coordinates = {PhantomNodes{source, target}};
+    one_leg_result.source_traversed_in_reverse = {true};
+    one_leg_result.target_traversed_in_reverse = {true};
+    one_leg_result.shortest_path_weight = 50;
+
+    auto collapsed = CollapseInternalRouteResult(one_leg_result, {true, true});
+    BOOST_CHECK_EQUAL(one_leg_result.unpacked_path_segments[0].front().turn_via_node,
+                      collapsed.unpacked_path_segments[0].front().turn_via_node);
+    BOOST_CHECK_EQUAL(one_leg_result.unpacked_path_segments[0].back().turn_via_node,
+                      collapsed.unpacked_path_segments[0].back().turn_via_node);
+}
+
+BOOST_AUTO_TEST_CASE(two_legs_to_one_leg)
+{
+    PathData pathy{2, 17, false, 2, 3, 4, 5, 0, {}, 4, 2, {}, 2, {1.0}, {1.0}, false};
+    PathData kathy{1, 16, false, 1, 2, 3, 4, 1, {}, 3, 1, {}, 1, {2.0}, {3.0}, false};
+    PathData cathy{3, 16, false, 1, 2, 3, 4, 1, {}, 3, 1, {}, 1, {2.0}, {3.0}, false};
+    PhantomNode node_1;
+    PhantomNode node_2;
+    PhantomNode node_3;
+    node_1.forward_segment_id = {1, true};
+    node_2.forward_segment_id = {6, true};
+    node_3.forward_segment_id = {12, true};
+    InternalRouteResult two_leg_result;
+    two_leg_result.unpacked_path_segments = {{pathy, kathy}, {kathy, cathy}};
+    two_leg_result.segment_end_coordinates = {PhantomNodes{node_1, node_2},
+                                              PhantomNodes{node_2, node_3}};
+    two_leg_result.source_traversed_in_reverse = {true, false};
+    two_leg_result.target_traversed_in_reverse = {true, false};
+    two_leg_result.shortest_path_weight = 80;
+
+    auto collapsed = CollapseInternalRouteResult(two_leg_result, {true, false, true, true});
+    BOOST_CHECK_EQUAL(collapsed.unpacked_path_segments.size(), 1);
+    BOOST_CHECK_EQUAL(collapsed.segment_end_coordinates.size(), 1);
+    BOOST_CHECK_EQUAL(collapsed.segment_end_coordinates[0].target_phantom.forward_segment_id.id,
+                      12);
+    BOOST_CHECK_EQUAL(collapsed.segment_end_coordinates[0].source_phantom.forward_segment_id.id, 1);
+    BOOST_CHECK_EQUAL(collapsed.unpacked_path_segments[0].size(), 3);
+    BOOST_CHECK_EQUAL(collapsed.unpacked_path_segments[0][0].turn_via_node, 2);
+    BOOST_CHECK_EQUAL(collapsed.unpacked_path_segments[0][1].turn_via_node, 1);
+    BOOST_CHECK_EQUAL(collapsed.unpacked_path_segments[0][2].turn_via_node, 3);
+}
+
+BOOST_AUTO_TEST_CASE(three_legs_to_two_legs)
+{
+    PathData pathy{2, 17, false, 2, 3, 4, 5, 0, {}, 4, 2, {}, 2, {1.0}, {1.0}, false};
+    PathData kathy{1, 16, false, 1, 2, 3, 4, 1, {}, 3, 1, {}, 1, {2.0}, {3.0}, false};
+    PathData qathy{5, 16, false, 1, 2, 3, 4, 1, {}, 3, 1, {}, 1, {2.0}, {3.0}, false};
+    PathData cathy{3, 16, false, 1, 2, 3, 4, 1, {}, 3, 1, {}, 1, {2.0}, {3.0}, false};
+    PathData mathy{4, 18, false, 8, 9, 13, 4, 2, {}, 4, 2, {}, 2, {3.0}, {1.0}, false};
+    PhantomNode node_1;
+    PhantomNode node_2;
+    PhantomNode node_3;
+    PhantomNode node_4;
+    node_1.forward_segment_id = {1, true};
+    node_2.forward_segment_id = {6, true};
+    node_3.forward_segment_id = {12, true};
+    node_4.forward_segment_id = {18, true};
+    InternalRouteResult three_leg_result;
+    three_leg_result.unpacked_path_segments = {std::vector<PathData>{pathy, kathy},
+                                               std::vector<PathData>{kathy, qathy, cathy},
+                                               std::vector<PathData>{cathy, mathy}};
+    three_leg_result.segment_end_coordinates = {
+        PhantomNodes{node_1, node_2}, PhantomNodes{node_2, node_3}, PhantomNodes{node_3, node_4}};
+    three_leg_result.source_traversed_in_reverse = {true, false, true},
+    three_leg_result.target_traversed_in_reverse = {true, false, true},
+    three_leg_result.shortest_path_weight = 140;
+
+    auto collapsed = CollapseInternalRouteResult(three_leg_result, {true, true, false, true});
+    BOOST_CHECK_EQUAL(collapsed.unpacked_path_segments.size(), 2);
+    BOOST_CHECK_EQUAL(collapsed.segment_end_coordinates.size(), 2);
+    BOOST_CHECK_EQUAL(collapsed.segment_end_coordinates[0].source_phantom.forward_segment_id.id, 1);
+    BOOST_CHECK_EQUAL(collapsed.segment_end_coordinates[0].target_phantom.forward_segment_id.id, 6);
+    BOOST_CHECK_EQUAL(collapsed.segment_end_coordinates[1].source_phantom.forward_segment_id.id, 6);
+    BOOST_CHECK_EQUAL(collapsed.segment_end_coordinates[1].target_phantom.forward_segment_id.id,
+                      18);
+    BOOST_CHECK_EQUAL(collapsed.unpacked_path_segments[0].size(), 2);
+    BOOST_CHECK_EQUAL(collapsed.unpacked_path_segments[1].size(), 4);
+    BOOST_CHECK_EQUAL(collapsed.unpacked_path_segments[0][0].turn_via_node, 2);
+    BOOST_CHECK_EQUAL(collapsed.unpacked_path_segments[0][1].turn_via_node, 1);
+    BOOST_CHECK_EQUAL(collapsed.unpacked_path_segments[1][0].turn_via_node, 1);
+    BOOST_CHECK_EQUAL(collapsed.unpacked_path_segments[1][1].turn_via_node, 5);
+    BOOST_CHECK_EQUAL(collapsed.unpacked_path_segments[1][2].turn_via_node, 3);
+    BOOST_CHECK_EQUAL(collapsed.unpacked_path_segments[1][3].turn_via_node, 4);
+}
+
+BOOST_AUTO_TEST_CASE(two_legs_to_two_legs)
+{
+    PathData pathy{2, 17, false, 2, 3, 4, 5, 0, {}, 4, 2, {}, 2, {1.0}, {1.0}, false};
+    PathData kathy{1, 16, false, 1, 2, 3, 4, 1, {}, 3, 1, {}, 1, {2.0}, {3.0}, false};
+    PathData cathy{3, 16, false, 1, 2, 3, 4, 1, {}, 3, 1, {}, 1, {2.0}, {3.0}, false};
+    PhantomNode node_1;
+    PhantomNode node_2;
+    PhantomNode node_3;
+    node_1.forward_segment_id = {1, true};
+    node_2.forward_segment_id = {6, true};
+    node_3.forward_segment_id = {12, true};
+    InternalRouteResult two_leg_result;
+    two_leg_result.unpacked_path_segments = {{pathy, kathy}, {kathy, cathy}};
+    two_leg_result.segment_end_coordinates = {PhantomNodes{node_1, node_2},
+                                              PhantomNodes{node_2, node_3}};
+    two_leg_result.source_traversed_in_reverse = {true, false};
+    two_leg_result.target_traversed_in_reverse = {true, false};
+    two_leg_result.shortest_path_weight = 80;
+
+    auto collapsed = CollapseInternalRouteResult(two_leg_result, {true, true, true});
+    BOOST_CHECK_EQUAL(collapsed.unpacked_path_segments.size(), 2);
+    BOOST_CHECK_EQUAL(collapsed.segment_end_coordinates.size(), 2);
+    BOOST_CHECK_EQUAL(collapsed.segment_end_coordinates[0].source_phantom.forward_segment_id.id, 1);
+    BOOST_CHECK_EQUAL(collapsed.segment_end_coordinates[0].target_phantom.forward_segment_id.id, 6);
+    BOOST_CHECK_EQUAL(collapsed.segment_end_coordinates[1].source_phantom.forward_segment_id.id, 6);
+    BOOST_CHECK_EQUAL(collapsed.segment_end_coordinates[1].target_phantom.forward_segment_id.id,
+                      12);
+    BOOST_CHECK_EQUAL(collapsed.unpacked_path_segments[0].size(), 2);
+    BOOST_CHECK_EQUAL(collapsed.unpacked_path_segments[1].size(), 2);
+    BOOST_CHECK_EQUAL(collapsed.unpacked_path_segments[0][0].turn_via_node, 2);
+    BOOST_CHECK_EQUAL(collapsed.unpacked_path_segments[0][1].turn_via_node, 1);
+    BOOST_CHECK_EQUAL(collapsed.unpacked_path_segments[1][0].turn_via_node, 1);
+    BOOST_CHECK_EQUAL(collapsed.unpacked_path_segments[1][1].turn_via_node, 3);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
@@ -555,6 +555,22 @@ BOOST_AUTO_TEST_CASE(valid_match_urls)
    CHECK_EQUAL_RANGE(reference_2.radiuses, result_2->radiuses);
    CHECK_EQUAL_RANGE(reference_2.approaches, result_2->approaches);
    CHECK_EQUAL_RANGE(reference_2.coordinates, result_2->coordinates);
+
+    std::vector<util::Coordinate> coords_2 = {{util::FloatLongitude{1}, util::FloatLatitude{2}},
+                                              {util::FloatLongitude{3}, util::FloatLatitude{4}},
+                                              {util::FloatLongitude{5}, util::FloatLatitude{6}}};
+
+    MatchParameters reference_3{};
+    reference_3.coordinates = coords_2;
+    reference_3.waypoints = {0, 2};
+    auto result_3 = parseParameters<MatchParameters>("1,2;3,4;5,6?waypoints=0;2");
+    BOOST_CHECK(result_3);
+    CHECK_EQUAL_RANGE(reference_3.waypoints, result_3->waypoints);
+    CHECK_EQUAL_RANGE(reference_3.timestamps, result_3->timestamps);
+    CHECK_EQUAL_RANGE(reference_3.bearings, result_3->bearings);
+    CHECK_EQUAL_RANGE(reference_3.radiuses, result_3->radiuses);
+    CHECK_EQUAL_RANGE(reference_3.approaches, result_3->approaches);
+    CHECK_EQUAL_RANGE(reference_3.coordinates, result_3->coordinates);
 }

 BOOST_AUTO_TEST_CASE(invalid_match_urls)
@@ -571,6 +587,15 @@ BOOST_AUTO_TEST_CASE(invalid_match_urls)
    BOOST_CHECK(reference_1.radiuses != result_1->radiuses);
    CHECK_EQUAL_RANGE(reference_1.approaches, result_1->approaches);
    CHECK_EQUAL_RANGE(reference_1.coordinates, result_1->coordinates);
+
+    std::vector<util::Coordinate> coords_2 = {{util::FloatLongitude{1}, util::FloatLatitude{2}},
+                                              {util::FloatLongitude{3}, util::FloatLatitude{4}}};
+
+    MatchParameters reference_2{};
+    reference_2.coordinates = coords_2;
+    BOOST_CHECK_EQUAL(testInvalidOptions<MatchParameters>("1,2;3,4?waypoints=0,4"), 19UL);
+    BOOST_CHECK_EQUAL(testInvalidOptions<MatchParameters>("1,2;3,4?waypoints=x;4"), 18UL);
+    BOOST_CHECK_EQUAL(testInvalidOptions<MatchParameters>("1,2;3,4?waypoints=0;3.5"), 21UL);
 }

 BOOST_AUTO_TEST_CASE(valid_nearest_urls)
Author	SHA1	Message	Date
Michael Krasnyk	6f12a4bd2c	Make 5.15.0-rc.1	2018-01-11 18:25:36 +01:00
Patrick Niklaus	168e313f73	Correctly mark edges going to/from core with exclude flags	2018-01-11 12:46:49 +00:00
Patrick Niklaus	30f910e861	Add regression test from @fijemax	2018-01-11 12:46:49 +00:00
Huyen Chau Nguyen	e998c1193d	Update docs for process_turn in the profile docs (#4786 ) * update correct attributes available in process turn * make travel mode in ExtractedTurn const * fix mismatch of struct and class	2018-01-10 11:31:24 +01:00
Michael Krasnyk	a8f3474996	Use unsigned type in percent_encoding to prevent overflow for %80..%ff Related fix in Boost.Spirit https://github.com/boostorg/spirit/commit/80414bc68868b27e1fd865cbbbc1a6db229825a5	2018-01-08 12:09:33 +00:00
karenzshea	55cc06fd8b	Add waypoints parameter to matching service, returns map matching result with selective input coordinates as waypoints	2018-01-08 12:28:20 +01:00
Karen Shea	8883d8cc56	Update http.md	2018-01-08 12:21:41 +01:00
Mateusz Loskot	5b2af6ef09	Restore use of user-provided osmium::thread::Pool instance Pool instance has been removed from Reader ctor parameters list in PR #4438, presumably unintentionally. It is required to prevent potential deadlock during Pool shutdown as explained in PR #4452.	2018-01-07 18:29:43 +01:00
Patrick Niklaus	6d801e7086	Bumped version to latest.4	2018-01-05 17:35:11 +01:00
Michael Krasnyk	17eb7052ba	Make distance_between_roads symmetrical	2018-01-05 17:35:11 +01:00
Michael Krasnyk	330f25eddb	Reduce extraction distance to 120 meters For intersection at https://www.openstreetmap.org/node/65299217 `are_parallel` in MergableRoadDetector::HaveSameDirection is false for South Van Ness Avenue with 150 meters	2018-01-05 17:35:11 +01:00
Michael Krasnyk	08b88bad63	Still use low precision bearings	2018-01-05 17:35:11 +01:00
Michael Krasnyk	153f9b02a5	Add low precision intersection views back	2018-01-05 17:35:11 +01:00
Michael Krasnyk	0568dca4a3	Adjust to review findings	2018-01-05 17:35:11 +01:00
Michael Krasnyk	60ef179d18	Remove handling of U-turns on motorways	2018-01-05 17:35:11 +01:00
Michael Krasnyk	c64904f5ea	Move roads re-ordering to convertToIntersectionView	2018-01-05 17:35:11 +01:00
Michael Krasnyk	4b9e3a8068	Remove IntersectionGenerator	2018-01-05 17:35:11 +01:00
Michael Krasnyk	db7c76d04d	Remove GetConnectedRoads from IntersectionGenerator	2018-01-05 17:35:11 +01:00
Michael Krasnyk	cc1a5ea78d	Remove usage of IntersectionGenerator in EBGF	2018-01-05 17:35:11 +01:00
Michael Krasnyk	9c033ff461	Free functions for guidance intersections analysis	2018-01-05 17:35:11 +01:00
Michael Krasnyk	3c3322173c	Allow to specify empty bearings string in input parameters	2018-01-05 17:35:11 +01:00
Michael Krasnyk	e805f85407	Print statistics only for allowed turns	2018-01-05 17:35:11 +01:00
Michael Krasnyk	4d54456f66	Don't fail if a registered printer has no name	2018-01-05 17:35:11 +01:00
Daniel J. Hofmann	7359d0542f	Updates readme link for demo server wiki page, closes #4773	2018-01-05 15:19:33 +01:00
Mateusz Loskot	da4fb13aa3	Tidy up #include-s for Intel TBB headers Remove unused and add missing headers.	2018-01-05 11:00:31 +01:00