Set package.json to match tag for publishing.

.travis.yml

@@ -365,7 +365,7 @@ install:
 script:
   - if [[ $TARGET_ARCH == armhf ]] ; then echo "Skip tests for $TARGET_ARCH" && exit 0 ; fi
   - make -C test/data benchmark
-  # - ./example/build/osrm-example test/data/mld/monaco.osrm
+  - ./example/build/osrm-example test/data/mld/monaco.osrm
   # All tests assume to be run from the build directory
   - pushd ${OSRM_BUILD_DIR}
   - ./unit_tests/library-tests

CHANGELOG.md

@@ -2,12 +2,9 @@
   - Changes from 5.18.0:
     - Optimizations:
       - CHANGED: Map matching is now almost twice as fast. [#5060](https://github.com/Project-OSRM/osrm-backend/pull/5060)
-      - CHANGED: Use Grisu2 for serializing floating point numbers. [#5188](https://github.com/Project-OSRM/osrm-backend/pull/5188)
-      - ADDED: Node bindings can return pre-rendered JSON buffer. [#5189](https://github.com/Project-OSRM/osrm-backend/pull/5189)
     - Bugfixes:
       - FIXED: collapsing of ExitRoundabout instructions [#5114](https://github.com/Project-OSRM/osrm-backend/issues/5114)
-    - Misc:
-      - CHANGED: Support up to 512 named shared memory regions [#5185](https://github.com/Project-OSRM/osrm-backend/pull/5185)
+      - FIXED: negative distances in table plugin annotation [#5106](https://github.com/Project-OSRM/osrm-backend/issues/5106)
 
 # 5.18.0
   - Changes from 5.17.0:

docs/nodejs/api.md

@@ -297,29 +297,6 @@ Returns **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refer
                  2) `waypoint_index`: index of the point in the trip.
 **`trips`**: an array of [`Route`](#route) objects that assemble the trace.
 
-## Plugin behaviour
-
-All plugins support a second additional object that is available to configure some NodeJS specific behaviours.
-
--   `plugin_config` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** Object literal containing parameters for the trip query.
-    -   `plugin_config.format` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** The format of the result object to various API calls.  Valid options are `object` (default), which returns a standard Javascript object, as described above, and `json_buffer`, which will return a NodeJS **[Buffer](https://nodejs.org/api/buffer.html)** object, containing a JSON string.  The latter has the advantage that it can be immediately serialized to disk/sent over the network, and the generation of the string is performed outside the main NodeJS event loop.  This option is ignored by the `tile` plugin.
-
-**Examples**
-
-```javascript
-var osrm = new OSRM('network.osrm');
-var options = {
-  coordinates: [
-    [13.36761474609375, 52.51663871100423],
-    [13.374481201171875, 52.506191342034576]
-  ]
-};
-osrm.route(options, { format: "json_buffer" }, function(err, response) {
-  if (err) throw err;
-  console.log(response.toString("utf-8"));
-});
-```
-
 ## Responses
 
 Responses

features/testbot/matching.feature

@@ -792,4 +792,4 @@ Feature: Basic Map Matching
         When I match I should get
           | trace | geometry             | a:distance | a:duration | a:weight | duration |
           | 2345  | 1.00018,1,1.000315,1 | 15.013264  | 1.5        | 1.5      | 1.5      |
-          | 4321  | 1.00027,1,1.000135,1 | 15.013264  | 1.5        | 1.5      | 1.5      |
+          | 4321  | 1.00027,1,1.000135,1 | 15.013264  | 1.5        | 1.5      | 1.5      |

include/contractor/contractor_config.hpp

@@ -72,14 +72,8 @@ struct ContractorConfig final : storage::IOConfig
     // The remaining vertices form the core of the hierarchy
     //(e.g. 0.8 contracts 80 percent of the hierarchy, leaving a core of 20%)
     double core_factor;
-
-    // Whether to store distances for CH edges in addition to duration/weight
-    // Defaults to false.  Setting to true will require more storage/memory,
-    // but avoids the need for path unpacking to learn the distance of a CH
-    // route (useful for faster distance results in table queries)
-    bool cache_distances;
 };
-} // namespace contractor
-} // namespace osrm
+}
+}
 
 #endif // EXTRACTOR_OPTIONS_HPP

include/contractor/contractor_graph.hpp

@@ -12,26 +12,23 @@ namespace contractor
 struct ContractorEdgeData
 {
     ContractorEdgeData()
-        : weight(0), duration(0), distance(0), id(0), originalEdges(0), shortcut(0), forward(0),
-          backward(0)
+        : weight(0), duration(0), id(0), originalEdges(0), shortcut(0), forward(0), backward(0)
     {
     }
     ContractorEdgeData(EdgeWeight weight,
                        EdgeWeight duration,
-                       EdgeDistance distance,
                        unsigned original_edges,
                        unsigned id,
                        bool shortcut,
                        bool forward,
                        bool backward)
-        : weight(weight), duration(duration), distance(distance), id(id),
+        : weight(weight), duration(duration), id(id),
           originalEdges(std::min((1u << 29) - 1u, original_edges)), shortcut(shortcut),
           forward(forward), backward(backward)
     {
     }
     EdgeWeight weight;
     EdgeWeight duration;
-    EdgeDistance distance;
     unsigned id;
     unsigned originalEdges : 29;
     bool shortcut : 1;

include/contractor/graph_contractor_adaptors.hpp

@@ -41,7 +41,6 @@ ContractorGraph toContractorGraph(NodeID number_of_nodes, InputEdgeContainer inp
                            input_edge.target,
                            std::max(input_edge.data.weight, 1),
                            input_edge.data.duration,
-                           input_edge.data.distance,
                            1,
                            input_edge.data.turn_id,
                            false,
@@ -52,7 +51,6 @@ ContractorGraph toContractorGraph(NodeID number_of_nodes, InputEdgeContainer inp
                            input_edge.source,
                            std::max(input_edge.data.weight, 1),
                            input_edge.data.duration,
-                           input_edge.data.distance,
                            1,
                            input_edge.data.turn_id,
                            false,
@@ -84,7 +82,6 @@ ContractorGraph toContractorGraph(NodeID number_of_nodes, InputEdgeContainer inp
         forward_edge.data.originalEdges = reverse_edge.data.originalEdges = 1;
         forward_edge.data.weight = reverse_edge.data.weight = INVALID_EDGE_WEIGHT;
         forward_edge.data.duration = reverse_edge.data.duration = MAXIMAL_EDGE_DURATION;
-        forward_edge.data.distance = reverse_edge.data.distance = MAXIMAL_EDGE_DISTANCE;
         // remove parallel edges
         while (i < edges.size() && edges[i].source == source && edges[i].target == target)
         {
@@ -93,16 +90,12 @@ ContractorGraph toContractorGraph(NodeID number_of_nodes, InputEdgeContainer inp
                 forward_edge.data.weight = std::min(edges[i].data.weight, forward_edge.data.weight);
                 forward_edge.data.duration =
                     std::min(edges[i].data.duration, forward_edge.data.duration);
-                forward_edge.data.distance =
-                    std::min(edges[i].data.distance, forward_edge.data.distance);
             }
             if (edges[i].data.backward)
             {
                 reverse_edge.data.weight = std::min(edges[i].data.weight, reverse_edge.data.weight);
                 reverse_edge.data.duration =
                     std::min(edges[i].data.duration, reverse_edge.data.duration);
-                reverse_edge.data.distance =
-                    std::min(edges[i].data.distance, reverse_edge.data.distance);
             }
             ++i;
         }
@@ -158,7 +151,6 @@ template <class Edge, typename GraphT> inline std::vector<Edge> toEdges(GraphT g
                 BOOST_ASSERT_MSG(SPECIAL_NODEID != new_edge.target, "Target id invalid");
                 new_edge.data.weight = data.weight;
                 new_edge.data.duration = data.duration;
-                new_edge.data.distance = data.distance;
                 new_edge.data.shortcut = data.shortcut;
                 new_edge.data.turn_id = data.id;
                 BOOST_ASSERT_MSG(new_edge.data.turn_id != INT_MAX, // 2^31

include/contractor/query_edge.hpp

@@ -17,8 +17,7 @@ struct QueryEdge
     struct EdgeData
     {
         explicit EdgeData()
-            : turn_id(0), shortcut(false), weight(0), duration(0), forward(false), backward(false),
-              distance(0)
+            : turn_id(0), shortcut(false), weight(0), duration(0), forward(false), backward(false)
         {
         }
 
@@ -26,11 +25,10 @@ struct QueryEdge
                  const bool shortcut,
                  const EdgeWeight weight,
                  const EdgeWeight duration,
-                 const EdgeDistance distance,
                  const bool forward,
                  const bool backward)
             : turn_id(turn_id), shortcut(shortcut), weight(weight), duration(duration),
-              forward(forward), backward(backward), distance(distance)
+              forward(forward), backward(backward)
         {
         }
 
@@ -42,7 +40,6 @@ struct QueryEdge
             turn_id = other.id;
             forward = other.forward;
             backward = other.backward;
-            distance = other.distance;
         }
         // this ID is either the middle node of the shortcut, or the ID of the edge based node (node
         // based edge) storing the appropriate data. If `shortcut` is set to true, we get the middle
@@ -53,7 +50,6 @@ struct QueryEdge
         EdgeWeight duration : 30;
         std::uint32_t forward : 1;
         std::uint32_t backward : 1;
-        EdgeDistance distance;
     } data;
 
     QueryEdge() : source(SPECIAL_NODEID), target(SPECIAL_NODEID) {}
@@ -73,11 +69,10 @@ struct QueryEdge
         return (source == right.source && target == right.target &&
                 data.weight == right.data.weight && data.duration == right.data.duration &&
                 data.shortcut == right.data.shortcut && data.forward == right.data.forward &&
-                data.backward == right.data.backward && data.turn_id == right.data.turn_id &&
-                data.distance == right.data.distance);
+                data.backward == right.data.backward && data.turn_id == right.data.turn_id);
     }
 };
-} // namespace contractor
-} // namespace osrm
+}
+}
 
 #endif // QUERYEDGE_HPP

include/engine/geospatial_query.hpp

@@ -449,6 +449,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         const auto reverse_durations = datafacade.GetUncompressedReverseDurations(geometry_id);
 
         const auto forward_geometry = datafacade.GetUncompressedForwardGeometry(geometry_id);
+        const auto reverse_geometry = datafacade.GetUncompressedReverseGeometry(geometry_id);
 
         const auto forward_weight_offset =
             std::accumulate(forward_weights.begin(),
@@ -479,19 +480,19 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
             datafacade.GetCoordinateOfNode(forward_geometry(data.fwd_segment_position)),
             point_on_segment);
 
-        const auto reverse_weight_offset =
-            std::accumulate(reverse_weights.begin(),
-                            reverse_weights.end() - data.fwd_segment_position - 1,
-                            EdgeWeight{0});
+        const auto rev_segment_position = reverse_weights.size() - data.fwd_segment_position - 1;
+
+        const auto reverse_weight_offset = std::accumulate(
+            reverse_weights.begin(), reverse_weights.begin() + rev_segment_position, EdgeWeight{0});
 
         const auto reverse_duration_offset =
             std::accumulate(reverse_durations.begin(),
-                            reverse_durations.end() - data.fwd_segment_position - 1,
+                            reverse_durations.begin() + rev_segment_position,
                             EdgeDuration{0});
 
         EdgeDistance reverse_distance_offset = 0;
-        for (auto current = forward_geometry.begin();
-             current < forward_geometry.end() - data.fwd_segment_position - 2;
+        for (auto current = reverse_geometry.begin();
+             current < reverse_geometry.begin() + rev_segment_position;
              ++current)
         {
             reverse_distance_offset += util::coordinate_calculation::fccApproximateDistance(
@@ -499,13 +500,11 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                 datafacade.GetCoordinateOfNode(*std::next(current)));
         }
 
-        EdgeWeight reverse_weight =
-            reverse_weights[reverse_weights.size() - data.fwd_segment_position - 1];
-        EdgeDuration reverse_duration =
-            reverse_durations[reverse_durations.size() - data.fwd_segment_position - 1];
+        EdgeWeight reverse_weight = reverse_weights[rev_segment_position];
+        EdgeDuration reverse_duration = reverse_durations[rev_segment_position];
         EdgeDistance reverse_distance = util::coordinate_calculation::fccApproximateDistance(
             point_on_segment,
-            datafacade.GetCoordinateOfNode(forward_geometry(data.fwd_segment_position + 1)));
+            datafacade.GetCoordinateOfNode(reverse_geometry(rev_segment_position)));
 
         ratio = std::min(1.0, std::max(0.0, ratio));
         if (data.forward_segment_id.id != SPECIAL_SEGMENTID)
@@ -693,7 +692,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
     const CoordinateList &coordinates;
     DataFacadeT &datafacade;
 };
-}
-}
+} // namespace engine
+} // namespace osrm
 
 #endif

include/engine/phantom_node.hpp

@@ -34,8 +34,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "util/coordinate.hpp"
 #include "util/typedefs.hpp"
 
-#include <iostream>
-
 #include <boost/assert.hpp>
 
 namespace osrm
@@ -236,7 +234,7 @@ struct PhantomNodes
     PhantomNode source_phantom;
     PhantomNode target_phantom;
 };
-} // namespace engine
-} // namespace osrm
+}
+}
 
 #endif // PHANTOM_NODES_H

include/engine/routing_algorithms/many_to_many.hpp

@@ -25,17 +25,15 @@ struct NodeBucket
     unsigned from_clique_arc : 1;
     EdgeWeight weight;
     EdgeDuration duration;
-    EdgeDistance distance;
 
     NodeBucket(NodeID middle_node,
                NodeID parent_node,
                bool from_clique_arc,
                unsigned column_index,
                EdgeWeight weight,
-               EdgeDuration duration,
-               EdgeDistance distance)
+               EdgeDuration duration)
         : middle_node(middle_node), parent_node(parent_node), column_index(column_index),
-          from_clique_arc(from_clique_arc), weight(weight), duration(duration), distance(distance)
+          from_clique_arc(from_clique_arc), weight(weight), duration(duration)
     {
     }
 
@@ -43,10 +41,9 @@ struct NodeBucket
                NodeID parent_node,
                unsigned column_index,
                EdgeWeight weight,
-               EdgeDuration duration,
-               EdgeDistance distance)
+               EdgeDuration duration)
         : middle_node(middle_node), parent_node(parent_node), column_index(column_index),
-          from_clique_arc(false), weight(weight), duration(duration), distance(distance)
+          from_clique_arc(false), weight(weight), duration(duration)
     {
     }
 

include/engine/routing_algorithms/routing_base.hpp

@@ -44,79 +44,144 @@ bool needsLoopBackwards(const PhantomNode &source_phantom, const PhantomNode &ta
 bool needsLoopForward(const PhantomNodes &phantoms);
 bool needsLoopBackwards(const PhantomNodes &phantoms);
 
-template <typename Heap>
-void insertNodesInHeaps(Heap &forward_heap, Heap &reverse_heap, const PhantomNodes &nodes)
+namespace detail
 {
-    const auto &source = nodes.source_phantom;
-    if (source.IsValidForwardSource())
-    {
-        forward_heap.Insert(source.forward_segment_id.id,
-                            -source.GetForwardWeightPlusOffset(),
-                            source.forward_segment_id.id);
-    }
-
-    if (source.IsValidReverseSource())
-    {
-        forward_heap.Insert(source.reverse_segment_id.id,
-                            -source.GetReverseWeightPlusOffset(),
-                            source.reverse_segment_id.id);
-    }
-
-    const auto &target = nodes.target_phantom;
-    if (target.IsValidForwardTarget())
-    {
-        reverse_heap.Insert(target.forward_segment_id.id,
-                            target.GetForwardWeightPlusOffset(),
-                            target.forward_segment_id.id);
-    }
-
-    if (target.IsValidReverseTarget())
-    {
-        reverse_heap.Insert(target.reverse_segment_id.id,
-                            target.GetReverseWeightPlusOffset(),
-                            target.reverse_segment_id.id);
-    }
-}
-
-template <typename ManyToManyQueryHeap>
-void insertSourceInHeap(ManyToManyQueryHeap &heap, const PhantomNode &phantom_node)
+template <typename Algorithm>
+void insertSourceInHeap(typename SearchEngineData<Algorithm>::ManyToManyQueryHeap &heap,
+                        const PhantomNode &phantom_node)
 {
-    if (phantom_node.IsValidForwardSource())
+    if (phantom_node.IsValidForwardTarget())
     {
         heap.Insert(phantom_node.forward_segment_id.id,
                     -phantom_node.GetForwardWeightPlusOffset(),
-                    {phantom_node.forward_segment_id.id,
-                     -phantom_node.GetForwardDuration(),
-                     -phantom_node.GetForwardDistance()});
+                    {phantom_node.forward_segment_id.id, -phantom_node.GetForwardDuration()});
     }
-    if (phantom_node.IsValidReverseSource())
+    if (phantom_node.IsValidReverseTarget())
     {
         heap.Insert(phantom_node.reverse_segment_id.id,
                     -phantom_node.GetReverseWeightPlusOffset(),
-                    {phantom_node.reverse_segment_id.id,
-                     -phantom_node.GetReverseDuration(),
-                     -phantom_node.GetReverseDistance()});
+                    {phantom_node.reverse_segment_id.id, -phantom_node.GetReverseDuration()});
     }
 }
 
-template <typename ManyToManyQueryHeap>
-void insertTargetInHeap(ManyToManyQueryHeap &heap, const PhantomNode &phantom_node)
+template <typename Algorithm>
+void insertTargetInHeap(typename SearchEngineData<Algorithm>::ManyToManyQueryHeap &heap,
+                        const PhantomNode &phantom_node)
 {
     if (phantom_node.IsValidForwardTarget())
     {
         heap.Insert(phantom_node.forward_segment_id.id,
                     phantom_node.GetForwardWeightPlusOffset(),
-                    {phantom_node.forward_segment_id.id,
-                     phantom_node.GetForwardDuration(),
-                     phantom_node.GetForwardDistance()});
+                    {phantom_node.forward_segment_id.id, phantom_node.GetForwardDuration()});
     }
     if (phantom_node.IsValidReverseTarget())
     {
         heap.Insert(phantom_node.reverse_segment_id.id,
                     phantom_node.GetReverseWeightPlusOffset(),
-                    {phantom_node.reverse_segment_id.id,
-                     phantom_node.GetReverseDuration(),
-                     phantom_node.GetReverseDistance()});
+                    {phantom_node.reverse_segment_id.id, phantom_node.GetReverseDuration()});
+    }
+}
+
+template <typename Algorithm>
+void insertSourceInHeap(typename SearchEngineData<Algorithm>::QueryHeap &heap,
+                        const PhantomNode &phantom_node)
+{
+    if (phantom_node.IsValidForwardSource())
+    {
+        heap.Insert(phantom_node.forward_segment_id.id,
+                    -phantom_node.GetForwardWeightPlusOffset(),
+                    phantom_node.forward_segment_id.id);
+    }
+    if (phantom_node.IsValidReverseSource())
+    {
+        heap.Insert(phantom_node.reverse_segment_id.id,
+                    -phantom_node.GetReverseWeightPlusOffset(),
+                    phantom_node.reverse_segment_id.id);
+    }
+}
+
+template <typename Algorithm>
+void insertTargetInHeap(typename SearchEngineData<Algorithm>::QueryHeap &heap,
+                        const PhantomNode &phantom_node)
+{
+    if (phantom_node.IsValidForwardTarget())
+    {
+        heap.Insert(phantom_node.forward_segment_id.id,
+                    phantom_node.GetForwardWeightPlusOffset(),
+                    phantom_node.forward_segment_id.id);
+    }
+    if (phantom_node.IsValidReverseTarget())
+    {
+        heap.Insert(phantom_node.reverse_segment_id.id,
+                    phantom_node.GetReverseWeightPlusOffset(),
+                    phantom_node.reverse_segment_id.id);
+    }
+}
+} // namespace detail
+
+inline void insertTargetInHeap(typename SearchEngineData<mld::Algorithm>::ManyToManyQueryHeap &heap,
+                               const PhantomNode &phantom_node)
+{
+    detail::insertTargetInHeap<mld::Algorithm>(heap, phantom_node);
+}
+inline void insertTargetInHeap(typename SearchEngineData<ch::Algorithm>::ManyToManyQueryHeap &heap,
+                               const PhantomNode &phantom_node)
+{
+    detail::insertTargetInHeap<ch::Algorithm>(heap, phantom_node);
+}
+inline void insertTargetInHeap(typename SearchEngineData<mld::Algorithm>::QueryHeap &heap,
+                               const PhantomNode &phantom_node)
+{
+    detail::insertTargetInHeap<mld::Algorithm>(heap, phantom_node);
+}
+inline void insertTargetInHeap(typename SearchEngineData<ch::Algorithm>::QueryHeap &heap,
+                               const PhantomNode &phantom_node)
+{
+    detail::insertTargetInHeap<ch::Algorithm>(heap, phantom_node);
+}
+inline void insertSourceInHeap(typename SearchEngineData<mld::Algorithm>::ManyToManyQueryHeap &heap,
+                               const PhantomNode &phantom_node)
+{
+    detail::insertSourceInHeap<mld::Algorithm>(heap, phantom_node);
+}
+inline void insertSourceInHeap(typename SearchEngineData<ch::Algorithm>::ManyToManyQueryHeap &heap,
+                               const PhantomNode &phantom_node)
+{
+    detail::insertSourceInHeap<ch::Algorithm>(heap, phantom_node);
+}
+inline void insertSourceInHeap(typename SearchEngineData<mld::Algorithm>::QueryHeap &heap,
+                               const PhantomNode &phantom_node)
+{
+    detail::insertSourceInHeap<mld::Algorithm>(heap, phantom_node);
+}
+inline void insertSourceInHeap(typename SearchEngineData<ch::Algorithm>::QueryHeap &heap,
+                               const PhantomNode &phantom_node)
+{
+    detail::insertSourceInHeap<ch::Algorithm>(heap, phantom_node);
+}
+
+template <typename Heap>
+void insertNodesInHeaps(Heap &forward_heap, Heap &reverse_heap, const PhantomNodes &nodes)
+{
+    insertSourceInHeap(forward_heap, nodes.source_phantom);
+    insertTargetInHeap(reverse_heap, nodes.target_phantom);
+}
+
+template <typename Algorithm>
+void insertSourceInHeap(typename SearchEngineData<Algorithm>::ManyToManyQueryHeap &heap,
+                        const PhantomNode &phantom_node)
+{
+    if (phantom_node.IsValidForwardSource())
+    {
+        heap.Insert(phantom_node.forward_segment_id.id,
+                    -phantom_node.GetForwardWeightPlusOffset(),
+                    {phantom_node.forward_segment_id.id, -phantom_node.GetForwardDuration()});
+    }
+    if (phantom_node.IsValidReverseSource())
+    {
+        heap.Insert(phantom_node.reverse_segment_id.id,
+                    -phantom_node.GetReverseWeightPlusOffset(),
+                    {phantom_node.reverse_segment_id.id, -phantom_node.GetReverseDuration()});
     }
 }
 
@@ -329,58 +394,10 @@ void annotatePath(const FacadeT &facade,
     }
 }
 
-template <typename Algorithm>
-double getPathDistance(const DataFacade<Algorithm> &facade,
-                       const std::vector<PathData> unpacked_path,
-                       const PhantomNode &source_phantom,
-                       const PhantomNode &target_phantom)
-{
-    using util::coordinate_calculation::detail::DEGREE_TO_RAD;
-    using util::coordinate_calculation::detail::EARTH_RADIUS;
-
-    double distance = 0;
-    double prev_lat =
-        static_cast<double>(util::toFloating(source_phantom.location.lat)) * DEGREE_TO_RAD;
-    double prev_lon =
-        static_cast<double>(util::toFloating(source_phantom.location.lon)) * DEGREE_TO_RAD;
-    double prev_cos = std::cos(prev_lat);
-    for (const auto &p : unpacked_path)
-    {
-        const auto current_coordinate = facade.GetCoordinateOfNode(p.turn_via_node);
-
-        const double current_lat =
-            static_cast<double>(util::toFloating(current_coordinate.lat)) * DEGREE_TO_RAD;
-        const double current_lon =
-            static_cast<double>(util::toFloating(current_coordinate.lon)) * DEGREE_TO_RAD;
-        const double current_cos = std::cos(current_lat);
-
-        const double sin_dlon = std::sin((prev_lon - current_lon) / 2.0);
-        const double sin_dlat = std::sin((prev_lat - current_lat) / 2.0);
-
-        const double aharv = sin_dlat * sin_dlat + prev_cos * current_cos * sin_dlon * sin_dlon;
-        const double charv = 2. * std::atan2(std::sqrt(aharv), std::sqrt(1.0 - aharv));
-        distance += EARTH_RADIUS * charv;
-
-        prev_lat = current_lat;
-        prev_lon = current_lon;
-        prev_cos = current_cos;
-    }
-
-    const double current_lat =
-        static_cast<double>(util::toFloating(target_phantom.location.lat)) * DEGREE_TO_RAD;
-    const double current_lon =
-        static_cast<double>(util::toFloating(target_phantom.location.lon)) * DEGREE_TO_RAD;
-    const double current_cos = std::cos(current_lat);
-
-    const double sin_dlon = std::sin((prev_lon - current_lon) / 2.0);
-    const double sin_dlat = std::sin((prev_lat - current_lat) / 2.0);
-
-    const double aharv = sin_dlat * sin_dlat + prev_cos * current_cos * sin_dlon * sin_dlon;
-    const double charv = 2. * std::atan2(std::sqrt(aharv), std::sqrt(1.0 - aharv));
-    distance += EARTH_RADIUS * charv;
-
-    return distance;
-}
+EdgeDistance adjustPathDistanceToPhantomNodes(const std::vector<NodeID> &path,
+                                              const PhantomNode &source_phantom,
+                                              const PhantomNode &target_phantom,
+                                              const EdgeDistance distance);
 
 template <typename AlgorithmT>
 InternalRouteResult extractRoute(const DataFacade<AlgorithmT> &facade,

include/engine/routing_algorithms/routing_base_ch.hpp

@@ -186,10 +186,9 @@ void routingStep(const DataFacade<Algorithm> &facade,
 }
 
 template <bool UseDuration>
-std::tuple<EdgeWeight, EdgeDistance> getLoopWeight(const DataFacade<Algorithm> &facade, NodeID node)
+EdgeWeight getLoopWeight(const DataFacade<Algorithm> &facade, NodeID node)
 {
     EdgeWeight loop_weight = UseDuration ? MAXIMAL_EDGE_DURATION : INVALID_EDGE_WEIGHT;
-    EdgeDistance loop_distance = MAXIMAL_EDGE_DISTANCE;
     for (auto edge : facade.GetAdjacentEdgeRange(node))
     {
         const auto &data = facade.GetEdgeData(edge);
@@ -199,15 +198,11 @@ std::tuple<EdgeWeight, EdgeDistance> getLoopWeight(const DataFacade<Algorithm> &
             if (to == node)
             {
                 const auto value = UseDuration ? data.duration : data.weight;
-                if (value < loop_weight)
-                {
-                    loop_weight = value;
-                    loop_distance = data.distance;
-                }
+                loop_weight = std::min(loop_weight, value);
             }
         }
     }
-    return std::make_tuple(loop_weight, loop_distance);
+    return loop_weight;
 }
 
 /**

include/engine/routing_algorithms/routing_base_mld.hpp

@@ -97,7 +97,6 @@ inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
                                  const std::vector<std::size_t> &phantom_indices)
 {
     auto min_level = [&partition, node](const PhantomNode &phantom_node) {
-
         const auto &forward_segment = phantom_node.forward_segment_id;
         const auto forward_level =
             forward_segment.enabled ? partition.GetHighestDifferentLevel(node, forward_segment.id)
@@ -120,7 +119,7 @@ inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
     }
     return result;
 }
-}
+} // namespace
 
 // Heaps only record for each node its predecessor ("parent") on the shortest path.
 // For re-constructing the actual path we need to trace back all parent "pointers".
@@ -391,21 +390,27 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
                     EdgeWeight weight_upper_bound,
                     Args... args)
 {
-    if (forward_heap.Empty() || reverse_heap.Empty())
+    if (forward_heap.Empty() && reverse_heap.Empty())
     {
         return std::make_tuple(INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>());
     }
 
     const auto &partition = facade.GetMultiLevelPartition();
 
-    BOOST_ASSERT(!forward_heap.Empty() && forward_heap.MinKey() < INVALID_EDGE_WEIGHT);
-    BOOST_ASSERT(!reverse_heap.Empty() && reverse_heap.MinKey() < INVALID_EDGE_WEIGHT);
+    BOOST_ASSERT(forward_heap.Empty() || forward_heap.MinKey() < INVALID_EDGE_WEIGHT);
+    BOOST_ASSERT(reverse_heap.Empty() || reverse_heap.MinKey() < INVALID_EDGE_WEIGHT);
 
     // run two-Target Dijkstra routing step.
     NodeID middle = SPECIAL_NODEID;
     EdgeWeight weight = weight_upper_bound;
-    EdgeWeight forward_heap_min = forward_heap.MinKey();
-    EdgeWeight reverse_heap_min = reverse_heap.MinKey();
+
+    EdgeWeight forward_heap_min = 0;
+    if (!forward_heap.Empty())
+        forward_heap_min = forward_heap.MinKey();
+    EdgeWeight reverse_heap_min = 0;
+    if (!reverse_heap.Empty())
+        reverse_heap_min = reverse_heap.MinKey();
+
     while (forward_heap.Size() + reverse_heap.Size() > 0 &&
            forward_heap_min + reverse_heap_min < weight)
     {
@@ -657,11 +662,7 @@ double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
                           const PhantomNode &target_phantom,
                           EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
 {
-    forward_heap.Clear();
-    reverse_heap.Clear();
-
     const PhantomNodes phantom_nodes{source_phantom, target_phantom};
-    insertNodesInHeaps(forward_heap, reverse_heap, phantom_nodes);
 
     EdgeWeight weight = INVALID_EDGE_WEIGHT;
     std::vector<NodeID> unpacked_nodes;
@@ -680,11 +681,22 @@ double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
         return std::numeric_limits<double>::max();
     }
 
-    std::vector<PathData> unpacked_path;
+    EdgeDistance distance = 0;
 
-    annotatePath(facade, phantom_nodes, unpacked_nodes, unpacked_edges, unpacked_path);
+    if (!unpacked_nodes.empty())
+    {
+        distance = std::accumulate(unpacked_nodes.begin(),
+                                   std::prev(unpacked_nodes.end()),
+                                   EdgeDistance{0},
+                                   [&](const EdgeDistance distance, const auto node_id) {
+                                       return distance + computeEdgeDistance(facade, node_id);
+                                   });
+    }
 
-    return getPathDistance(facade, unpacked_path, source_phantom, target_phantom);
+    distance = adjustPathDistanceToPhantomNodes(
+        unpacked_nodes, phantom_nodes.source_phantom, phantom_nodes.target_phantom, distance);
+
+    return distance;
 }
 
 } // namespace mld

include/engine/search_engine_data.hpp

@@ -30,11 +30,7 @@ struct HeapData
 struct ManyToManyHeapData : HeapData
 {
     EdgeWeight duration;
-    EdgeDistance distance;
-    ManyToManyHeapData(NodeID p, EdgeWeight duration, EdgeDistance distance)
-        : HeapData(p), duration(duration), distance(distance)
-    {
-    }
+    ManyToManyHeapData(NodeID p, EdgeWeight duration) : HeapData(p), duration(duration) {}
 };
 
 template <> struct SearchEngineData<routing_algorithms::ch::Algorithm>
@@ -79,16 +75,12 @@ struct MultiLayerDijkstraHeapData
 struct ManyToManyMultiLayerDijkstraHeapData : MultiLayerDijkstraHeapData
 {
     EdgeWeight duration;
-    EdgeDistance distance;
-    ManyToManyMultiLayerDijkstraHeapData(NodeID p, EdgeWeight duration, EdgeDistance distance)
-        : MultiLayerDijkstraHeapData(p), duration(duration), distance(distance)
+    ManyToManyMultiLayerDijkstraHeapData(NodeID p, EdgeWeight duration)
+        : MultiLayerDijkstraHeapData(p), duration(duration)
     {
     }
-    ManyToManyMultiLayerDijkstraHeapData(NodeID p,
-                                         bool from,
-                                         EdgeWeight duration,
-                                         EdgeDistance distance)
-        : MultiLayerDijkstraHeapData(p, from), duration(duration), distance(distance)
+    ManyToManyMultiLayerDijkstraHeapData(NodeID p, bool from, EdgeWeight duration)
+        : MultiLayerDijkstraHeapData(p, from), duration(duration)
     {
     }
 };
@@ -120,7 +112,7 @@ template <> struct SearchEngineData<routing_algorithms::mld::Algorithm>
     void InitializeOrClearManyToManyThreadLocalStorage(unsigned number_of_nodes,
                                                        unsigned number_of_boundary_nodes);
 };
-} // namespace engine
-} // namespace osrm
+}
+}
 
 #endif // SEARCH_ENGINE_DATA_HPP

include/extractor/compressed_edge_container.hpp

@@ -82,7 +82,7 @@ class CompressedEdgeContainer
     std::unordered_map<EdgeID, unsigned> m_reverse_edge_id_to_zipped_index_map;
     std::unique_ptr<SegmentDataContainer> segment_data;
 };
-} // namespace extractor
-} // namespace osrm
+}
+}
 
 #endif // GEOMETRY_COMPRESSOR_HPP_

include/extractor/edge_based_edge.hpp

@@ -15,25 +15,20 @@ struct EdgeBasedEdge
   public:
     struct EdgeData
     {
-        EdgeData()
-            : turn_id(0), weight(0), distance(0), duration(0), forward(false), backward(false)
-        {
-        }
+        EdgeData() : turn_id(0), weight(0), duration(0), forward(false), backward(false) {}
 
         EdgeData(const NodeID turn_id,
                  const EdgeWeight weight,
-                 const EdgeDistance distance,
                  const EdgeWeight duration,
                  const bool forward,
                  const bool backward)
-            : turn_id(turn_id), weight(weight), distance(distance), duration(duration),
-              forward(forward), backward(backward)
+            : turn_id(turn_id), weight(weight), duration(duration), forward(forward),
+              backward(backward)
         {
         }
 
         NodeID turn_id; // ID of the edge based node (node based edge)
         EdgeWeight weight;
-        EdgeDistance distance;
         EdgeWeight duration : 30;
         std::uint32_t forward : 1;
         std::uint32_t backward : 1;
@@ -48,7 +43,6 @@ struct EdgeBasedEdge
                   const NodeID edge_id,
                   const EdgeWeight weight,
                   const EdgeWeight duration,
-                  const EdgeDistance distance,
                   const bool forward,
                   const bool backward);
     EdgeBasedEdge(const NodeID source, const NodeID target, const EdgeBasedEdge::EdgeData &data);
@@ -59,7 +53,7 @@ struct EdgeBasedEdge
     NodeID target;
     EdgeData data;
 };
-static_assert(sizeof(extractor::EdgeBasedEdge) == 24,
+static_assert(sizeof(extractor::EdgeBasedEdge) == 20,
               "Size of extractor::EdgeBasedEdge type is "
               "bigger than expected. This will influence "
               "memory consumption.");
@@ -73,10 +67,9 @@ inline EdgeBasedEdge::EdgeBasedEdge(const NodeID source,
                                     const NodeID turn_id,
                                     const EdgeWeight weight,
                                     const EdgeWeight duration,
-                                    const EdgeDistance distance,
                                     const bool forward,
                                     const bool backward)
-    : source(source), target(target), data{turn_id, weight, distance, duration, forward, backward}
+    : source(source), target(target), data{turn_id, weight, duration, forward, backward}
 {
 }
 
@@ -96,7 +89,7 @@ inline bool EdgeBasedEdge::operator<(const EdgeBasedEdge &other) const
     return std::tie(source, target, data.weight, unidirectional) <
            std::tie(other.source, other.target, other.data.weight, other_is_unidirectional);
 }
-} // namespace extractor
-} // namespace osrm
+} // ns extractor
+} // ns osrm
 
 #endif /* EDGE_BASED_EDGE_HPP */

include/extractor/internal_extractor_edge.hpp

@@ -49,7 +49,7 @@ struct ByEdgeOrByMeterValue
     using value_type = float;
     value_type value;
 };
-} // namespace detail
+}
 
 struct InternalExtractorEdge
 {
@@ -63,7 +63,7 @@ struct InternalExtractorEdge
                                    WeightData weight_data,
                                    DurationData duration_data,
                                    util::Coordinate source_coordinate)
-        : result(source, target, 0, 0, 0, {}, -1, {}), weight_data(std::move(weight_data)),
+        : result(source, target, 0, 0, {}, -1, {}), weight_data(std::move(weight_data)),
           duration_data(std::move(duration_data)), source_coordinate(std::move(source_coordinate))
     {
     }
@@ -113,7 +113,7 @@ struct InternalExtractorEdge
         return v;
     }
 };
-} // namespace extractor
-} // namespace osrm
+}
+}
 
 #endif // INTERNAL_EXTRACTOR_EDGE_HPP

include/extractor/node_based_edge.hpp

@@ -97,7 +97,6 @@ struct NodeBasedEdge
                   NodeID target,
                   EdgeWeight weight,
                   EdgeDuration duration,
-                  EdgeDistance distance,
                   GeometryID geometry_id,
                   AnnotationID annotation_data,
                   NodeBasedEdgeClassification flags);
@@ -108,7 +107,6 @@ struct NodeBasedEdge
     NodeID target;                     // 32 4
     EdgeWeight weight;                 // 32 4
     EdgeDuration duration;             // 32 4
-    EdgeDistance distance;             // 32 4
     GeometryID geometry_id;            // 32 4
     AnnotationID annotation_data;      // 32 4
     NodeBasedEdgeClassification flags; // 32 4
@@ -122,7 +120,6 @@ struct NodeBasedEdgeWithOSM : NodeBasedEdge
                          OSMNodeID target,
                          EdgeWeight weight,
                          EdgeDuration duration,
-                         EdgeDistance distance,
                          GeometryID geometry_id,
                          AnnotationID annotation_data,
                          NodeBasedEdgeClassification flags);
@@ -140,8 +137,7 @@ inline NodeBasedEdgeClassification::NodeBasedEdgeClassification()
 }
 
 inline NodeBasedEdge::NodeBasedEdge()
-    : source(SPECIAL_NODEID), target(SPECIAL_NODEID), weight(0), duration(0), distance(0),
-      annotation_data(-1)
+    : source(SPECIAL_NODEID), target(SPECIAL_NODEID), weight(0), duration(0), annotation_data(-1)
 {
 }
 
@@ -149,12 +145,11 @@ inline NodeBasedEdge::NodeBasedEdge(NodeID source,
                                     NodeID target,
                                     EdgeWeight weight,
                                     EdgeDuration duration,
-                                    EdgeDistance distance,
                                     GeometryID geometry_id,
                                     AnnotationID annotation_data,
                                     NodeBasedEdgeClassification flags)
-    : source(source), target(target), weight(weight), duration(duration), distance(distance),
-      geometry_id(geometry_id), annotation_data(annotation_data), flags(flags)
+    : source(source), target(target), weight(weight), duration(duration), geometry_id(geometry_id),
+      annotation_data(annotation_data), flags(flags)
 {
 }
 
@@ -180,18 +175,11 @@ inline NodeBasedEdgeWithOSM::NodeBasedEdgeWithOSM(OSMNodeID source,
                                                   OSMNodeID target,
                                                   EdgeWeight weight,
                                                   EdgeDuration duration,
-                                                  EdgeDistance distance,
                                                   GeometryID geometry_id,
                                                   AnnotationID annotation_data,
                                                   NodeBasedEdgeClassification flags)
-    : NodeBasedEdge(SPECIAL_NODEID,
-                    SPECIAL_NODEID,
-                    weight,
-                    duration,
-                    distance,
-                    geometry_id,
-                    annotation_data,
-                    flags),
+    : NodeBasedEdge(
+          SPECIAL_NODEID, SPECIAL_NODEID, weight, duration, geometry_id, annotation_data, flags),
       osm_source_id(std::move(source)), osm_target_id(std::move(target))
 {
 }
@@ -201,12 +189,12 @@ inline NodeBasedEdgeWithOSM::NodeBasedEdgeWithOSM()
 {
 }
 
-static_assert(sizeof(extractor::NodeBasedEdge) == 32,
+static_assert(sizeof(extractor::NodeBasedEdge) == 28,
               "Size of extractor::NodeBasedEdge type is "
               "bigger than expected. This will influence "
               "memory consumption.");
 
-} // namespace extractor
-} // namespace osrm
+} // ns extractor
+} // ns osrm
 
 #endif /* NODE_BASED_EDGE_HPP */

include/nodejs/node_osrm_support.hpp

@@ -2,7 +2,6 @@
 #define OSRM_BINDINGS_NODE_SUPPORT_HPP
 
 #include "nodejs/json_v8_renderer.hpp"
-#include "util/json_renderer.hpp"
 
 #include "osrm/approach.hpp"
 #include "osrm/bearing.hpp"
@@ -25,7 +24,6 @@
 #include <algorithm>
 #include <iostream>
 #include <iterator>
-#include <sstream>
 #include <string>
 #include <vector>
 
@@ -44,13 +42,6 @@ using match_parameters_ptr = std::unique_ptr<osrm::MatchParameters>;
 using nearest_parameters_ptr = std::unique_ptr<osrm::NearestParameters>;
 using table_parameters_ptr = std::unique_ptr<osrm::TableParameters>;
 
-struct PluginParameters
-{
-    bool renderJSONToBuffer = false;
-};
-
-using ObjectOrString = typename mapbox::util::variant<osrm::json::Object, std::string>;
-
 template <typename ResultT> inline v8::Local<v8::Value> render(const ResultT &result);
 
 template <> v8::Local<v8::Value> inline render(const std::string &result)
@@ -58,21 +49,11 @@ template <> v8::Local<v8::Value> inline render(const std::string &result)
     return Nan::CopyBuffer(result.data(), result.size()).ToLocalChecked();
 }
 
-template <> v8::Local<v8::Value> inline render(const ObjectOrString &result)
+template <> v8::Local<v8::Value> inline render(const osrm::json::Object &result)
 {
-    if (result.is<osrm::json::Object>())
-    {
-        // Convert osrm::json object tree into matching v8 object tree
-        v8::Local<v8::Value> value;
-        renderToV8(value, result.get<osrm::json::Object>());
-        return value;
-    }
-    else
-    {
-        // Return the string object as a node Buffer
-        return Nan::CopyBuffer(result.get<std::string>().data(), result.get<std::string>().size())
-            .ToLocalChecked();
-    }
+    v8::Local<v8::Value> value;
+    renderToV8(value, result);
+    return value;
 }
 
 inline void ParseResult(const osrm::Status &result_status, osrm::json::Object &result)
@@ -833,50 +814,6 @@ inline bool parseCommonParameters(const v8::Local<v8::Object> &obj, ParamType &p
     return true;
 }
 
-inline PluginParameters
-argumentsToPluginParameters(const Nan::FunctionCallbackInfo<v8::Value> &args)
-{
-    if (args.Length() < 3 || !args[1]->IsObject())
-    {
-        return {};
-    }
-    v8::Local<v8::Object> obj = Nan::To<v8::Object>(args[1]).ToLocalChecked();
-    if (obj->Has(Nan::New("format").ToLocalChecked()))
-    {
-
-        v8::Local<v8::Value> format = obj->Get(Nan::New("format").ToLocalChecked());
-        if (format.IsEmpty())
-        {
-            return {};
-        }
-
-        if (!format->IsString())
-        {
-            Nan::ThrowError("format must be a string: \"object\" or \"json_buffer\"");
-            return {};
-        }
-
-        const Nan::Utf8String format_utf8str(format);
-        std::string format_str{*format_utf8str, *format_utf8str + format_utf8str.length()};
-
-        if (format_str == "object")
-        {
-            return {false};
-        }
-        else if (format_str == "json_buffer")
-        {
-            return {true};
-        }
-        else
-        {
-            Nan::ThrowError("format must be a string: \"object\" or \"json_buffer\"");
-            return {};
-        }
-    }
-
-    return {};
-}
-
 inline route_parameters_ptr
 argumentsToRouteParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
                           bool requires_multiple_coordinates)
@@ -1420,6 +1357,6 @@ argumentsToMatchParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
     return params;
 }
 
-} // namespace node_osrm
+} // ns node_osrm
 
 #endif

include/partitioner/edge_based_graph_reader.hpp

@@ -14,8 +14,6 @@
 #include <tbb/parallel_for.h>
 #include <tbb/parallel_reduce.h>
 
-#include <iostream>
-
 #include <cstdint>
 
 #include <algorithm>
@@ -45,7 +43,6 @@ splitBidirectionalEdges(const std::vector<extractor::EdgeBasedEdge> &edges)
                               edge.data.turn_id,
                               std::max(edge.data.weight, 1),
                               edge.data.duration,
-                              edge.data.distance,
                               edge.data.forward,
                               edge.data.backward);
 
@@ -54,7 +51,6 @@ splitBidirectionalEdges(const std::vector<extractor::EdgeBasedEdge> &edges)
                               edge.data.turn_id,
                               std::max(edge.data.weight, 1),
                               edge.data.duration,
-                              edge.data.distance,
                               edge.data.backward,
                               edge.data.forward);
     }
@@ -200,7 +196,7 @@ inline DynamicEdgeBasedGraph LoadEdgeBasedGraph(const boost::filesystem::path &p
     return DynamicEdgeBasedGraph(number_of_edge_based_nodes, std::move(tidied), checksum);
 }
 
-} // namespace partitioner
-} // namespace osrm
+} // ns partition
+} // ns osrm
 
 #endif

include/storage/shared_monitor.hpp

@@ -146,9 +146,7 @@ template <typename Data> struct SharedMonitor
     // like two-turnstile reusable barrier or boost/interprocess/sync/spin/condition.hpp
     // fail if a waiter is killed.
 
-    // Buffer size needs to be large enough to hold all the semaphores for every
-    // listener you want to support.
-    static constexpr int buffer_size = 4096 * 4;
+    static constexpr int buffer_size = 4096;
 
     struct InternalData
     {

include/util/coordinate_calculation.hpp

@@ -23,9 +23,6 @@ namespace detail
 {
 const constexpr double DEGREE_TO_RAD = 0.017453292519943295769236907684886;
 const constexpr double RAD_TO_DEGREE = 1. / DEGREE_TO_RAD;
-// earth radius varies between 6,356.750-6,378.135 km (3,949.901-3,963.189mi)
-// The IUGG value for the equatorial radius is 6378.137 km (3963.19 miles)
-const constexpr long double EARTH_RADIUS = 6372797.560856;
 
 inline double degToRad(const double degree)
 {

include/util/debug.hpp

@@ -1,11 +1,9 @@
 #ifndef OSRM_UTIL_DEBUG_HPP_
 #define OSRM_UTIL_DEBUG_HPP_
 
-#include "extractor/edge_based_edge.hpp"
 #include "extractor/node_data_container.hpp"
 #include "extractor/query_node.hpp"
 #include "guidance/intersection.hpp"
-#include "guidance/turn_instruction.hpp"
 #include "guidance/turn_lane_data.hpp"
 #include "engine/guidance/route_step.hpp"
 #include "util/node_based_graph.hpp"
@@ -27,7 +25,7 @@ inline std::ostream &operator<<(std::ostream &out, const Coordinate &coordinate)
         << toFloating(coordinate.lat) << "}";
     return out;
 }
-} // namespace util
+}
 
 namespace engine
 {
@@ -62,8 +60,8 @@ inline std::ostream &operator<<(std::ostream &out, const RouteStep &step)
 
     return out;
 }
-} // namespace guidance
-} // namespace engine
+}
+}
 
 namespace guidance
 {
@@ -76,7 +74,7 @@ inline std::ostream &operator<<(std::ostream &out, const ConnectedRoad &road)
         << static_cast<std::int32_t>(road.lane_data_id) << "}";
     return out;
 }
-} // namespace guidance
+}
 
 namespace extractor
 {
@@ -95,7 +93,7 @@ inline std::ostream &operator<<(std::ostream &out, const IntersectionViewData &v
         << " angle: " << view.angle << " bearing: " << view.perceived_bearing << "}";
     return out;
 }
-} // namespace intersection
+}
 
 namespace TurnLaneType
 {
@@ -125,9 +123,9 @@ inline std::ostream &operator<<(std::ostream &out, const Mask lane_type)
 
     return out;
 }
-} // namespace TurnLaneType
-} // namespace extractor
-} // namespace osrm
+}
+}
+}
 
 namespace std
 {
@@ -147,7 +145,7 @@ inline std::ostream &operator<<(std::ostream &out,
 
     return out;
 }
-} // namespace std
+}
 
 namespace osrm
 {
@@ -186,26 +184,8 @@ inline std::ostream &operator<<(std::ostream &out, const LaneDataVector &turn_la
 
     return out;
 }
-} // namespace lanes
-} // namespace guidance
-
-namespace extractor
-{
-inline std::ostream &operator<<(std::ostream &out, const EdgeBasedEdge &edge)
-{
-    out << " EdgeBasedEdge {";
-    out << " source " << edge.source << ", target: " << edge.target;
-    out << " EdgeBasedEdgeData data {";
-    out << " turn_id: " << edge.data.turn_id << ", weight: " << edge.data.weight;
-    out << " distance: " << edge.data.distance << ", duration: " << edge.data.duration;
-    out << " forward: " << (edge.data.forward == 0 ? "false" : "true")
-        << ", backward: " << (edge.data.backward == 0 ? "false" : "true");
-    out << " }";
-    out << "}";
-    return out;
+}
+}
 }
 
-} // namespace extractor
-} // namespace osrm
-
 #endif /*OSRM_ENGINE_GUIDANCE_DEBUG_HPP_*/

include/util/ieee754.hpp

@@ -1,517 +0,0 @@
-#ifndef IEEE754_HPP
-#define IEEE754_HPP
-/**
-Copyright (C) 2014 Milo Yip
-
-Imported from:
-https://github.com/miloyip/dtoa-benchmark/blob/c4020c62754950d38a1aaaed2975b05b441d1e7d/src/milo/dtoa_milo.h
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-**/
-
-#include <assert.h>
-#include <math.h>
-
-#if defined(_MSC_VER)
-#include "msinttypes/stdint.h"
-#include <intrin.h>
-#else
-#include <stdint.h>
-#endif
-
-#define UINT64_C2(h, l) ((static_cast<uint64_t>(h) << 32) | static_cast<uint64_t>(l))
-
-namespace osrm
-{
-namespace util
-{
-namespace ieee754
-{
-
-struct DiyFp
-{
-    DiyFp() {}
-
-    DiyFp(uint64_t f, int e) : f(f), e(e) {}
-
-    DiyFp(double d)
-    {
-        union {
-            double d;
-            uint64_t u64;
-        } u = {d};
-
-        int biased_e = (u.u64 & kDpExponentMask) >> kDpSignificandSize;
-        uint64_t significand = (u.u64 & kDpSignificandMask);
-        if (biased_e != 0)
-        {
-            f = significand + kDpHiddenBit;
-            e = biased_e - kDpExponentBias;
-        }
-        else
-        {
-            f = significand;
-            e = kDpMinExponent + 1;
-        }
-    }
-
-    DiyFp operator-(const DiyFp &rhs) const
-    {
-        assert(e == rhs.e);
-        assert(f >= rhs.f);
-        return DiyFp(f - rhs.f, e);
-    }
-
-    DiyFp operator*(const DiyFp &rhs) const
-    {
-#if defined(_MSC_VER) && defined(_M_AMD64)
-        uint64_t h;
-        uint64_t l = _umul128(f, rhs.f, &h);
-        if (l & (uint64_t(1) << 63)) // rounding
-            h++;
-        return DiyFp(h, e + rhs.e + 64);
-#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
-        unsigned __int128 p =
-            static_cast<unsigned __int128>(f) * static_cast<unsigned __int128>(rhs.f);
-        uint64_t h = p >> 64;
-        uint64_t l = static_cast<uint64_t>(p);
-        if (l & (uint64_t(1) << 63)) // rounding
-            h++;
-        return DiyFp(h, e + rhs.e + 64);
-#else
-        const uint64_t M32 = 0xFFFFFFFF;
-        const uint64_t a = f >> 32;
-        const uint64_t b = f & M32;
-        const uint64_t c = rhs.f >> 32;
-        const uint64_t d = rhs.f & M32;
-        const uint64_t ac = a * c;
-        const uint64_t bc = b * c;
-        const uint64_t ad = a * d;
-        const uint64_t bd = b * d;
-        uint64_t tmp = (bd >> 32) + (ad & M32) + (bc & M32);
-        tmp += 1U << 31; /// mult_round
-        return DiyFp(ac + (ad >> 32) + (bc >> 32) + (tmp >> 32), e + rhs.e + 64);
-#endif
-    }
-
-    DiyFp Normalize() const
-    {
-#if defined(_MSC_VER) && defined(_M_AMD64)
-        unsigned long index;
-        _BitScanReverse64(&index, f);
-        return DiyFp(f << (63 - index), e - (63 - index));
-#elif defined(__GNUC__)
-        int s = __builtin_clzll(f);
-        return DiyFp(f << s, e - s);
-#else
-        DiyFp res = *this;
-        while (!(res.f & kDpHiddenBit))
-        {
-            res.f <<= 1;
-            res.e--;
-        }
-        res.f <<= (kDiySignificandSize - kDpSignificandSize - 1);
-        res.e = res.e - (kDiySignificandSize - kDpSignificandSize - 1);
-        return res;
-#endif
-    }
-
-    DiyFp NormalizeBoundary() const
-    {
-#if defined(_MSC_VER) && defined(_M_AMD64)
-        unsigned long index;
-        _BitScanReverse64(&index, f);
-        return DiyFp(f << (63 - index), e - (63 - index));
-#else
-        DiyFp res = *this;
-        while (!(res.f & (kDpHiddenBit << 1)))
-        {
-            res.f <<= 1;
-            res.e--;
-        }
-        res.f <<= (kDiySignificandSize - kDpSignificandSize - 2);
-        res.e = res.e - (kDiySignificandSize - kDpSignificandSize - 2);
-        return res;
-#endif
-    }
-
-    void NormalizedBoundaries(DiyFp *minus, DiyFp *plus) const
-    {
-        DiyFp pl = DiyFp((f << 1) + 1, e - 1).NormalizeBoundary();
-        DiyFp mi = (f == kDpHiddenBit) ? DiyFp((f << 2) - 1, e - 2) : DiyFp((f << 1) - 1, e - 1);
-        mi.f <<= mi.e - pl.e;
-        mi.e = pl.e;
-        *plus = pl;
-        *minus = mi;
-    }
-
-    static const int kDiySignificandSize = 64;
-    static const int kDpSignificandSize = 52;
-    static const int kDpExponentBias = 0x3FF + kDpSignificandSize;
-    static const int kDpMinExponent = -kDpExponentBias;
-    static const uint64_t kDpExponentMask = UINT64_C2(0x7FF00000, 0x00000000);
-    static const uint64_t kDpSignificandMask = UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
-    static const uint64_t kDpHiddenBit = UINT64_C2(0x00100000, 0x00000000);
-
-    uint64_t f;
-    int e;
-};
-
-inline DiyFp GetCachedPower(int e, int *K)
-{
-    // 10^-348, 10^-340, ..., 10^340
-    static const uint64_t kCachedPowers_F[] = {
-        UINT64_C2(0xfa8fd5a0, 0x081c0288), UINT64_C2(0xbaaee17f, 0xa23ebf76),
-        UINT64_C2(0x8b16fb20, 0x3055ac76), UINT64_C2(0xcf42894a, 0x5dce35ea),
-        UINT64_C2(0x9a6bb0aa, 0x55653b2d), UINT64_C2(0xe61acf03, 0x3d1a45df),
-        UINT64_C2(0xab70fe17, 0xc79ac6ca), UINT64_C2(0xff77b1fc, 0xbebcdc4f),
-        UINT64_C2(0xbe5691ef, 0x416bd60c), UINT64_C2(0x8dd01fad, 0x907ffc3c),
-        UINT64_C2(0xd3515c28, 0x31559a83), UINT64_C2(0x9d71ac8f, 0xada6c9b5),
-        UINT64_C2(0xea9c2277, 0x23ee8bcb), UINT64_C2(0xaecc4991, 0x4078536d),
-        UINT64_C2(0x823c1279, 0x5db6ce57), UINT64_C2(0xc2109436, 0x4dfb5637),
-        UINT64_C2(0x9096ea6f, 0x3848984f), UINT64_C2(0xd77485cb, 0x25823ac7),
-        UINT64_C2(0xa086cfcd, 0x97bf97f4), UINT64_C2(0xef340a98, 0x172aace5),
-        UINT64_C2(0xb23867fb, 0x2a35b28e), UINT64_C2(0x84c8d4df, 0xd2c63f3b),
-        UINT64_C2(0xc5dd4427, 0x1ad3cdba), UINT64_C2(0x936b9fce, 0xbb25c996),
-        UINT64_C2(0xdbac6c24, 0x7d62a584), UINT64_C2(0xa3ab6658, 0x0d5fdaf6),
-        UINT64_C2(0xf3e2f893, 0xdec3f126), UINT64_C2(0xb5b5ada8, 0xaaff80b8),
-        UINT64_C2(0x87625f05, 0x6c7c4a8b), UINT64_C2(0xc9bcff60, 0x34c13053),
-        UINT64_C2(0x964e858c, 0x91ba2655), UINT64_C2(0xdff97724, 0x70297ebd),
-        UINT64_C2(0xa6dfbd9f, 0xb8e5b88f), UINT64_C2(0xf8a95fcf, 0x88747d94),
-        UINT64_C2(0xb9447093, 0x8fa89bcf), UINT64_C2(0x8a08f0f8, 0xbf0f156b),
-        UINT64_C2(0xcdb02555, 0x653131b6), UINT64_C2(0x993fe2c6, 0xd07b7fac),
-        UINT64_C2(0xe45c10c4, 0x2a2b3b06), UINT64_C2(0xaa242499, 0x697392d3),
-        UINT64_C2(0xfd87b5f2, 0x8300ca0e), UINT64_C2(0xbce50864, 0x92111aeb),
-        UINT64_C2(0x8cbccc09, 0x6f5088cc), UINT64_C2(0xd1b71758, 0xe219652c),
-        UINT64_C2(0x9c400000, 0x00000000), UINT64_C2(0xe8d4a510, 0x00000000),
-        UINT64_C2(0xad78ebc5, 0xac620000), UINT64_C2(0x813f3978, 0xf8940984),
-        UINT64_C2(0xc097ce7b, 0xc90715b3), UINT64_C2(0x8f7e32ce, 0x7bea5c70),
-        UINT64_C2(0xd5d238a4, 0xabe98068), UINT64_C2(0x9f4f2726, 0x179a2245),
-        UINT64_C2(0xed63a231, 0xd4c4fb27), UINT64_C2(0xb0de6538, 0x8cc8ada8),
-        UINT64_C2(0x83c7088e, 0x1aab65db), UINT64_C2(0xc45d1df9, 0x42711d9a),
-        UINT64_C2(0x924d692c, 0xa61be758), UINT64_C2(0xda01ee64, 0x1a708dea),
-        UINT64_C2(0xa26da399, 0x9aef774a), UINT64_C2(0xf209787b, 0xb47d6b85),
-        UINT64_C2(0xb454e4a1, 0x79dd1877), UINT64_C2(0x865b8692, 0x5b9bc5c2),
-        UINT64_C2(0xc83553c5, 0xc8965d3d), UINT64_C2(0x952ab45c, 0xfa97a0b3),
-        UINT64_C2(0xde469fbd, 0x99a05fe3), UINT64_C2(0xa59bc234, 0xdb398c25),
-        UINT64_C2(0xf6c69a72, 0xa3989f5c), UINT64_C2(0xb7dcbf53, 0x54e9bece),
-        UINT64_C2(0x88fcf317, 0xf22241e2), UINT64_C2(0xcc20ce9b, 0xd35c78a5),
-        UINT64_C2(0x98165af3, 0x7b2153df), UINT64_C2(0xe2a0b5dc, 0x971f303a),
-        UINT64_C2(0xa8d9d153, 0x5ce3b396), UINT64_C2(0xfb9b7cd9, 0xa4a7443c),
-        UINT64_C2(0xbb764c4c, 0xa7a44410), UINT64_C2(0x8bab8eef, 0xb6409c1a),
-        UINT64_C2(0xd01fef10, 0xa657842c), UINT64_C2(0x9b10a4e5, 0xe9913129),
-        UINT64_C2(0xe7109bfb, 0xa19c0c9d), UINT64_C2(0xac2820d9, 0x623bf429),
-        UINT64_C2(0x80444b5e, 0x7aa7cf85), UINT64_C2(0xbf21e440, 0x03acdd2d),
-        UINT64_C2(0x8e679c2f, 0x5e44ff8f), UINT64_C2(0xd433179d, 0x9c8cb841),
-        UINT64_C2(0x9e19db92, 0xb4e31ba9), UINT64_C2(0xeb96bf6e, 0xbadf77d9),
-        UINT64_C2(0xaf87023b, 0x9bf0ee6b)};
-    static const int16_t kCachedPowers_E[] = {
-        -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954, -927, -901,
-        -874,  -847,  -821,  -794,  -768,  -741,  -715,  -688,  -661,  -635, -608, -582, -555,
-        -529,  -502,  -475,  -449,  -422,  -396,  -369,  -343,  -316,  -289, -263, -236, -210,
-        -183,  -157,  -130,  -103,  -77,   -50,   -24,   3,     30,    56,   83,   109,  136,
-        162,   189,   216,   242,   269,   295,   322,   348,   375,   402,  428,  455,  481,
-        508,   534,   561,   588,   614,   641,   667,   694,   720,   747,  774,  800,  827,
-        853,   880,   907,   933,   960,   986,   1013,  1039,  1066};
-
-    // int k = static_cast<int>(ceil((-61 - e) * 0.30102999566398114)) + 374;
-    double dk =
-        (-61 - e) * 0.30102999566398114 + 347; // dk must be positive, so can do ceiling in positive
-    int k = static_cast<int>(dk);
-    if (k != dk)
-        k++;
-
-    unsigned index = static_cast<unsigned>((k >> 3) + 1);
-    *K = -(-348 + static_cast<int>(index << 3)); // decimal exponent no need lookup table
-
-    assert(index < sizeof(kCachedPowers_F) / sizeof(kCachedPowers_F[0]));
-    return DiyFp(kCachedPowers_F[index], kCachedPowers_E[index]);
-}
-
-inline void
-GrisuRound(char *buffer, int len, uint64_t delta, uint64_t rest, uint64_t ten_kappa, uint64_t wp_w)
-{
-    while (rest < wp_w && delta - rest >= ten_kappa && (rest + ten_kappa < wp_w || /// closer
-                                                        wp_w - rest > rest + ten_kappa - wp_w))
-    {
-        buffer[len - 1]--;
-        rest += ten_kappa;
-    }
-}
-
-inline unsigned CountDecimalDigit32(uint32_t n)
-{
-    // Simple pure C++ implementation was faster than __builtin_clz version in this situation.
-    if (n < 10)
-        return 1;
-    if (n < 100)
-        return 2;
-    if (n < 1000)
-        return 3;
-    if (n < 10000)
-        return 4;
-    if (n < 100000)
-        return 5;
-    if (n < 1000000)
-        return 6;
-    if (n < 10000000)
-        return 7;
-    if (n < 100000000)
-        return 8;
-    if (n < 1000000000)
-        return 9;
-    return 10;
-}
-
-inline void
-DigitGen(const DiyFp &W, const DiyFp &Mp, uint64_t delta, char *buffer, int *len, int *K)
-{
-    static const uint32_t kPow10[] = {
-        1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};
-    const DiyFp one(uint64_t(1) << -Mp.e, Mp.e);
-    const DiyFp wp_w = Mp - W;
-    uint32_t p1 = static_cast<uint32_t>(Mp.f >> -one.e);
-    uint64_t p2 = Mp.f & (one.f - 1);
-    int kappa = static_cast<int>(CountDecimalDigit32(p1));
-    *len = 0;
-
-    while (kappa > 0)
-    {
-        uint32_t d;
-        switch (kappa)
-        {
-        case 10:
-            d = p1 / 1000000000;
-            p1 %= 1000000000;
-            break;
-        case 9:
-            d = p1 / 100000000;
-            p1 %= 100000000;
-            break;
-        case 8:
-            d = p1 / 10000000;
-            p1 %= 10000000;
-            break;
-        case 7:
-            d = p1 / 1000000;
-            p1 %= 1000000;
-            break;
-        case 6:
-            d = p1 / 100000;
-            p1 %= 100000;
-            break;
-        case 5:
-            d = p1 / 10000;
-            p1 %= 10000;
-            break;
-        case 4:
-            d = p1 / 1000;
-            p1 %= 1000;
-            break;
-        case 3:
-            d = p1 / 100;
-            p1 %= 100;
-            break;
-        case 2:
-            d = p1 / 10;
-            p1 %= 10;
-            break;
-        case 1:
-            d = p1;
-            p1 = 0;
-            break;
-        default:
-#if defined(_MSC_VER)
-            __assume(0);
-#elif __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
-            __builtin_unreachable();
-#else
-            d = 0;
-#endif
-        }
-        if (d || *len)
-            buffer[(*len)++] = '0' + static_cast<char>(d);
-        kappa--;
-        uint64_t tmp = (static_cast<uint64_t>(p1) << -one.e) + p2;
-        if (tmp <= delta)
-        {
-            *K += kappa;
-            GrisuRound(
-                buffer, *len, delta, tmp, static_cast<uint64_t>(kPow10[kappa]) << -one.e, wp_w.f);
-            return;
-        }
-    }
-
-    // kappa = 0
-    for (;;)
-    {
-        p2 *= 10;
-        delta *= 10;
-        char d = static_cast<char>(p2 >> -one.e);
-        if (d || *len)
-            buffer[(*len)++] = '0' + d;
-        p2 &= one.f - 1;
-        kappa--;
-        if (p2 < delta)
-        {
-            *K += kappa;
-            GrisuRound(buffer, *len, delta, p2, one.f, wp_w.f * kPow10[-kappa]);
-            return;
-        }
-    }
-}
-
-inline void Grisu2(double value, char *buffer, int *length, int *K)
-{
-    const DiyFp v(value);
-    DiyFp w_m, w_p;
-    v.NormalizedBoundaries(&w_m, &w_p);
-
-    const DiyFp c_mk = GetCachedPower(w_p.e, K);
-    const DiyFp W = v.Normalize() * c_mk;
-    DiyFp Wp = w_p * c_mk;
-    DiyFp Wm = w_m * c_mk;
-    Wm.f++;
-    Wp.f--;
-    DigitGen(W, Wp, Wp.f - Wm.f, buffer, length, K);
-}
-
-inline const char *GetDigitsLut()
-{
-    static const char cDigitsLut[200] = {
-        '0', '0', '0', '1', '0', '2', '0', '3', '0', '4', '0', '5', '0', '6', '0', '7', '0',
-        '8', '0', '9', '1', '0', '1', '1', '1', '2', '1', '3', '1', '4', '1', '5', '1', '6',
-        '1', '7', '1', '8', '1', '9', '2', '0', '2', '1', '2', '2', '2', '3', '2', '4', '2',
-        '5', '2', '6', '2', '7', '2', '8', '2', '9', '3', '0', '3', '1', '3', '2', '3', '3',
-        '3', '4', '3', '5', '3', '6', '3', '7', '3', '8', '3', '9', '4', '0', '4', '1', '4',
-        '2', '4', '3', '4', '4', '4', '5', '4', '6', '4', '7', '4', '8', '4', '9', '5', '0',
-        '5', '1', '5', '2', '5', '3', '5', '4', '5', '5', '5', '6', '5', '7', '5', '8', '5',
-        '9', '6', '0', '6', '1', '6', '2', '6', '3', '6', '4', '6', '5', '6', '6', '6', '7',
-        '6', '8', '6', '9', '7', '0', '7', '1', '7', '2', '7', '3', '7', '4', '7', '5', '7',
-        '6', '7', '7', '7', '8', '7', '9', '8', '0', '8', '1', '8', '2', '8', '3', '8', '4',
-        '8', '5', '8', '6', '8', '7', '8', '8', '8', '9', '9', '0', '9', '1', '9', '2', '9',
-        '3', '9', '4', '9', '5', '9', '6', '9', '7', '9', '8', '9', '9'};
-    return cDigitsLut;
-}
-
-inline void WriteExponent(int K, char *buffer)
-{
-    if (K < 0)
-    {
-        *buffer++ = '-';
-        K = -K;
-    }
-
-    if (K >= 100)
-    {
-        *buffer++ = '0' + static_cast<char>(K / 100);
-        K %= 100;
-        const char *d = GetDigitsLut() + K * 2;
-        *buffer++ = d[0];
-        *buffer++ = d[1];
-    }
-    else if (K >= 10)
-    {
-        const char *d = GetDigitsLut() + K * 2;
-        *buffer++ = d[0];
-        *buffer++ = d[1];
-    }
-    else
-        *buffer++ = '0' + static_cast<char>(K);
-
-    *buffer = '\0';
-}
-
-inline void Prettify(char *buffer, int length, int k)
-{
-    const int kk = length + k; // 10^(kk-1) <= v < 10^kk
-
-    if (length <= kk && kk <= 21)
-    {
-        // 1234e7 -> 12340000000
-        for (int i = length; i < kk; i++)
-            buffer[i] = '0';
-        buffer[kk] = '.';
-        buffer[kk + 1] = '0';
-        buffer[kk + 2] = '\0';
-    }
-    else if (0 < kk && kk <= 21)
-    {
-        // 1234e-2 -> 12.34
-        memmove(&buffer[kk + 1], &buffer[kk], length - kk);
-        buffer[kk] = '.';
-        buffer[length + 1] = '\0';
-    }
-    else if (-6 < kk && kk <= 0)
-    {
-        // 1234e-6 -> 0.001234
-        const int offset = 2 - kk;
-        memmove(&buffer[offset], &buffer[0], length);
-        buffer[0] = '0';
-        buffer[1] = '.';
-        for (int i = 2; i < offset; i++)
-            buffer[i] = '0';
-        buffer[length + offset] = '\0';
-    }
-    else if (length == 1)
-    {
-        // 1e30
-        buffer[1] = 'e';
-        WriteExponent(kk - 1, &buffer[2]);
-    }
-    else
-    {
-        // 1234e30 -> 1.234e33
-        memmove(&buffer[2], &buffer[1], length - 1);
-        buffer[1] = '.';
-        buffer[length + 1] = 'e';
-        WriteExponent(kk - 1, &buffer[0 + length + 2]);
-    }
-}
-
-inline void dtoa_milo(double value, char *buffer)
-{
-    // Not handling NaN and inf
-    assert(!isnan(value));
-    assert(!isinf(value));
-
-    if (value == 0)
-    {
-        buffer[0] = '0';
-        buffer[1] = '.';
-        buffer[2] = '0';
-        buffer[3] = '\0';
-    }
-    else
-    {
-        if (value < 0)
-        {
-            *buffer++ = '-';
-            value = -value;
-        }
-        int length, K;
-        Grisu2(value, buffer, &length, &K);
-        Prettify(buffer, length, K);
-    }
-}
-} // namespace ieee754
-} // namespace util
-} // namespace osrm
-
-#endif // IEEE754_HPP

include/util/json_renderer.hpp

@@ -5,7 +5,6 @@
 #define JSON_RENDERER_HPP
 
 #include "util/cast.hpp"
-#include "util/ieee754.hpp"
 #include "util/string_util.hpp"
 
 #include "osrm/json_container.hpp"
@@ -22,11 +21,6 @@ namespace util
 namespace json
 {
 
-namespace
-{
-constexpr int MAX_FLOAT_STRING_LENGTH = 256;
-}
-
 struct Renderer
 {
     explicit Renderer(std::ostream &_out) : out(_out) {}
@@ -40,31 +34,8 @@ struct Renderer
 
     void operator()(const Number &number) const
     {
-        char buffer[MAX_FLOAT_STRING_LENGTH] = {'\0'};
-        ieee754::dtoa_milo(number.value, buffer);
-
-        // Trucate to 10 decimal places
-        int pos = 0;
-        int decimalpos = 0;
-        while (decimalpos == 0 && pos < MAX_FLOAT_STRING_LENGTH && buffer[pos] != 0)
-        {
-            if (buffer[pos] == '.')
-            {
-                decimalpos = pos;
-                break;
-            }
-            ++pos;
-        }
-        while (pos < MAX_FLOAT_STRING_LENGTH && buffer[pos] != 0)
-        {
-            if (pos - decimalpos == 10)
-            {
-                buffer[pos] = '\0';
-                break;
-            }
-            ++pos;
-        }
-        out << buffer;
+        out.precision(10);
+        out << number.value;
     }
 
     void operator()(const Object &object) const

include/util/node_based_graph.hpp

@@ -9,7 +9,6 @@
 
 #include <tbb/parallel_sort.h>
 
-#include <iostream>
 #include <memory>
 #include <utility>
 
@@ -21,27 +20,24 @@ namespace util
 struct NodeBasedEdgeData
 {
     NodeBasedEdgeData()
-        : weight(INVALID_EDGE_WEIGHT), duration(INVALID_EDGE_WEIGHT),
-          distance(INVALID_EDGE_DISTANCE), geometry_id({0, false}), reversed(false),
-          annotation_data(-1)
+        : weight(INVALID_EDGE_WEIGHT), duration(INVALID_EDGE_WEIGHT), geometry_id({0, false}),
+          reversed(false), annotation_data(-1)
     {
     }
 
     NodeBasedEdgeData(EdgeWeight weight,
                       EdgeWeight duration,
-                      EdgeDistance distance,
                       GeometryID geometry_id,
                       bool reversed,
                       extractor::NodeBasedEdgeClassification flags,
                       AnnotationID annotation_data)
-        : weight(weight), duration(duration), distance(distance), geometry_id(geometry_id),
-          reversed(reversed), flags(flags), annotation_data(annotation_data)
+        : weight(weight), duration(duration), geometry_id(geometry_id), reversed(reversed),
+          flags(flags), annotation_data(annotation_data)
     {
     }
 
     EdgeWeight weight;
     EdgeWeight duration;
-    EdgeDistance distance;
     GeometryID geometry_id;
     bool reversed : 1;
     extractor::NodeBasedEdgeClassification flags;
@@ -84,24 +80,18 @@ NodeBasedDynamicGraphFromEdges(NodeID number_of_nodes,
            const extractor::NodeBasedEdge &input_edge) {
             output_edge.data.weight = input_edge.weight;
             output_edge.data.duration = input_edge.duration;
-            output_edge.data.distance = input_edge.distance;
             output_edge.data.flags = input_edge.flags;
             output_edge.data.annotation_data = input_edge.annotation_data;
 
-            BOOST_ASSERT(output_edge.data.weight >= 0);
-            BOOST_ASSERT(output_edge.data.duration >= 0);
-            if (output_edge.data.distance <= 0)
-            {
-                std::cout << "output_edge.data.distance " << output_edge.data.distance << std::endl;
-            }
-            BOOST_ASSERT(output_edge.data.distance >= 0);
+            BOOST_ASSERT(output_edge.data.weight > 0);
+            BOOST_ASSERT(output_edge.data.duration > 0);
         });
 
     tbb::parallel_sort(edges_list.begin(), edges_list.end());
 
     return NodeBasedDynamicGraph(number_of_nodes, edges_list);
 }
-} // namespace util
-} // namespace osrm
+}
+}
 
 #endif // NODE_BASED_GRAPH_HPP

include/util/typedefs.hpp

@@ -48,7 +48,7 @@ struct osm_way_id
 struct duplicated_node
 {
 };
-} // namespace tag
+}
 using OSMNodeID = osrm::Alias<std::uint64_t, tag::osm_node_id>;
 static_assert(std::is_pod<OSMNodeID>(), "OSMNodeID is not a valid alias");
 using OSMWayID = osrm::Alias<std::uint64_t, tag::osm_way_id>;
@@ -113,7 +113,6 @@ static const SegmentWeight MAX_SEGMENT_WEIGHT = INVALID_SEGMENT_WEIGHT - 1;
 static const SegmentDuration MAX_SEGMENT_DURATION = INVALID_SEGMENT_DURATION - 1;
 static const EdgeWeight INVALID_EDGE_WEIGHT = std::numeric_limits<EdgeWeight>::max();
 static const EdgeDuration MAXIMAL_EDGE_DURATION = std::numeric_limits<EdgeDuration>::max();
-static const EdgeDistance MAXIMAL_EDGE_DISTANCE = std::numeric_limits<EdgeDistance>::max();
 static const TurnPenalty INVALID_TURN_PENALTY = std::numeric_limits<TurnPenalty>::max();
 static const EdgeDistance INVALID_EDGE_DISTANCE = std::numeric_limits<EdgeDistance>::max();
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "osrm",
-  "version": "5.20.0-alpha.2",
+  "version": "5.18.0-moarshm.2",
   "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": {
@@ -18,7 +18,7 @@
   },
   "scripts": {
     "lint": "node ./node_modules/eslint/bin/eslint.js -c ./.eslintrc features/step_definitions/ features/support/",
-    "test": "npm run lint && node ./node_modules/cucumber/bin/cucumber.js features/ -p verify",
+    "test": "npm run lint && node ./node_modules/cucumber/bin/cucumber.js features/ -p verify && node ./node_modules/cucumber/bin/cucumber.js features/ -p mld",
     "clean": "rm -rf test/cache",
     "docs": "./scripts/build_api_docs.sh",
     "install": "node-pre-gyp install --fallback-to-build=false || ./scripts/node_install.sh",

profiles/car.lua

@@ -120,6 +120,9 @@ function setup()
 
     -- classes to support for exclude flags
     excludable = Sequence {
+        Set {'toll'},
+        Set {'motorway'},
+        Set {'ferry'}
     },
 
     avoid = Set {

src/contractor/contractor.cpp

@@ -102,7 +102,6 @@ int Contractor::Run()
     QueryGraph query_graph;
     std::vector<std::vector<bool>> edge_filters;
     std::vector<std::vector<bool>> cores;
-
     std::tie(query_graph, edge_filters) = contractExcludableGraph(
         toContractorGraph(number_of_edge_based_nodes, std::move(edge_based_edge_list)),
         std::move(node_weights),

src/contractor/graph_contractor.cpp

@@ -215,7 +215,6 @@ void ContractNode(ContractorThreadData *data,
                                                     target,
                                                     path_weight,
                                                     in_data.duration + out_data.duration,
-                                                    in_data.distance + out_data.distance,
                                                     out_data.originalEdges + in_data.originalEdges,
                                                     node,
                                                     SHORTCUT_ARC,
@@ -226,7 +225,6 @@ void ContractNode(ContractorThreadData *data,
                                                     source,
                                                     path_weight,
                                                     in_data.duration + out_data.duration,
-                                                    in_data.distance + out_data.distance,
                                                     out_data.originalEdges + in_data.originalEdges,
                                                     node,
                                                     SHORTCUT_ARC,
@@ -282,7 +280,6 @@ void ContractNode(ContractorThreadData *data,
                                                 target,
                                                 path_weight,
                                                 in_data.duration + out_data.duration,
-                                                in_data.distance + out_data.distance,
                                                 out_data.originalEdges + in_data.originalEdges,
                                                 node,
                                                 SHORTCUT_ARC,
@@ -293,7 +290,6 @@ void ContractNode(ContractorThreadData *data,
                                                 source,
                                                 path_weight,
                                                 in_data.duration + out_data.duration,
-                                                in_data.distance + out_data.distance,
                                                 out_data.originalEdges + in_data.originalEdges,
                                                 node,
                                                 SHORTCUT_ARC,
@@ -560,7 +556,7 @@ bool IsNodeIndependent(const util::XORFastHash<> &hash,
     }
     return true;
 }
-} // namespace
+}
 
 std::vector<bool> contractGraph(ContractorGraph &graph,
                                 std::vector<bool> node_is_uncontracted_,

src/engine/routing_algorithms/alternative_path_ch.cpp

@@ -90,7 +90,7 @@ void alternativeRoutingStep(const DataFacade<Algorithm> &facade,
             else
             {
                 // check whether there is a loop present at the node
-                const auto loop_weight = std::get<0>(getLoopWeight<false>(facade, node));
+                const auto loop_weight = getLoopWeight<false>(facade, node);
                 const EdgeWeight new_weight_with_loop = new_weight + loop_weight;
                 if (loop_weight != INVALID_EDGE_WEIGHT &&
                     new_weight_with_loop <= *upper_bound_to_shortest_path_weight)
@@ -558,7 +558,7 @@ bool viaNodeCandidatePassesTTest(SearchEngineData<Algorithm> &engine_working_dat
     }
     return (upper_bound <= t_test_path_weight);
 }
-} // namespace
+} // anon. namespace
 
 InternalManyRoutesResult alternativePathSearch(SearchEngineData<Algorithm> &engine_working_data,
                                                const DataFacade<Algorithm> &facade,
@@ -853,4 +853,4 @@ InternalManyRoutesResult alternativePathSearch(SearchEngineData<Algorithm> &engi
 
 } // namespace routing_algorithms
 } // namespace engine
-} // namespace osrm
+} // namespace osrm}

src/engine/routing_algorithms/many_to_many_ch.cpp

@@ -21,21 +21,18 @@ namespace ch
 inline bool addLoopWeight(const DataFacade<ch::Algorithm> &facade,
                           const NodeID node,
                           EdgeWeight &weight,
-                          EdgeDuration &duration,
-                          EdgeDistance &distance)
+                          EdgeDuration &duration)
 { // Special case for CH when contractor creates a loop edge node->node
     BOOST_ASSERT(weight < 0);
 
     const auto loop_weight = ch::getLoopWeight<false>(facade, node);
-    if (std::get<0>(loop_weight) != INVALID_EDGE_WEIGHT)
+    if (loop_weight != INVALID_EDGE_WEIGHT)
     {
-        const auto new_weight_with_loop = weight + std::get<0>(loop_weight);
+        const auto new_weight_with_loop = weight + loop_weight;
         if (new_weight_with_loop >= 0)
         {
             weight = new_weight_with_loop;
-            auto result = ch::getLoopWeight<true>(facade, node);
-            duration += std::get<0>(result);
-            distance += std::get<1>(result);
+            duration += ch::getLoopWeight<true>(facade, node);
             return true;
         }
     }
@@ -49,7 +46,6 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                         const NodeID node,
                         const EdgeWeight weight,
                         const EdgeDuration duration,
-                        const EdgeDistance distance,
                         typename SearchEngineData<Algorithm>::ManyToManyQueryHeap &query_heap,
                         const PhantomNode &)
 {
@@ -67,23 +63,21 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
             const auto edge_weight = data.weight;
 
             const auto edge_duration = data.duration;
-            const auto edge_distance = data.distance;
 
             BOOST_ASSERT_MSG(edge_weight > 0, "edge_weight invalid");
             const auto to_weight = weight + edge_weight;
             const auto to_duration = duration + edge_duration;
-            const auto to_distance = distance + edge_distance;
 
             // New Node discovered -> Add to Heap + Node Info Storage
             if (!query_heap.WasInserted(to))
             {
-                query_heap.Insert(to, to_weight, {node, to_duration, to_distance});
+                query_heap.Insert(to, to_weight, {node, to_duration});
             }
             // Found a shorter Path -> Update weight and set new parent
             else if (std::tie(to_weight, to_duration) <
                      std::tie(query_heap.GetKey(to), query_heap.GetData(to).duration))
             {
-                query_heap.GetData(to) = {node, to_duration, to_distance};
+                query_heap.GetData(to) = {node, to_duration};
                 query_heap.DecreaseKey(to, to_weight);
             }
         }
@@ -97,14 +91,12 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
                         const std::vector<NodeBucket> &search_space_with_buckets,
                         std::vector<EdgeWeight> &weights_table,
                         std::vector<EdgeDuration> &durations_table,
-                        std::vector<EdgeDistance> &distances_table,
                         std::vector<NodeID> &middle_nodes_table,
                         const PhantomNode &phantom_node)
 {
     const auto node = query_heap.DeleteMin();
     const auto source_weight = query_heap.GetKey(node);
     const auto source_duration = query_heap.GetData(node).duration;
-    const auto source_distance = query_heap.GetData(node).distance;
 
     // Check if each encountered node has an entry
     const auto &bucket_list = std::equal_range(search_space_with_buckets.begin(),
@@ -117,24 +109,20 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
         const auto column_index = current_bucket.column_index;
         const auto target_weight = current_bucket.weight;
         const auto target_duration = current_bucket.duration;
-        const auto target_distance = current_bucket.distance;
 
         auto &current_weight = weights_table[row_index * number_of_targets + column_index];
         auto &current_duration = durations_table[row_index * number_of_targets + column_index];
-        auto &current_distance = distances_table[row_index * number_of_targets + column_index];
 
         // Check if new weight is better
         auto new_weight = source_weight + target_weight;
         auto new_duration = source_duration + target_duration;
-        auto new_distance = source_distance + target_distance;
 
         if (new_weight < 0)
         {
-            if (addLoopWeight(facade, node, new_weight, new_duration, new_distance))
+            if (addLoopWeight(facade, node, new_weight, new_duration))
             {
                 current_weight = std::min(current_weight, new_weight);
                 current_duration = std::min(current_duration, new_duration);
-                current_distance = std::min(current_distance, new_distance);
                 middle_nodes_table[row_index * number_of_targets + column_index] = node;
             }
         }
@@ -142,13 +130,12 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
         {
             current_weight = new_weight;
             current_duration = new_duration;
-            current_distance = new_distance;
             middle_nodes_table[row_index * number_of_targets + column_index] = node;
         }
     }
 
     relaxOutgoingEdges<FORWARD_DIRECTION>(
-        facade, node, source_weight, source_duration, source_distance, query_heap, phantom_node);
+        facade, node, source_weight, source_duration, query_heap, phantom_node);
 }
 
 void backwardRoutingStep(const DataFacade<Algorithm> &facade,
@@ -160,15 +147,14 @@ void backwardRoutingStep(const DataFacade<Algorithm> &facade,
     const auto node = query_heap.DeleteMin();
     const auto target_weight = query_heap.GetKey(node);
     const auto target_duration = query_heap.GetData(node).duration;
-    const auto target_distance = query_heap.GetData(node).distance;
     const auto parent = query_heap.GetData(node).parent;
 
     // Store settled nodes in search space bucket
     search_space_with_buckets.emplace_back(
-        node, parent, column_index, target_weight, target_duration, target_distance);
+        node, parent, column_index, target_weight, target_duration);
 
     relaxOutgoingEdges<REVERSE_DIRECTION>(
-        facade, node, target_weight, target_duration, target_distance, query_heap, phantom_node);
+        facade, node, target_weight, target_duration, query_heap, phantom_node);
 }
 
 } // namespace ch
@@ -249,79 +235,17 @@ void calculateDistances(typename SearchEngineData<ch::Algorithm>::ManyToManyQuer
                                        needsLoopBackwards(source_phantom, target_phantom)))
         {
             auto weight = ch::getLoopWeight<false>(facade, packed_leg.front());
-            if (std::get<0>(weight) != INVALID_EDGE_WEIGHT)
+            if (weight != INVALID_EDGE_WEIGHT)
                 packed_leg.push_back(packed_leg.front());
         }
         if (!packed_leg.empty())
         {
-            auto annotation =
+            EdgeDistance annotation =
                 ch::calculateEBGNodeAnnotations(facade, packed_leg.begin(), packed_leg.end());
+            annotation = adjustPathDistanceToPhantomNodes(
+                packed_leg, source_phantom, target_phantom, annotation);
 
             distances_table[row_index * number_of_targets + column_index] = annotation;
-
-            // check the direction of travel to figure out how to calculate the offset to/from
-            // the source/target
-            if (source_phantom.forward_segment_id.id == packed_leg.front())
-            {
-                //       ............       <-- calculateEGBAnnotation returns distance from 0 to 3
-                //       -->s               <-- subtract offset to start at source
-                //          .........       <-- want this distance as result
-                // entry 0---1---2---3---   <-- 3 is exit node
-                EdgeDistance offset = source_phantom.GetForwardDistance();
-                distances_table[row_index * number_of_targets + column_index] -= offset;
-            }
-            else if (source_phantom.reverse_segment_id.id == packed_leg.front())
-            {
-                //       ............    <-- calculateEGBAnnotation returns distance from 0 to 3
-                //          s<-------    <-- subtract offset to start at source
-                //       ...             <-- want this distance
-                // entry 0---1---2---3   <-- 3 is exit node
-                EdgeDistance offset = source_phantom.GetReverseDistance();
-                distances_table[row_index * number_of_targets + column_index] -= offset;
-            }
-            if (target_phantom.forward_segment_id.id == packed_leg.back())
-            {
-                //       ............       <-- calculateEGBAnnotation returns distance from 0 to 3
-                //                   ++>t   <-- add offset to get to target
-                //       ................   <-- want this distance as result
-                // entry 0---1---2---3---   <-- 3 is exit node
-                EdgeDistance offset = target_phantom.GetForwardDistance();
-                distances_table[row_index * number_of_targets + column_index] += offset;
-            }
-            else if (target_phantom.reverse_segment_id.id == packed_leg.back())
-            {
-                //       ............       <-- calculateEGBAnnotation returns distance from 0 to 3
-                //                   <++t   <-- add offset to get from target
-                //       ................   <-- want this distance as result
-                // entry 0---1---2---3---   <-- 3 is exit node
-                EdgeDistance offset = target_phantom.GetReverseDistance();
-                distances_table[row_index * number_of_targets + column_index] += offset;
-            }
-        }
-        else
-        {
-            // there is no shortcut to unpack. source and target are on the same EBG Node.
-            // if the offset of the target is greater than the offset of the source, subtract it
-            if (target_phantom.GetForwardDistance() > source_phantom.GetForwardDistance())
-            {
-                //       --------->t        <-- offsets
-                //       ->s                <-- subtract source offset from target offset
-                //         .........        <-- want this distance as result
-                // entry 0---1---2---3---   <-- 3 is exit node
-                EdgeDistance offset =
-                    target_phantom.GetForwardDistance() - source_phantom.GetForwardDistance();
-                distances_table[row_index * number_of_targets + column_index] = offset;
-            }
-            else
-            {
-                //               s<---      <-- offsets
-                //         t<---------      <-- subtract source offset from target offset
-                //         ......           <-- want this distance as result
-                // entry 0---1---2---3---   <-- 3 is exit node
-                EdgeDistance offset =
-                    target_phantom.GetReverseDistance() - source_phantom.GetReverseDistance();
-                distances_table[row_index * number_of_targets + column_index] = offset;
-            }
         }
         packed_leg.clear();
     }
@@ -345,7 +269,7 @@ manyToManySearch(SearchEngineData<ch::Algorithm> &engine_working_data,
 
     std::vector<EdgeWeight> weights_table(number_of_entries, INVALID_EDGE_WEIGHT);
     std::vector<EdgeDuration> durations_table(number_of_entries, MAXIMAL_EDGE_DURATION);
-    std::vector<EdgeDistance> distances_table(number_of_entries, MAXIMAL_EDGE_DISTANCE);
+    std::vector<EdgeDistance> distances_table;
     std::vector<NodeID> middle_nodes_table(number_of_entries, SPECIAL_NODEID);
 
     std::vector<NodeBucket> search_space_with_buckets;
@@ -394,7 +318,6 @@ manyToManySearch(SearchEngineData<ch::Algorithm> &engine_working_data,
                                search_space_with_buckets,
                                weights_table,
                                durations_table,
-                               distances_table,
                                middle_nodes_table,
                                source_phantom);
         }
@@ -402,21 +325,17 @@ manyToManySearch(SearchEngineData<ch::Algorithm> &engine_working_data,
         if (calculate_distance)
         {
             distances_table.resize(number_of_entries, INVALID_EDGE_DISTANCE);
-            // TODO: this is a hack to work around stuff
-            if (number_of_entries == 0)
-            {
-                calculateDistances(query_heap,
-                                   facade,
-                                   phantom_nodes,
-                                   target_indices,
-                                   row_index,
-                                   source_index,
-                                   source_phantom,
-                                   number_of_targets,
-                                   search_space_with_buckets,
-                                   distances_table,
-                                   middle_nodes_table);
-            }
+            calculateDistances(query_heap,
+                               facade,
+                               phantom_nodes,
+                               target_indices,
+                               row_index,
+                               source_index,
+                               source_phantom,
+                               number_of_targets,
+                               search_space_with_buckets,
+                               distances_table,
+                               middle_nodes_table);
         }
     }
 

src/engine/routing_algorithms/many_to_many_mld.cpp

@@ -41,7 +41,6 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
                         const NodeID node,
                         const EdgeWeight weight,
                         const EdgeDuration duration,
-                        const EdgeDistance /* distance TODO use this */,
                         typename SearchEngineData<mld::Algorithm>::ManyToManyQueryHeap &query_heap,
                         Args... args)
 {
@@ -78,14 +77,14 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
                     const auto to_duration = duration + shortcut_durations.front();
                     if (!query_heap.WasInserted(to))
                     {
-                        query_heap.Insert(to, to_weight, {node, true, to_duration, 0});
+                        query_heap.Insert(to, to_weight, {node, true, to_duration});
                     }
                     else if (std::tie(to_weight, to_duration, node) <
                              std::tie(query_heap.GetKey(to),
                                       query_heap.GetData(to).duration,
                                       query_heap.GetData(to).parent))
                     {
-                        query_heap.GetData(to) = {node, true, to_duration, 0};
+                        query_heap.GetData(to) = {node, true, to_duration};
                         query_heap.DecreaseKey(to, to_weight);
                     }
                 }
@@ -110,14 +109,14 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
                     const auto to_duration = duration + shortcut_durations.front();
                     if (!query_heap.WasInserted(to))
                     {
-                        query_heap.Insert(to, to_weight, {node, true, to_duration, 0});
+                        query_heap.Insert(to, to_weight, {node, true, to_duration});
                     }
                     else if (std::tie(to_weight, to_duration, node) <
                              std::tie(query_heap.GetKey(to),
                                       query_heap.GetData(to).duration,
                                       query_heap.GetData(to).parent))
                     {
-                        query_heap.GetData(to) = {node, true, to_duration, 0};
+                        query_heap.GetData(to) = {node, true, to_duration};
                         query_heap.DecreaseKey(to, to_weight);
                     }
                 }
@@ -154,7 +153,7 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
             // New Node discovered -> Add to Heap + Node Info Storage
             if (!query_heap.WasInserted(to))
             {
-                query_heap.Insert(to, to_weight, {node, false, to_duration, 0});
+                query_heap.Insert(to, to_weight, {node, false, to_duration});
             }
             // Found a shorter Path -> Update weight and set new parent
             else if (std::tie(to_weight, to_duration, node) <
@@ -162,7 +161,7 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
                               query_heap.GetData(to).duration,
                               query_heap.GetData(to).parent))
             {
-                query_heap.GetData(to) = {node, false, to_duration, 0};
+                query_heap.GetData(to) = {node, false, to_duration};
                 query_heap.DecreaseKey(to, to_weight);
             }
         }
@@ -179,15 +178,15 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
                 const std::vector<PhantomNode> &phantom_nodes,
                 std::size_t phantom_index,
                 const std::vector<std::size_t> &phantom_indices,
-                const bool /* calculate_distance */)
+                const bool calculate_distance)
 {
     std::vector<EdgeWeight> weights(phantom_indices.size(), INVALID_EDGE_WEIGHT);
     std::vector<EdgeDuration> durations(phantom_indices.size(), MAXIMAL_EDGE_DURATION);
-    std::vector<EdgeDistance> distances_table(phantom_indices.size(), MAXIMAL_EDGE_DISTANCE);
+    std::vector<EdgeDistance> distances_table;
     std::vector<NodeID> middle_nodes_table(phantom_indices.size(), SPECIAL_NODEID);
 
     // Collect destination (source) nodes into a map
-    std::unordered_multimap<NodeID, std::tuple<std::size_t, EdgeWeight, EdgeDuration, EdgeDistance>>
+    std::unordered_multimap<NodeID, std::tuple<std::size_t, EdgeWeight, EdgeDuration>>
         target_nodes_index;
     target_nodes_index.reserve(phantom_indices.size());
     for (std::size_t index = 0; index < phantom_indices.size(); ++index)
@@ -202,15 +201,13 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
                     {phantom_node.forward_segment_id.id,
                      std::make_tuple(index,
                                      phantom_node.GetForwardWeightPlusOffset(),
-                                     phantom_node.GetForwardDuration(),
-                                     phantom_node.GetForwardDistance())});
+                                     phantom_node.GetForwardDuration())});
             if (phantom_node.IsValidReverseTarget())
                 target_nodes_index.insert(
                     {phantom_node.reverse_segment_id.id,
                      std::make_tuple(index,
                                      phantom_node.GetReverseWeightPlusOffset(),
-                                     phantom_node.GetReverseDuration(),
-                                     phantom_node.GetReverseDistance())});
+                                     phantom_node.GetReverseDuration())});
         }
         else if (DIRECTION == REVERSE_DIRECTION)
         {
@@ -219,15 +216,13 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
                     {phantom_node.forward_segment_id.id,
                      std::make_tuple(index,
                                      -phantom_node.GetForwardWeightPlusOffset(),
-                                     -phantom_node.GetForwardDuration(),
-                                     -phantom_node.GetForwardDistance())});
+                                     -phantom_node.GetForwardDuration())});
             if (phantom_node.IsValidReverseSource())
                 target_nodes_index.insert(
                     {phantom_node.reverse_segment_id.id,
                      std::make_tuple(index,
                                      -phantom_node.GetReverseWeightPlusOffset(),
-                                     -phantom_node.GetReverseDuration(),
-                                     -phantom_node.GetReverseDistance())});
+                                     -phantom_node.GetReverseDuration())});
         }
     }
 
@@ -237,50 +232,44 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
     auto &query_heap = *(engine_working_data.many_to_many_heap);
 
     // Check if node is in the destinations list and update weights/durations
-    auto update_values =
-        [&](NodeID node, EdgeWeight weight, EdgeDuration duration, EdgeDistance distance) {
-            auto candidates = target_nodes_index.equal_range(node);
-            for (auto it = candidates.first; it != candidates.second;)
+    auto update_values = [&](NodeID node, EdgeWeight weight, EdgeDuration duration) {
+        auto candidates = target_nodes_index.equal_range(node);
+        for (auto it = candidates.first; it != candidates.second;)
+        {
+            std::size_t index;
+            EdgeWeight target_weight;
+            EdgeDuration target_duration;
+            std::tie(index, target_weight, target_duration) = it->second;
+
+            const auto path_weight = weight + target_weight;
+            if (path_weight >= 0)
             {
-                std::size_t index;
-                EdgeWeight target_weight;
-                EdgeDuration target_duration;
-                EdgeDuration target_distance;
-                std::tie(index, target_weight, target_duration, target_distance) = it->second;
+                const auto path_duration = duration + target_duration;
 
-                const auto path_weight = weight + target_weight;
-                if (path_weight >= 0)
+                if (std::tie(path_weight, path_duration) <
+                    std::tie(weights[index], durations[index]))
                 {
-                    const auto path_duration = duration + target_duration;
-                    const auto path_distance = distance + target_distance;
-
-                    if (std::tie(path_weight, path_duration) <
-                        std::tie(weights[index], durations[index]))
-                    {
-                        weights[index] = path_weight;
-                        durations[index] = path_duration;
-                        distances_table[index] = path_distance;
-                        middle_nodes_table[index] = node;
-                    }
-
-                    // Remove node from destinations list
-                    it = target_nodes_index.erase(it);
-                }
-                else
-                {
-                    ++it;
+                    weights[index] = path_weight;
+                    durations[index] = path_duration;
+                    middle_nodes_table[index] = node;
                 }
+
+                // Remove node from destinations list
+                it = target_nodes_index.erase(it);
             }
-        };
+            else
+            {
+                ++it;
+            }
+        }
+    };
+
+    auto insert_node = [&](NodeID node, EdgeWeight initial_weight, EdgeDuration initial_duration) {
 
-    auto insert_node = [&](NodeID node,
-                           EdgeWeight initial_weight,
-                           EdgeDuration initial_duration,
-                           EdgeDistance initial_distance) {
         // Update single node paths
-        update_values(node, initial_weight, initial_duration, initial_distance);
+        update_values(node, initial_weight, initial_duration);
 
-        query_heap.Insert(node, initial_weight, {node, initial_duration, initial_distance});
+        query_heap.Insert(node, initial_weight, {node, initial_duration});
 
         // Place adjacent nodes into heap
         for (auto edge : facade.GetAdjacentEdgeRange(node))
@@ -303,9 +292,8 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
                                          facade.GetWeightPenaltyForEdgeID(turn_id);
                 const auto edge_duration = initial_duration + facade.GetNodeDuration(node_id) +
                                            facade.GetDurationPenaltyForEdgeID(turn_id);
-                const auto edge_distance = initial_distance;
 
-                query_heap.Insert(to, edge_weight, {node, edge_duration, edge_distance});
+                query_heap.Insert(to, edge_weight, {node, edge_duration});
             }
         }
     };
@@ -319,16 +307,14 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
             {
                 insert_node(phantom_node.forward_segment_id.id,
                             -phantom_node.GetForwardWeightPlusOffset(),
-                            -phantom_node.GetForwardDuration(),
-                            -phantom_node.GetForwardDistance());
+                            -phantom_node.GetForwardDuration());
             }
 
             if (phantom_node.IsValidReverseSource())
             {
                 insert_node(phantom_node.reverse_segment_id.id,
                             -phantom_node.GetReverseWeightPlusOffset(),
-                            -phantom_node.GetReverseDuration(),
-                            -phantom_node.GetReverseDistance());
+                            -phantom_node.GetReverseDuration());
             }
         }
         else if (DIRECTION == REVERSE_DIRECTION)
@@ -337,16 +323,14 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
             {
                 insert_node(phantom_node.forward_segment_id.id,
                             phantom_node.GetForwardWeightPlusOffset(),
-                            phantom_node.GetForwardDuration(),
-                            phantom_node.GetForwardDistance());
+                            phantom_node.GetForwardDuration());
             }
 
             if (phantom_node.IsValidReverseTarget())
             {
                 insert_node(phantom_node.reverse_segment_id.id,
                             phantom_node.GetReverseWeightPlusOffset(),
-                            phantom_node.GetReverseDuration(),
-                            phantom_node.GetReverseDistance());
+                            phantom_node.GetReverseDuration());
             }
         }
     }
@@ -357,26 +341,22 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
         const auto node = query_heap.DeleteMin();
         const auto weight = query_heap.GetKey(node);
         const auto duration = query_heap.GetData(node).duration;
-        const auto distance = query_heap.GetData(node).distance;
 
         // Update values
-        update_values(node, weight, duration, distance);
+        update_values(node, weight, duration);
 
         // Relax outgoing edges
         relaxOutgoingEdges<DIRECTION>(facade,
                                       node,
                                       weight,
                                       duration,
-                                      distance,
                                       query_heap,
                                       phantom_nodes,
                                       phantom_index,
                                       phantom_indices);
     }
 
-    // TODO: re-enable this if we need to fallback
-    // if (calculate_distance)
-    if (false)
+    if (calculate_distance)
     {
         // Initialize unpacking heaps
         engine_working_data.InitializeOrClearFirstThreadLocalStorage(
@@ -517,7 +497,6 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
     const auto node = query_heap.DeleteMin();
     const auto source_weight = query_heap.GetKey(node);
     const auto source_duration = query_heap.GetData(node).duration;
-    const auto source_distance = query_heap.GetData(node).distance;
 
     // Check if each encountered node has an entry
     const auto &bucket_list = std::equal_range(search_space_with_buckets.begin(),
@@ -554,7 +533,7 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
     }
 
     relaxOutgoingEdges<DIRECTION>(
-        facade, node, source_weight, source_duration, source_distance, query_heap, phantom_node);
+        facade, node, source_weight, source_duration, query_heap, phantom_node);
 }
 
 template <bool DIRECTION>
@@ -567,7 +546,6 @@ void backwardRoutingStep(const DataFacade<Algorithm> &facade,
     const auto node = query_heap.DeleteMin();
     const auto target_weight = query_heap.GetKey(node);
     const auto target_duration = query_heap.GetData(node).duration;
-    const auto target_distance = query_heap.GetData(node).distance;
     const auto parent = query_heap.GetData(node).parent;
     const auto from_clique_arc = query_heap.GetData(node).from_clique_arc;
 
@@ -578,14 +556,8 @@ void backwardRoutingStep(const DataFacade<Algorithm> &facade,
     const auto &partition = facade.GetMultiLevelPartition();
     const auto maximal_level = partition.GetNumberOfLevels() - 1;
 
-    relaxOutgoingEdges<!DIRECTION>(facade,
-                                   node,
-                                   target_weight,
-                                   target_duration,
-                                   target_distance,
-                                   query_heap,
-                                   phantom_node,
-                                   maximal_level);
+    relaxOutgoingEdges<!DIRECTION>(
+        facade, node, target_weight, target_duration, query_heap, phantom_node, maximal_level);
 }
 
 template <bool DIRECTION>

src/engine/routing_algorithms/map_matching.cpp

@@ -227,6 +227,9 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
                 {
                     continue;
                 }
+                forward_heap.Clear();
+                const auto &source_phantom = prev_unbroken_timestamps_list[s].phantom_node;
+                insertSourceInHeap(forward_heap, source_phantom);
 
                 for (const auto s_prime : util::irange<std::size_t>(0UL, current_viterbi.size()))
                 {
@@ -237,14 +240,19 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
                         continue;
                     }
 
-                    double network_distance =
-                        getNetworkDistance(engine_working_data,
-                                           facade,
-                                           forward_heap,
-                                           reverse_heap,
-                                           prev_unbroken_timestamps_list[s].phantom_node,
-                                           current_timestamps_list[s_prime].phantom_node,
-                                           weight_upper_bound);
+                    reverse_heap.Clear();
+                    const auto &target_phantom = current_timestamps_list[s_prime].phantom_node;
+                    insertTargetInHeap(reverse_heap, target_phantom);
+
+                    double network_distance = getNetworkDistance(engine_working_data,
+                                                                 facade,
+                                                                 forward_heap,
+                                                                 reverse_heap,
+                                                                 source_phantom,
+                                                                 target_phantom,
+                                                                 weight_upper_bound);
+
+                    network_distance = std::round(network_distance * 10) / 10;
 
                     // get distance diff between loc1/2 and locs/s_prime
                     const auto d_t = std::abs(network_distance - haversine_distance);

src/engine/routing_algorithms/routing_base.cpp

@@ -33,6 +33,79 @@ bool needsLoopBackwards(const PhantomNodes &phantoms)
     return needsLoopBackwards(phantoms.source_phantom, phantoms.target_phantom);
 }
 
+EdgeDistance adjustPathDistanceToPhantomNodes(const std::vector<NodeID> &path,
+                                              const PhantomNode &source_phantom,
+                                              const PhantomNode &target_phantom,
+                                              const EdgeDistance uncorrected_distance)
+{
+    EdgeDistance distance = uncorrected_distance;
+    if (!path.empty())
+    {
+
+        // check the direction of travel to figure out how to calculate the offset to/from
+        // the source/target
+        if (source_phantom.forward_segment_id.id == path.front())
+        {
+            //       ............       <-- calculateEGBAnnotation returns distance from 0 to 3
+            //       -->s               <-- subtract offset to start at source
+            //          .........       <-- want this distance as result
+            // entry 0---1---2---3---   <-- 3 is exit node
+            distance -= source_phantom.GetForwardDistance();
+        }
+        else if (source_phantom.reverse_segment_id.id == path.front())
+        {
+            //       ............    <-- calculateEGBAnnotation returns distance from 0 to 3
+            //          s<-------    <-- subtract offset to start at source
+            //       ...             <-- want this distance
+            // entry 0---1---2---3   <-- 3 is exit node
+            distance -= source_phantom.GetReverseDistance();
+        }
+        if (target_phantom.forward_segment_id.id == path.back())
+        {
+            //       ............       <-- calculateEGBAnnotation returns distance from 0 to 3
+            //                   ++>t   <-- add offset to get to target
+            //       ................   <-- want this distance as result
+            // entry 0---1---2---3---   <-- 3 is exit node
+            distance += target_phantom.GetForwardDistance();
+        }
+        else if (target_phantom.reverse_segment_id.id == path.back())
+        {
+            //       ............       <-- calculateEGBAnnotation returns distance from 0 to 3
+            //                   <++t   <-- add offset to get from target
+            //       ................   <-- want this distance as result
+            // entry 0---1---2---3---   <-- 3 is exit node
+            distance += target_phantom.GetReverseDistance();
+        }
+    }
+    else
+    {
+        // there is no shortcut to unpack. source and target are on the same EBG Node.
+        // if the offset of the target is greater than the offset of the source, subtract it
+        if (target_phantom.GetForwardDistance() > source_phantom.GetForwardDistance())
+        {
+            //       --------->t        <-- offsets
+            //       ->s                <-- subtract source offset from target offset
+            //         .........        <-- want this distance as result
+            // entry 0---1---2---3---   <-- 3 is exit node
+            distance = target_phantom.GetForwardDistance() - source_phantom.GetForwardDistance();
+        }
+        else
+        {
+            //               s<---      <-- offsets
+            //         t<---------      <-- subtract source offset from target offset
+            //         ......           <-- want this distance as result
+            // entry 0---1---2---3---   <-- 3 is exit node
+            distance = target_phantom.GetReverseDistance() - source_phantom.GetReverseDistance();
+        }
+    }
+
+    BOOST_ASSERT_MSG(distance >= 0 || distance > -1.0f,
+                     "Distance correction generated negative number");
+    // guard against underflow errors caused by rounding
+    distance = std::max(EdgeDistance{0}, distance);
+    return distance;
+}
+
 } // namespace routing_algorithms
 } // namespace engine
 } // namespace osrm

src/engine/routing_algorithms/routing_base_ch.cpp

@@ -100,7 +100,7 @@ void search(SearchEngineData<Algorithm> & /*engine_working_data*/,
             const PhantomNodes & /*phantom_nodes*/,
             const EdgeWeight weight_upper_bound)
 {
-    if (forward_heap.Empty() || reverse_heap.Empty())
+    if (forward_heap.Empty() && reverse_heap.Empty())
     {
         weight = INVALID_EDGE_WEIGHT;
         return;
@@ -110,10 +110,14 @@ void search(SearchEngineData<Algorithm> & /*engine_working_data*/,
     weight = weight_upper_bound;
 
     // get offset to account for offsets on phantom nodes on compressed edges
-    const auto min_edge_offset = std::min(0, forward_heap.MinKey());
-    BOOST_ASSERT(min_edge_offset <= 0);
+    EdgeWeight min_edge_offset = 0;
+    if (forward_heap.Size() > 0)
+    {
+        min_edge_offset = std::min(min_edge_offset, forward_heap.MinKey());
+        BOOST_ASSERT(min_edge_offset <= 0);
+    }
     // we only every insert negative offsets for nodes in the forward heap
-    BOOST_ASSERT(reverse_heap.MinKey() >= 0);
+    BOOST_ASSERT(reverse_heap.Empty() || reverse_heap.MinKey() >= 0);
 
     // run two-Target Dijkstra routing step.
     while (0 < (forward_heap.Size() + reverse_heap.Size()))
@@ -176,11 +180,6 @@ double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
                           const PhantomNode &target_phantom,
                           EdgeWeight weight_upper_bound)
 {
-    forward_heap.Clear();
-    reverse_heap.Clear();
-
-    insertNodesInHeaps(forward_heap, reverse_heap, {source_phantom, target_phantom});
-
     EdgeWeight weight = INVALID_EDGE_WEIGHT;
     std::vector<NodeID> packed_path;
     search(engine_working_data,
@@ -199,14 +198,31 @@ double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
         return std::numeric_limits<double>::max();
     }
 
-    std::vector<PathData> unpacked_path;
-    unpackPath(facade,
-               packed_path.begin(),
-               packed_path.end(),
-               {source_phantom, target_phantom},
-               unpacked_path);
+    EdgeDistance distance = 0;
 
-    return getPathDistance(facade, unpacked_path, source_phantom, target_phantom);
+    std::vector<NodeID> unpacked_nodes;
+    unpacked_nodes.reserve(packed_path.size());
+    if (!packed_path.empty())
+    {
+        unpacked_nodes.push_back(packed_path.front());
+        unpackPath(
+            facade, packed_path.begin(), packed_path.end(), [&](const auto &edge, const auto &) {
+                BOOST_ASSERT(edge.first == unpacked_nodes.back());
+                unpacked_nodes.push_back(edge.second);
+            });
+
+        distance = std::accumulate(unpacked_nodes.begin(),
+                                   std::prev(unpacked_nodes.end()),
+                                   EdgeDistance{0},
+                                   [&](const EdgeDistance distance, const auto node_id) {
+                                       return distance + computeEdgeDistance(facade, node_id);
+                                   });
+    }
+
+    distance =
+        adjustPathDistanceToPhantomNodes(unpacked_nodes, source_phantom, target_phantom, distance);
+
+    return distance;
 }
 } // namespace ch
 

src/extractor/compressed_edge_container.cpp

@@ -396,5 +396,5 @@ std::unique_ptr<SegmentDataContainer> CompressedEdgeContainer::ToSegmentData()
 
     return std::move(segment_data);
 }
-} // namespace extractor
-} // namespace osrm
+}
+}

src/extractor/edge_based_graph_factory.cpp

@@ -51,7 +51,7 @@ template <> struct hash<std::pair<NodeID, NodeID>>
         return seed;
     }
 };
-} // namespace std
+}
 
 // Buffer size of turn_indexes_write_buffer to reduce number of write(v) syscals
 const constexpr int TURN_INDEX_WRITE_BUFFER_SIZE = 1000;
@@ -570,6 +570,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
             const auto &road_legs_on_the_right,
             const auto &road_legs_on_the_left,
             const auto &edge_geometries) {
+
             const auto node_restricted =
                 isRestricted(node_along_road_entering,
                              intersection_node,
@@ -651,17 +652,16 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
             // auto turn_id = m_edge_based_edge_list.size();
             auto weight = boost::numeric_cast<EdgeWeight>(edge_data1.weight + weight_penalty);
             auto duration = boost::numeric_cast<EdgeWeight>(edge_data1.duration + duration_penalty);
-            auto distance = boost::numeric_cast<EdgeDistance>(edge_data1.distance);
 
-            EdgeBasedEdge edge_based_edge = {edge_based_node_from,
-                                             edge_based_node_to,
-                                             SPECIAL_NODEID, // This will be updated once the main
-                                                             // loop completes!
-                                             weight,
-                                             duration,
-                                             distance,
-                                             true,
-                                             false};
+            EdgeBasedEdge edge_based_edge = {
+                edge_based_node_from,
+                edge_based_node_to,
+                SPECIAL_NODEID, // This will be updated once the main loop
+                                // completes!
+                weight,
+                duration,
+                true,
+                false};
 
             // We write out the mapping between the edge-expanded edges and the original nodes.
             // Since each edge represents a possible maneuver, external programs can use this to
@@ -693,6 +693,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
         //
         tbb::filter_t<tbb::blocked_range<NodeID>, EdgesPipelineBufferPtr> processor_stage(
             tbb::filter::parallel, [&](const tbb::blocked_range<NodeID> &intersection_node_range) {
+
                 auto buffer = std::make_shared<EdgesPipelineBuffer>();
                 buffer->nodes_processed = intersection_node_range.size();
 
@@ -1031,6 +1032,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
         std::vector<EdgeWithData> delayed_data;
         tbb::filter_t<EdgesPipelineBufferPtr, void> output_stage(
             tbb::filter::serial_in_order, [&](auto buffer) {
+
                 routing_progress.PrintAddition(buffer->nodes_processed);
 
                 m_connectivity_checksum = buffer->checksum.update_checksum(m_connectivity_checksum);

src/extractor/extraction_containers.cpp

@@ -99,7 +99,7 @@ inline NodeID mapExternalToInternalNodeID(Iter first, Iter last, const OSMNodeID
     return (it == last || value < *it) ? SPECIAL_NODEID
                                        : static_cast<NodeID>(std::distance(first, it));
 }
-} // namespace
+}
 
 namespace osrm
 {
@@ -387,16 +387,12 @@ void ExtractionContainers::PrepareEdges(ScriptingEnvironment &scripting_environm
             const auto weight = edge_iterator->weight_data(distance);
             const auto duration = edge_iterator->duration_data(distance);
 
-            const auto accurate_distance =
-                util::coordinate_calculation::fccApproximateDistance(source_coord, target_coord);
-
             ExtractionSegment segment(source_coord, target_coord, distance, weight, duration);
             scripting_environment.ProcessSegment(segment);
 
             auto &edge = edge_iterator->result;
             edge.weight = std::max<EdgeWeight>(1, std::round(segment.weight * weight_multiplier));
             edge.duration = std::max<EdgeWeight>(1, std::round(segment.duration * 10.));
-            edge.distance = accurate_distance;
 
             // assign new node id
             const auto node_id = mapExternalToInternalNodeID(
@@ -744,6 +740,7 @@ void ExtractionContainers::PrepareManeuverOverrides()
      **/
     auto const find_turn_from_way_tofrom_nodes = [&](auto const &from_segment,
                                                      auto const &to_segment) {
+
         if (from_segment.first_segment_source_id == to_segment.first_segment_source_id)
         {
             return NodeBasedTurn{osm_node_to_internal_nbn(from_segment.first_segment_target_id),
@@ -860,6 +857,7 @@ void ExtractionContainers::PrepareManeuverOverrides()
     // Later, the UnresolvedManeuverOverride will be converted into a final ManeuverOverride
     // once the edge-based-node IDs are generated by the edge-based-graph-factory
     const auto transform = [&](const auto &external, auto &internal) {
+
         // Create a stub override
         auto maneuver_override =
             UnresolvedManeuverOverride{{},

src/extractor/extractor_callbacks.cpp

@@ -415,7 +415,6 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
                     OSMNodeID{static_cast<std::uint64_t>(last_node.ref())},
                     0,  // weight
                     0,  // duration
-                    0,  // distance
                     {}, // geometry id
                     static_cast<AnnotationID>(annotation_data_id),
                     {true,
@@ -451,7 +450,6 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
                     OSMNodeID{static_cast<std::uint64_t>(last_node.ref())},
                     0,  // weight
                     0,  // duration
-                    0,  // distance
                     {}, // geometry id
                     static_cast<AnnotationID>(annotation_data_id),
                     {false,

src/extractor/graph_compressor.cpp

@@ -259,8 +259,6 @@ void GraphCompressor::Compress(
                 const auto forward_weight2 = fwd_edge_data2.weight;
                 const auto forward_duration1 = fwd_edge_data1.duration;
                 const auto forward_duration2 = fwd_edge_data2.duration;
-                // const auto forward_distance1 = fwd_edge_data1.distance;
-                const auto forward_distance2 = fwd_edge_data2.distance;
 
                 BOOST_ASSERT(0 != forward_weight1);
                 BOOST_ASSERT(0 != forward_weight2);
@@ -269,8 +267,6 @@ void GraphCompressor::Compress(
                 const auto reverse_weight2 = rev_edge_data2.weight;
                 const auto reverse_duration1 = rev_edge_data1.duration;
                 const auto reverse_duration2 = rev_edge_data2.duration;
-                // const auto reverse_distance1 = rev_edge_data1.distance;
-                const auto reverse_distance2 = rev_edge_data2.distance;
 
                 BOOST_ASSERT(0 != reverse_weight1);
                 BOOST_ASSERT(0 != reverse_weight2);
@@ -283,10 +279,6 @@ void GraphCompressor::Compress(
                 graph.GetEdgeData(forward_e1).duration += forward_duration2;
                 graph.GetEdgeData(reverse_e1).duration += reverse_duration2;
 
-                // add duration of e2's to e1
-                graph.GetEdgeData(forward_e1).distance += forward_distance2;
-                graph.GetEdgeData(reverse_e1).distance += reverse_distance2;
-
                 if (node_weight_penalty != INVALID_EDGE_WEIGHT &&
                     node_duration_penalty != MAXIMAL_EDGE_DURATION)
                 {
@@ -294,7 +286,6 @@ void GraphCompressor::Compress(
                     graph.GetEdgeData(reverse_e1).weight += node_weight_penalty;
                     graph.GetEdgeData(forward_e1).duration += node_duration_penalty;
                     graph.GetEdgeData(reverse_e1).duration += node_duration_penalty;
-                    // Note: no penalties for distances
                 }
 
                 // extend e1's to targets of e2's
@@ -368,5 +359,5 @@ void GraphCompressor::PrintStatistics(unsigned original_number_of_nodes,
     util::Log() << "Node compression ratio: " << new_node_count / (double)original_number_of_nodes;
     util::Log() << "Edge compression ratio: " << new_edge_count / (double)original_number_of_edges;
 }
-} // namespace extractor
-} // namespace osrm
+}
+}

src/nodejs/node_osrm.cpp

@@ -9,15 +9,12 @@
 #include "osrm/trip_parameters.hpp"
 
 #include <exception>
-#include <sstream>
 #include <type_traits>
 #include <utility>
 
 #include "nodejs/node_osrm.hpp"
 #include "nodejs/node_osrm_support.hpp"
 
-#include "util/json_renderer.hpp"
-
 namespace node_osrm
 {
 
@@ -125,8 +122,6 @@ inline void async(const Nan::FunctionCallbackInfo<v8::Value> &info,
     if (!params)
         return;
 
-    auto pluginParams = argumentsToPluginParameters(info);
-
     BOOST_ASSERT(params->IsValid());
 
     if (!info[info.Length() - 1]->IsFunction())
@@ -142,89 +137,9 @@ inline void async(const Nan::FunctionCallbackInfo<v8::Value> &info,
         Worker(std::shared_ptr<osrm::OSRM> osrm_,
                ParamPtr params_,
                ServiceMemFn service,
-               Nan::Callback *callback,
-               PluginParameters pluginParams_)
+               Nan::Callback *callback)
             : Base(callback), osrm{std::move(osrm_)}, service{std::move(service)},
-              params{std::move(params_)}, pluginParams{std::move(pluginParams_)}
-        {
-        }
-
-        void Execute() override try
-        {
-            osrm::json::Object r;
-            const auto status = ((*osrm).*(service))(*params, r);
-            ParseResult(status, r);
-            if (pluginParams.renderJSONToBuffer)
-            {
-                std::ostringstream buf;
-                osrm::util::json::render(buf, r);
-                result = buf.str();
-            }
-            else
-            {
-                result = r;
-            }
-        }
-        catch (const std::exception &e)
-        {
-            SetErrorMessage(e.what());
-        }
-
-        void HandleOKCallback() override
-        {
-            Nan::HandleScope scope;
-
-            const constexpr auto argc = 2u;
-            v8::Local<v8::Value> argv[argc] = {Nan::Null(), render(result)};
-
-            callback->Call(argc, argv);
-        }
-
-        // Keeps the OSRM object alive even after shutdown until we're done with callback
-        std::shared_ptr<osrm::OSRM> osrm;
-        ServiceMemFn service;
-        const ParamPtr params;
-        const PluginParameters pluginParams;
-
-        ObjectOrString result;
-    };
-
-    auto *callback = new Nan::Callback{info[info.Length() - 1].As<v8::Function>()};
-    Nan::AsyncQueueWorker(
-        new Worker{self->this_, std::move(params), service, callback, std::move(pluginParams)});
-}
-
-template <typename ParameterParser, typename ServiceMemFn>
-inline void asyncForTiles(const Nan::FunctionCallbackInfo<v8::Value> &info,
-                          ParameterParser argsToParams,
-                          ServiceMemFn service,
-                          bool requires_multiple_coordinates)
-{
-    auto params = argsToParams(info, requires_multiple_coordinates);
-    if (!params)
-        return;
-
-    auto pluginParams = argumentsToPluginParameters(info);
-
-    BOOST_ASSERT(params->IsValid());
-
-    if (!info[info.Length() - 1]->IsFunction())
-        return Nan::ThrowTypeError("last argument must be a callback function");
-
-    auto *const self = Nan::ObjectWrap::Unwrap<Engine>(info.Holder());
-    using ParamPtr = decltype(params);
-
-    struct Worker final : Nan::AsyncWorker
-    {
-        using Base = Nan::AsyncWorker;
-
-        Worker(std::shared_ptr<osrm::OSRM> osrm_,
-               ParamPtr params_,
-               ServiceMemFn service,
-               Nan::Callback *callback,
-               PluginParameters pluginParams_)
-            : Base(callback), osrm{std::move(osrm_)}, service{std::move(service)},
-              params{std::move(params_)}, pluginParams{std::move(pluginParams_)}
+              params{std::move(params_)}
         {
         }
 
@@ -252,14 +167,18 @@ inline void asyncForTiles(const Nan::FunctionCallbackInfo<v8::Value> &info,
         std::shared_ptr<osrm::OSRM> osrm;
         ServiceMemFn service;
         const ParamPtr params;
-        const PluginParameters pluginParams;
 
-        std::string result;
+        // All services return json::Object .. except for Tile!
+        using ObjectOrString =
+            typename std::conditional<std::is_same<ParamPtr, tile_parameters_ptr>::value,
+                                      std::string,
+                                      osrm::json::Object>::type;
+
+        ObjectOrString result;
     };
 
     auto *callback = new Nan::Callback{info[info.Length() - 1].As<v8::Function>()};
-    Nan::AsyncQueueWorker(
-        new Worker{self->this_, std::move(params), service, callback, std::move(pluginParams)});
+    Nan::AsyncQueueWorker(new Worker{self->this_, std::move(params), service, callback});
 }
 
 // clang-format off
@@ -422,7 +341,7 @@ NAN_METHOD(Engine::table) //
 // clang-format on
 NAN_METHOD(Engine::tile)
 {
-    asyncForTiles(info, &argumentsToTileParameters, &osrm::OSRM::Tile, {/*unused*/});
+    async(info, &argumentsToTileParameters, &osrm::OSRM::Tile, {/*unused*/});
 }
 
 // clang-format off

src/tools/contract.cpp

@@ -81,11 +81,7 @@ return_code parseArguments(int argc,
         "time-zone-file",
         boost::program_options::value<std::string>(&contractor_config.updater_config.tz_file_path),
         "Required for conditional turn restriction parsing, provide a geojson file containing "
-        "time zone boundaries")(
-        "cache-distances",
-        boost::program_options::bool_switch(&contractor_config.cache_distances)
-            ->default_value(false),
-        "Store distances for CH edges, avoiding the need for query-time re-calculation.");
+        "time zone boundaries");
 
     // hidden options, will be allowed on command line, but will not be shown to the user
     boost::program_options::options_description hidden_options("Hidden options");

src/tools/routed.cpp

@@ -70,8 +70,8 @@ std::istream &operator>>(std::istream &in, EngineConfig::Algorithm &algorithm)
         throw util::RuntimeError(token, ErrorCode::UnknownAlgorithm, SOURCE_REF);
     return in;
 }
-} // namespace engine
-} // namespace osrm
+}
+}
 
 // generate boost::program_options object for the routing part
 inline unsigned generateServerProgramOptions(const int argc,
@@ -273,12 +273,10 @@ int main(int argc, const char *argv[]) try
 
 #ifndef _WIN32
     int sig = 0;
-    sigset_t wait_mask;
-    sigemptyset(&wait_mask);
-    sigaddset(&wait_mask, SIGINT);
-    sigaddset(&wait_mask, SIGQUIT);
-    sigaddset(&wait_mask, SIGTERM);
-    pthread_sigmask(SIG_BLOCK, &wait_mask, nullptr); // only block necessary signals
+    sigset_t new_mask;
+    sigset_t old_mask;
+    sigfillset(&new_mask);
+    pthread_sigmask(SIG_BLOCK, &new_mask, &old_mask);
 #endif
 
     auto service_handler = std::make_unique<server::ServiceHandler>(config);
@@ -300,13 +298,19 @@ int main(int argc, const char *argv[]) try
         std::thread server_thread(std::move(server_task));
 
 #ifndef _WIN32
+        sigset_t wait_mask;
+        pthread_sigmask(SIG_SETMASK, &old_mask, nullptr);
+        sigemptyset(&wait_mask);
+        sigaddset(&wait_mask, SIGINT);
+        sigaddset(&wait_mask, SIGQUIT);
+        sigaddset(&wait_mask, SIGTERM);
+        pthread_sigmask(SIG_BLOCK, &wait_mask, nullptr);
         util::Log() << "running and waiting for requests";
         if (std::getenv("SIGNAL_PARENT_WHEN_READY"))
         {
             kill(getppid(), SIGUSR1);
         }
         sigwait(&wait_mask, &sig);
-        util::Log() << "received signal " << sig;
 #else
         // Set console control handler to allow server to be stopped.
         console_ctrl_function = std::bind(&server::Server::Stop, routing_server);

src/tools/store.cpp

@@ -82,8 +82,7 @@ void springClean()
     }
     else
     {
-        for (auto key : util::irange<storage::SharedRegionRegister::RegionID>(
-                 0, storage::SharedRegionRegister::MAX_SHM_KEYS))
+        for (auto key : util::irange<storage::SharedRegionRegister::RegionID>(0, storage::SharedRegionRegister::MAX_SHM_KEYS))
         {
             deleteRegion(key);
         }

src/util/coordinate_calculation.cpp

@@ -22,6 +22,11 @@ namespace coordinate_calculation
 
 namespace
 {
+
+// earth radius varies between 6,356.750-6,378.135 km (3,949.901-3,963.189mi)
+// The IUGG value for the equatorial radius is 6378.137 km (3963.19 miles)
+const constexpr double EARTH_RADIUS = 6372797.560856;
+
 class CheapRulerContainer
 {
   public:
@@ -112,7 +117,7 @@ double haversineDistance(const Coordinate coordinate_1, const Coordinate coordin
     const double aharv = std::pow(std::sin(dlat / 2.0), 2.0) +
                          std::cos(dlat1) * std::cos(dlat2) * std::pow(std::sin(dlong / 2.), 2);
     const double charv = 2. * std::atan2(std::sqrt(aharv), std::sqrt(1.0 - aharv));
-    return detail::EARTH_RADIUS * charv;
+    return EARTH_RADIUS * charv;
 }
 
 double greatCircleDistance(const Coordinate coordinate_1, const Coordinate coordinate_2)
@@ -133,7 +138,7 @@ double greatCircleDistance(const Coordinate coordinate_1, const Coordinate coord
 
     const double x_value = (float_lon2 - float_lon1) * std::cos((float_lat1 + float_lat2) / 2.0);
     const double y_value = float_lat2 - float_lat1;
-    return std::hypot(x_value, y_value) * detail::EARTH_RADIUS;
+    return std::hypot(x_value, y_value) * EARTH_RADIUS;
 }
 
 double perpendicularDistance(const Coordinate segment_source,

test/data/Makefile

@@ -74,11 +74,11 @@ benchmark: data $(DATA_NAME).requests
 	$(TIMER) "queries\tCoreCH" "cat $(DATA_NAME).requests | xargs curl &> /dev/null"
 	@cat osrm-routed.pid | xargs kill
 	@rm osrm-routed.pid
-	# @/bin/sh -c '$(OSRM_ROUTED) --algorithm=MLD mld/$(DATA_NAME).osrm > /dev/null & echo "$$!" > osrm-routed.pid'
-	# @sleep 1
-	# $(TIMER) "queries\tMLD" "cat $(DATA_NAME).requests | xargs curl &> /dev/null"
-	# @cat osrm-routed.pid | xargs kill
-	# @rm osrm-routed.pid
+	@/bin/sh -c '$(OSRM_ROUTED) --algorithm=MLD mld/$(DATA_NAME).osrm > /dev/null & echo "$$!" > osrm-routed.pid'
+	@sleep 1
+	$(TIMER) "queries\tMLD" "cat $(DATA_NAME).requests | xargs curl &> /dev/null"
+	@cat osrm-routed.pid | xargs kill
+	@rm osrm-routed.pid
 	@echo "**** timings ***"
 	@cat /tmp/osrm.timings
 	@echo "****************"

test/nodejs/match.js

@@ -25,28 +25,6 @@ test('match: match in Monaco', function(assert) {
     });
 });
 
-test('match: match in Monaco returning a buffer', function(assert) {
-    assert.plan(6);
-    var osrm = new OSRM(data_path);
-    var options = {
-        coordinates: three_test_coordinates,
-        timestamps: [1424684612, 1424684616, 1424684620]
-    };
-    osrm.match(options, { format: 'json_buffer' }, function(err, response) {
-        assert.ifError(err);
-        assert.ok(response instanceof Buffer);
-        response = JSON.parse(response);
-        assert.equal(response.matchings.length, 1);
-        assert.ok(response.matchings.every(function(m) {
-            return !!m.distance && !!m.duration && Array.isArray(m.legs) && !!m.geometry && m.confidence > 0;
-        }))
-        assert.equal(response.tracepoints.length, 3);
-        assert.ok(response.tracepoints.every(function(t) {
-            return !!t.hint && !isNaN(t.matchings_index) && !isNaN(t.waypoint_index) && !!t.name;
-        }));
-    });
-});
-
 test('match: match in Monaco without timestamps', function(assert) {
     assert.plan(3);
     var osrm = new OSRM(data_path);
@@ -247,30 +225,20 @@ test('match: throws on invalid tidy param', function(assert) {
         /tidy must be of type Boolean/);
 });
 
-test('match: throws on invalid config param', function(assert) {
-    assert.plan(1);
+test('match: match in Monaco without motorways', function(assert) {
+    assert.plan(3);
     var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
     var options = {
         coordinates: three_test_coordinates,
+        exclude: ['motorway']
     };
-    assert.throws(function() { osrm.match(options, { format: 'invalid' }, function(err, response) {}) },
-        /format must be a string:/);
+    osrm.match(options, function(err, response) {
+        assert.ifError(err);
+        assert.equal(response.tracepoints.length, 3);
+        assert.equal(response.matchings.length, 1);
+    });
 });
 
-// test('match: match in Monaco without motorways', function(assert) {
-//     assert.plan(3);
-//     var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
-//     var options = {
-//         coordinates: three_test_coordinates,
-//         exclude: ['motorway']
-//     };
-//     osrm.match(options, function(err, response) {
-//         assert.ifError(err);
-//         assert.equal(response.tracepoints.length, 3);
-//         assert.equal(response.matchings.length, 1);
-//     });
-// });
-
 test('match: throws on invalid waypoints values needs at least two', function(assert) {
     assert.plan(1);
     var osrm = new OSRM(data_path);

test/nodejs/nearest.js

@@ -19,21 +19,6 @@ test('nearest', function(assert) {
     });
 });
 
-test('nearest', function(assert) {
-    assert.plan(5);
-    var osrm = new OSRM(data_path);
-    osrm.nearest({
-        coordinates: [three_test_coordinates[0]]
-    }, { format: 'json_buffer' }, function(err, result) {
-        assert.ifError(err);
-        assert.ok(result instanceof Buffer);
-        result = JSON.parse(result);
-        assert.equal(result.waypoints.length, 1);
-        assert.equal(result.waypoints[0].location.length, 2);
-        assert.ok(result.waypoints[0].hasOwnProperty('name'));
-    });
-});
-
 test('nearest: can ask for multiple nearest pts', function(assert) {
     assert.plan(2);
     var osrm = new OSRM(data_path);
@@ -47,7 +32,7 @@ test('nearest: can ask for multiple nearest pts', function(assert) {
 });
 
 test('nearest: throws on invalid args', function(assert) {
-    assert.plan(7);
+    assert.plan(6);
     var osrm = new OSRM(data_path);
     var options = {};
     assert.throws(function() { osrm.nearest(options); },
@@ -67,21 +52,17 @@ test('nearest: throws on invalid args', function(assert) {
     options.number = 0;
     assert.throws(function() { osrm.nearest(options, function(err, res) {}); },
         /Number must be an integer greater than or equal to 1/);
-
-    options.number = 1;
-    assert.throws(function() { osrm.nearest(options, { format: 'invalid' }, function(err, res) {}); },
-        /format must be a string:/);
 });
 
-// test('nearest: nearest in Monaco without motorways', function(assert) {
-//     assert.plan(2);
-//     var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
-//     var options = {
-//         coordinates: [two_test_coordinates[0]],
-//         exclude: ['motorway']
-//     };
-//     osrm.nearest(options, function(err, response) {
-//         assert.ifError(err);
-//         assert.equal(response.waypoints.length, 1);
-//     });
-// });
+test('nearest: nearest in Monaco without motorways', function(assert) {
+    assert.plan(2);
+    var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
+    var options = {
+        coordinates: [two_test_coordinates[0]],
+        exclude: ['motorway']
+    };
+    osrm.nearest(options, function(err, response) {
+        assert.ifError(err);
+        assert.equal(response.waypoints.length, 1);
+    });
+});

test/nodejs/route.js

@@ -43,22 +43,8 @@ test('route: routes Monaco on CoreCH', function(assert) {
     });
 });
 
-test('route: routes Monaco and returns a JSON buffer', function(assert) {
-    assert.plan(6);
-    var osrm = new OSRM({path: monaco_corech_path, algorithm: 'CoreCH'});
-    osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]]}, { format: 'json_buffer'}, function(err, result) {
-        assert.ifError(err);
-        assert.ok(result instanceof Buffer);
-        const route = JSON.parse(result);
-        assert.ok(route.waypoints);
-        assert.ok(route.routes);
-        assert.ok(route.routes.length);
-        assert.ok(route.routes[0].geometry);
-    });
-});
-
 test('route: throws with too few or invalid args', function(assert) {
-    assert.plan(4);
+    assert.plan(3);
     var osrm = new OSRM(monaco_path);
     assert.throws(function() { osrm.route({coordinates: two_test_coordinates}) },
         /Two arguments required/);
@@ -66,8 +52,6 @@ test('route: throws with too few or invalid args', function(assert) {
         /First arg must be an object/);
     assert.throws(function() { osrm.route({coordinates: two_test_coordinates}, true)},
         /last argument must be a callback function/);
-    assert.throws(function() { osrm.route({coordinates: two_test_coordinates}, { format: 'invalid' }, function(err, route) {})},
-        /format must be a string:/);
 });
 
 test('route: provides no alternatives by default, but when requested it may (not guaranteed)', function(assert) {
@@ -592,17 +576,17 @@ test('route:  in Monaco with custom limits on MLD', function(assert) {
     });
 });
 
-// test('route: route in Monaco without motorways', function(assert) {
-//     assert.plan(3);
-//     var osrm = new OSRM({path: monaco_mld_path, algorithm: 'MLD'});
-//     var options = {
-//         coordinates: two_test_coordinates,
-//         exclude: ['motorway']
-//     };
-//     osrm.route(options, function(err, response) {
-//         assert.ifError(err);
-//         assert.equal(response.waypoints.length, 2);
-//         assert.equal(response.routes.length, 1);
-//     });
-// });
+test('route: route in Monaco without motorways', function(assert) {
+    assert.plan(3);
+    var osrm = new OSRM({path: monaco_mld_path, algorithm: 'MLD'});
+    var options = {
+        coordinates: two_test_coordinates,
+        exclude: ['motorway']
+    };
+    osrm.route(options, function(err, response) {
+        assert.ifError(err);
+        assert.equal(response.waypoints.length, 2);
+        assert.equal(response.routes.length, 1);
+    });
+});
 

test/nodejs/table.js

@@ -48,20 +48,6 @@ test('table: test annotations paramater combination', function(assert) {
     });
 });
 
-test('table: returns buffer', function(assert) {
-    assert.plan(3);
-    var osrm = new OSRM(data_path);
-    var options = {
-        coordinates: [three_test_coordinates[0], three_test_coordinates[1]],
-    };
-    osrm.table(options, { format: 'json_buffer' }, function(err, table) {
-        assert.ifError(err);
-        assert.ok(table instanceof Buffer);
-        table = JSON.parse(table);
-        assert.ok(table['durations'], 'distances table result should exist');
-    });
-});
-
 var tables = ['distances', 'durations'];
 
 tables.forEach(function(annotation) {
@@ -130,7 +116,7 @@ tables.forEach(function(annotation) {
     });
 
     test('table: ' + annotation + ' throws on invalid arguments', function(assert) {
-        assert.plan(15);
+        assert.plan(14);
         var osrm = new OSRM(data_path);
         var options = {annotations: [annotation.slice(0,-1)]};
         assert.throws(function() { osrm.table(options); },
@@ -149,9 +135,6 @@ tables.forEach(function(annotation) {
             /Coordinates must be an array of \(lon\/lat\) pairs/);
 
         options.coordinates = two_test_coordinates;
-        assert.throws(function() { osrm.table(options, { format: 'invalid' }, function(err, response) {}) },
-            /format must be a string:/);
-
         options.sources = true;
         assert.throws(function() { osrm.table(options, function(err, response) {}) },
             /Sources must be an array of indices \(or undefined\)/);
@@ -233,17 +216,17 @@ tables.forEach(function(annotation) {
         });
     });
 
-    // test('table: ' + annotation + ' table in Monaco without motorways', function(assert) {
-    //     assert.plan(1);
-    //     var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
-    //     var options = {
-    //         coordinates: two_test_coordinates,
-    //         exclude: ['motorway'],
-    //         annotations: [annotation.slice(0,-1)]
-    //     };
-    //     osrm.table(options, function(err, response) {
-    //         assert.equal(response[annotation].length, 2);
-    //     });
-    // });
+    test('table: ' + annotation + ' table in Monaco without motorways', function(assert) {
+        assert.plan(1);
+        var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
+        var options = {
+            coordinates: two_test_coordinates,
+            exclude: ['motorway'],
+            annotations: [annotation.slice(0,-1)]
+        };
+        osrm.table(options, function(err, response) {
+            assert.equal(response[annotation].length, 2);
+        });
+    });
 });
 

test/nodejs/trip.js

@@ -17,19 +17,6 @@ test('trip: trip in Monaco', function(assert) {
     });
 });
 
-test('trip: trip in Monaco as a buffer', function(assert) {
-    assert.plan(3);
-    var osrm = new OSRM(data_path);
-    osrm.trip({coordinates: two_test_coordinates}, { format: 'json_buffer' }, function(err, trip) {
-        assert.ifError(err);
-        assert.ok(trip instanceof Buffer);
-        trip = JSON.parse(trip);
-        for (t = 0; t < trip.trips.length; t++) {
-            assert.ok(trip.trips[t].geometry);
-        }
-    });
-});
-
 test('trip: trip with many locations in Monaco', function(assert) {
     assert.plan(2);
 
@@ -46,14 +33,12 @@ test('trip: trip with many locations in Monaco', function(assert) {
 });
 
 test('trip: throws with too few or invalid args', function(assert) {
-    assert.plan(3);
+    assert.plan(2);
     var osrm = new OSRM(data_path);
     assert.throws(function() { osrm.trip({coordinates: two_test_coordinates}) },
         /Two arguments required/);
     assert.throws(function() { osrm.trip(null, function(err, trip) {}) },
         /First arg must be an object/);
-    assert.throws(function() { osrm.trip({coordinates: two_test_coordinates}, { format: 'invalid' }, function(err, trip) {}) },
-        /format must be a string:/);
 });
 
 test('trip: throws with bad params', function(assert) {
@@ -342,17 +327,17 @@ test('trip: fixed start and end combinations', function(assert) {
     assert.end();
 });
 
-// test('trip: trip in Monaco without motorways', function(assert) {
-//     assert.plan(3);
-//     var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
-//     var options = {
-//         coordinates: two_test_coordinates,
-//         exclude: ['motorway']
-//     };
-//     osrm.trip(options, function(err, response) {
-//         assert.ifError(err);
-//         assert.equal(response.waypoints.length, 2);
-//         assert.equal(response.trips.length, 1);
-//     });
-// });
+test('trip: trip in Monaco without motorways', function(assert) {
+    assert.plan(3);
+    var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
+    var options = {
+        coordinates: two_test_coordinates,
+        exclude: ['motorway']
+    };
+    osrm.trip(options, function(err, response) {
+        assert.ifError(err);
+        assert.equal(response.waypoints.length, 2);
+        assert.equal(response.trips.length, 1);
+    });
+});
 

unit_tests/contractor/contracted_edge_container.cpp

@@ -31,79 +31,79 @@ std::ostream &operator<<(std::ostream &out, const QueryEdge &edge)
 
 BOOST_AUTO_TEST_SUITE(contracted_edge_container)
 
-// BOOST_AUTO_TEST_CASE(merge_edge_of_multiple_graph)
-// {
-//     ContractedEdgeContainer container;
+BOOST_AUTO_TEST_CASE(merge_edge_of_multiple_graph)
+{
+    ContractedEdgeContainer container;
 
-//     std::vector<QueryEdge> edges;
-//     edges.push_back(QueryEdge{0, 1, {1, false, 3, 6, true, false}});
-//     edges.push_back(QueryEdge{1, 2, {2, false, 3, 6, true, false}});
-//     edges.push_back(QueryEdge{2, 0, {3, false, 3, 6, false, true}});
-//     edges.push_back(QueryEdge{2, 1, {4, false, 3, 6, false, true}});
-//     container.Insert(edges);
+    std::vector<QueryEdge> edges;
+    edges.push_back(QueryEdge{0, 1, {1, false, 3, 6, true, false}});
+    edges.push_back(QueryEdge{1, 2, {2, false, 3, 6, true, false}});
+    edges.push_back(QueryEdge{2, 0, {3, false, 3, 6, false, true}});
+    edges.push_back(QueryEdge{2, 1, {4, false, 3, 6, false, true}});
+    container.Insert(edges);
 
-//     edges.clear();
-//     edges.push_back(QueryEdge{0, 1, {1, false, 3, 6, true, false}});
-//     edges.push_back(QueryEdge{1, 2, {2, false, 3, 6, true, false}});
-//     edges.push_back(QueryEdge{2, 0, {3, false, 12, 24, false, true}});
-//     edges.push_back(QueryEdge{2, 1, {4, false, 12, 24, false, true}});
-//     container.Merge(edges);
+    edges.clear();
+    edges.push_back(QueryEdge{0, 1, {1, false, 3, 6, true, false}});
+    edges.push_back(QueryEdge{1, 2, {2, false, 3, 6, true, false}});
+    edges.push_back(QueryEdge{2, 0, {3, false, 12, 24, false, true}});
+    edges.push_back(QueryEdge{2, 1, {4, false, 12, 24, false, true}});
+    container.Merge(edges);
 
-//     edges.clear();
-//     edges.push_back(QueryEdge{1, 4, {5, false, 3, 6, true, false}});
-//     container.Merge(edges);
+    edges.clear();
+    edges.push_back(QueryEdge{1, 4, {5, false, 3, 6, true, false}});
+    container.Merge(edges);
 
-//     std::vector<QueryEdge> reference_edges;
-//     reference_edges.push_back(QueryEdge{0, 1, {1, false, 3, 6, true, false}});
-//     reference_edges.push_back(QueryEdge{1, 2, {2, false, 3, 6, true, false}});
-//     reference_edges.push_back(QueryEdge{1, 4, {5, false, 3, 6, true, false}});
-//     reference_edges.push_back(QueryEdge{2, 0, {3, false, 3, 6, false, true}});
-//     reference_edges.push_back(QueryEdge{2, 0, {3, false, 12, 24, false, true}});
-//     reference_edges.push_back(QueryEdge{2, 1, {4, false, 3, 6, false, true}});
-//     reference_edges.push_back(QueryEdge{2, 1, {4, false, 12, 24, false, true}});
-//     CHECK_EQUAL_COLLECTIONS(container.edges, reference_edges);
+    std::vector<QueryEdge> reference_edges;
+    reference_edges.push_back(QueryEdge{0, 1, {1, false, 3, 6, true, false}});
+    reference_edges.push_back(QueryEdge{1, 2, {2, false, 3, 6, true, false}});
+    reference_edges.push_back(QueryEdge{1, 4, {5, false, 3, 6, true, false}});
+    reference_edges.push_back(QueryEdge{2, 0, {3, false, 3, 6, false, true}});
+    reference_edges.push_back(QueryEdge{2, 0, {3, false, 12, 24, false, true}});
+    reference_edges.push_back(QueryEdge{2, 1, {4, false, 3, 6, false, true}});
+    reference_edges.push_back(QueryEdge{2, 1, {4, false, 12, 24, false, true}});
+    CHECK_EQUAL_COLLECTIONS(container.edges, reference_edges);
 
-//     auto filters = container.MakeEdgeFilters();
-//     BOOST_CHECK_EQUAL(filters.size(), 2);
+    auto filters = container.MakeEdgeFilters();
+    BOOST_CHECK_EQUAL(filters.size(), 2);
 
-//     REQUIRE_SIZE_RANGE(filters[0], 7);
-//     CHECK_EQUAL_RANGE(filters[0], true, true, false, true, true, true, true);
+    REQUIRE_SIZE_RANGE(filters[0], 7);
+    CHECK_EQUAL_RANGE(filters[0], true, true, false, true, true, true, true);
 
-//     REQUIRE_SIZE_RANGE(filters[1], 7);
-//     CHECK_EQUAL_RANGE(filters[1], true, true, true, true, false, true, false);
-// }
+    REQUIRE_SIZE_RANGE(filters[1], 7);
+    CHECK_EQUAL_RANGE(filters[1], true, true, true, true, false, true, false);
+}
 
-// BOOST_AUTO_TEST_CASE(merge_edge_of_multiple_disjoint_graph)
-// {
-//     ContractedEdgeContainer container;
+BOOST_AUTO_TEST_CASE(merge_edge_of_multiple_disjoint_graph)
+{
+    ContractedEdgeContainer container;
 
-//     std::vector<QueryEdge> edges;
-//     edges.push_back(QueryEdge{0, 1, {1, false, 3, 6, true, false}});
-//     edges.push_back(QueryEdge{1, 2, {2, false, 3, 6, true, false}});
-//     edges.push_back(QueryEdge{2, 0, {3, false, 12, 24, false, true}});
-//     edges.push_back(QueryEdge{2, 1, {4, false, 12, 24, false, true}});
-//     container.Merge(edges);
+    std::vector<QueryEdge> edges;
+    edges.push_back(QueryEdge{0, 1, {1, false, 3, 6, true, false}});
+    edges.push_back(QueryEdge{1, 2, {2, false, 3, 6, true, false}});
+    edges.push_back(QueryEdge{2, 0, {3, false, 12, 24, false, true}});
+    edges.push_back(QueryEdge{2, 1, {4, false, 12, 24, false, true}});
+    container.Merge(edges);
 
-//     edges.clear();
-//     edges.push_back(QueryEdge{1, 4, {5, false, 3, 6, true, false}});
-//     container.Merge(edges);
+    edges.clear();
+    edges.push_back(QueryEdge{1, 4, {5, false, 3, 6, true, false}});
+    container.Merge(edges);
 
-//     std::vector<QueryEdge> reference_edges;
-//     reference_edges.push_back(QueryEdge{0, 1, {1, false, 3, 6, true, false}});
-//     reference_edges.push_back(QueryEdge{1, 2, {2, false, 3, 6, true, false}});
-//     reference_edges.push_back(QueryEdge{1, 4, {5, false, 3, 6, true, false}});
-//     reference_edges.push_back(QueryEdge{2, 0, {3, false, 12, 24, false, true}});
-//     reference_edges.push_back(QueryEdge{2, 1, {4, false, 12, 24, false, true}});
-//     CHECK_EQUAL_COLLECTIONS(container.edges, reference_edges);
+    std::vector<QueryEdge> reference_edges;
+    reference_edges.push_back(QueryEdge{0, 1, {1, false, 3, 6, true, false}});
+    reference_edges.push_back(QueryEdge{1, 2, {2, false, 3, 6, true, false}});
+    reference_edges.push_back(QueryEdge{1, 4, {5, false, 3, 6, true, false}});
+    reference_edges.push_back(QueryEdge{2, 0, {3, false, 12, 24, false, true}});
+    reference_edges.push_back(QueryEdge{2, 1, {4, false, 12, 24, false, true}});
+    CHECK_EQUAL_COLLECTIONS(container.edges, reference_edges);
 
-//     auto filters = container.MakeEdgeFilters();
-//     BOOST_CHECK_EQUAL(filters.size(), 2);
+    auto filters = container.MakeEdgeFilters();
+    BOOST_CHECK_EQUAL(filters.size(), 2);
 
-//     REQUIRE_SIZE_RANGE(filters[0], 5);
-//     CHECK_EQUAL_RANGE(filters[0], true, true, false, true, true);
+    REQUIRE_SIZE_RANGE(filters[0], 5);
+    CHECK_EQUAL_RANGE(filters[0], true, true, false, true, true);
 
-//     REQUIRE_SIZE_RANGE(filters[1], 5);
-//     CHECK_EQUAL_RANGE(filters[1], false, false, true, false, false);
-// }
+    REQUIRE_SIZE_RANGE(filters[1], 5);
+    CHECK_EQUAL_RANGE(filters[1], false, false, true, false, false);
+}
 
 BOOST_AUTO_TEST_SUITE_END()

unit_tests/contractor/graph_contractor.cpp

@@ -14,122 +14,122 @@ using namespace osrm::unit_test;
 
 BOOST_AUTO_TEST_SUITE(graph_contractor)
 
-// BOOST_AUTO_TEST_CASE(contract_graph)
-// {
-//     tbb::task_scheduler_init scheduler(1);
-//     /*
-//      *                 <--1--<
-//      * (0) >--3--> (1) >--3--> (3)
-//      *  v          ^  v          ^
-//      *   \        /    \         |
-//      *    1      1      1        1
-//      *     \    ^        \       /
-//      *      >(5)          > (4) >
-//      */
-//     std::vector<TestEdge> edges = {TestEdge{0, 1, 3},
-//                                    TestEdge{0, 5, 1},
-//                                    TestEdge{1, 3, 3},
-//                                    TestEdge{1, 4, 1},
-//                                    TestEdge{3, 1, 1},
-//                                    TestEdge{4, 3, 1},
-//                                    TestEdge{5, 1, 1}};
-//     auto reference_graph = makeGraph(edges);
+BOOST_AUTO_TEST_CASE(contract_graph)
+{
+    tbb::task_scheduler_init scheduler(1);
+    /*
+     *                 <--1--<
+     * (0) >--3--> (1) >--3--> (3)
+     *  v          ^  v          ^
+     *   \        /    \         |
+     *    1      1      1        1
+     *     \    ^        \       /
+     *      >(5)          > (4) >
+     */
+    std::vector<TestEdge> edges = {TestEdge{0, 1, 3},
+                                   TestEdge{0, 5, 1},
+                                   TestEdge{1, 3, 3},
+                                   TestEdge{1, 4, 1},
+                                   TestEdge{3, 1, 1},
+                                   TestEdge{4, 3, 1},
+                                   TestEdge{5, 1, 1}};
+    auto reference_graph = makeGraph(edges);
 
-//     auto contracted_graph = reference_graph;
-//     std::vector<bool> core = contractGraph(contracted_graph, {1, 1, 1, 1, 1, 1});
+    auto contracted_graph = reference_graph;
+    std::vector<bool> core = contractGraph(contracted_graph, {1, 1, 1, 1, 1, 1});
 
-//     // This contraction order is dependent on the priority caculation in the contractor
-//     // but deterministic for the same graph.
-//     CHECK_EQUAL_RANGE(core, false, false, false, false, false, false);
+    // This contraction order is dependent on the priority caculation in the contractor
+    // but deterministic for the same graph.
+    CHECK_EQUAL_RANGE(core, false, false, false, false, false, false);
 
-//     /* After contracting 0 and 2:
-//      *
-//      * Deltes edges 5 -> 0, 1 -> 0
-//      *
-//      *                 <--1--<
-//      * (0) ---3--> (1) >--3--> (3)
-//      *  \          ^  v          ^
-//      *   \        /    \         |
-//      *    1      1      1        1
-//      *     \    ^        \       /
-//      *      >(5)          > (4) >
-//      */
-//     reference_graph.DeleteEdgesTo(5, 0);
-//     reference_graph.DeleteEdgesTo(1, 0);
+    /* After contracting 0 and 2:
+     *
+     * Deltes edges 5 -> 0, 1 -> 0
+     *
+     *                 <--1--<
+     * (0) ---3--> (1) >--3--> (3)
+     *  \          ^  v          ^
+     *   \        /    \         |
+     *    1      1      1        1
+     *     \    ^        \       /
+     *      >(5)          > (4) >
+     */
+    reference_graph.DeleteEdgesTo(5, 0);
+    reference_graph.DeleteEdgesTo(1, 0);
 
-//     /* After contracting 5:
-//      *
-//      * Deletes edges 1 -> 5
-//      *
-//      *                 <--1--<
-//      * (0) ---3--> (1) >--3--> (3)
-//      *  \          ^  v          ^
-//      *   \        /    \         |
-//      *    1      1      1        1
-//      *     \    /        \       /
-//      *      >(5)          > (4) >
-//      */
-//     reference_graph.DeleteEdgesTo(5, 0);
-//     reference_graph.DeleteEdgesTo(1, 0);
+    /* After contracting 5:
+     *
+     * Deletes edges 1 -> 5
+     *
+     *                 <--1--<
+     * (0) ---3--> (1) >--3--> (3)
+     *  \          ^  v          ^
+     *   \        /    \         |
+     *    1      1      1        1
+     *     \    /        \       /
+     *      >(5)          > (4) >
+     */
+    reference_graph.DeleteEdgesTo(5, 0);
+    reference_graph.DeleteEdgesTo(1, 0);
 
-//      After contracting 3:
-//      *
-//      * Deletes edges 1 -> 3
-//      * Deletes edges 4 -> 3
-//      * Insert edge 4 -> 1
-//      *
-//      *                 <--1---
-//      * (0) ---3--> (1) >--3--- (3)
-//      *  \          ^  v ^        |
-//      *   \        /    \ \       |
-//      *    1      1      1 2      1
-//      *     \    /        \ \     /
-//      *      >(5)          > (4) >
+    /* After contracting 3:
+     *
+     * Deletes edges 1 -> 3
+     * Deletes edges 4 -> 3
+     * Insert edge 4 -> 1
+     *
+     *                 <--1---
+     * (0) ---3--> (1) >--3--- (3)
+     *  \          ^  v ^        |
+     *   \        /    \ \       |
+     *    1      1      1 2      1
+     *     \    /        \ \     /
+     *      >(5)          > (4) >
+     */
+    reference_graph.DeleteEdgesTo(1, 3);
+    reference_graph.DeleteEdgesTo(4, 3);
+    // Insert shortcut
+    reference_graph.InsertEdge(4, 1, {2, 4, 3, 0, true, true, false});
 
-//     reference_graph.DeleteEdgesTo(1, 3);
-//     reference_graph.DeleteEdgesTo(4, 3);
-//     // Insert shortcut
-//     reference_graph.InsertEdge(4, 1, {2, 4, 3, 0, true, true, false});
+    /* After contracting 4:
+     *
+     * Delete edges 1 -> 4
+     *
+     *                 <--1---
+     * (0) ---3--> (1) >--3--- (3)
+     *  \          ^  v ^        |
+     *   \        /    \ \       |
+     *    1      1      1 2      1
+     *     \    /        \ \     /
+     *      >(5)          \ (4) >
+     */
+    reference_graph.DeleteEdgesTo(1, 4);
 
-//     /* After contracting 4:
-//      *
-//      * Delete edges 1 -> 4
-//      *
-//      *                 <--1---
-//      * (0) ---3--> (1) >--3--- (3)
-//      *  \          ^  v ^        |
-//      *   \        /    \ \       |
-//      *    1      1      1 2      1
-//      *     \    /        \ \     /
-//      *      >(5)          \ (4) >
-//      */
-//     reference_graph.DeleteEdgesTo(1, 4);
+    /* After contracting 1:
+     *
+     * Delete no edges.
+     *
+     *                 <--1---
+     * (0) ---3--> (1) >--3--- (3)
+     *  \          ^  v ^        |
+     *   \        /    \ \       |
+     *    1      1      1 2      1
+     *     \    /        \ \     /
+     *      >(5)          \ (4) >
+     */
 
-//     /* After contracting 1:
-//      *
-//      * Delete no edges.
-//      *
-//      *                 <--1---
-//      * (0) ---3--> (1) >--3--- (3)
-//      *  \          ^  v ^        |
-//      *   \        /    \ \       |
-//      *    1      1      1 2      1
-//      *     \    /        \ \     /
-//      *      >(5)          \ (4) >
-//      */
-
-//     REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(0), 2);
-//     BOOST_CHECK(contracted_graph.FindEdge(0, 1) != SPECIAL_EDGEID);
-//     BOOST_CHECK(contracted_graph.FindEdge(0, 5) != SPECIAL_EDGEID);
-//     REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(1), 0);
-//     REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(2), 0);
-//     REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(3), 3);
-//     BOOST_CHECK(contracted_graph.FindEdge(3, 1) != SPECIAL_EDGEID);
-//     BOOST_CHECK(contracted_graph.FindEdge(3, 4) != SPECIAL_EDGEID);
-//     REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(4), 2);
-//     BOOST_CHECK(contracted_graph.FindEdge(4, 1) != SPECIAL_EDGEID);
-//     REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(5), 1);
-//     BOOST_CHECK(contracted_graph.FindEdge(5, 1) != SPECIAL_EDGEID);
-// }
+    REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(0), 2);
+    BOOST_CHECK(contracted_graph.FindEdge(0, 1) != SPECIAL_EDGEID);
+    BOOST_CHECK(contracted_graph.FindEdge(0, 5) != SPECIAL_EDGEID);
+    REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(1), 0);
+    REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(2), 0);
+    REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(3), 3);
+    BOOST_CHECK(contracted_graph.FindEdge(3, 1) != SPECIAL_EDGEID);
+    BOOST_CHECK(contracted_graph.FindEdge(3, 4) != SPECIAL_EDGEID);
+    REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(4), 2);
+    BOOST_CHECK(contracted_graph.FindEdge(4, 1) != SPECIAL_EDGEID);
+    REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(5), 1);
+    BOOST_CHECK(contracted_graph.FindEdge(5, 1) != SPECIAL_EDGEID);
+}
 
 BOOST_AUTO_TEST_SUITE_END()

unit_tests/contractor/helper.hpp

@@ -24,11 +24,11 @@ inline contractor::ContractorGraph makeGraph(const std::vector<TestEdge> &edges)
         input_edges.push_back(contractor::ContractorEdge{
             start,
             target,
-            contractor::ContractorEdgeData{weight, weight * 2, 1.0, id++, 0, false, true, false}});
+            contractor::ContractorEdgeData{weight, weight * 2, id++, 0, false, true, false}});
         input_edges.push_back(contractor::ContractorEdge{
             target,
             start,
-            contractor::ContractorEdgeData{weight, weight * 2, 1.0, id++, 0, false, false, true}});
+            contractor::ContractorEdgeData{weight, weight * 2, id++, 0, false, false, true}});
     }
     std::sort(input_edges.begin(), input_edges.end());
 

unit_tests/extractor/graph_compressor.cpp

@@ -1,296 +1,295 @@
-// #include "extractor/graph_compressor.hpp"
-// #include "extractor/compressed_edge_container.hpp"
-// #include "extractor/maneuver_override.hpp"
-// #include "extractor/restriction.hpp"
-// #include "util/node_based_graph.hpp"
-// #include "util/typedefs.hpp"
+#include "extractor/graph_compressor.hpp"
+#include "extractor/compressed_edge_container.hpp"
+#include "extractor/maneuver_override.hpp"
+#include "extractor/restriction.hpp"
+#include "util/node_based_graph.hpp"
+#include "util/typedefs.hpp"
 
-// #include "../unit_tests/mocks/mock_scripting_environment.hpp"
+#include "../unit_tests/mocks/mock_scripting_environment.hpp"
 
-// #include <boost/test/test_case_template.hpp>
-// #include <boost/test/unit_test.hpp>
+#include <boost/test/test_case_template.hpp>
+#include <boost/test/unit_test.hpp>
 
-// #include <iostream>
-// #include <unordered_set>
-// #include <vector>
+#include <iostream>
+#include <unordered_set>
+#include <vector>
 
-// BOOST_AUTO_TEST_SUITE(graph_compressor)
+BOOST_AUTO_TEST_SUITE(graph_compressor)
 
-// using namespace osrm;
-// using namespace osrm::extractor;
-// using InputEdge = util::NodeBasedDynamicGraph::InputEdge;
-// using Graph = util::NodeBasedDynamicGraph;
+using namespace osrm;
+using namespace osrm::extractor;
+using InputEdge = util::NodeBasedDynamicGraph::InputEdge;
+using Graph = util::NodeBasedDynamicGraph;
 
-// namespace
-// {
+namespace
+{
 
-// // creates a default edge of unit weight
-// inline InputEdge MakeUnitEdge(const NodeID from, const NodeID to)
-// {
-//     return {from,                          // source
-//             to,                            // target
-//             1,                             // weight
-//             1,                             // duration
-//             GeometryID{0, false},          // geometry_id
-//             false,                         // reversed
-//             NodeBasedEdgeClassification(), // default flags
-//             0};                            // AnnotationID
-// }
+// creates a default edge of unit weight
+inline InputEdge MakeUnitEdge(const NodeID from, const NodeID to)
+{
+    return {from,                          // source
+            to,                            // target
+            1,                             // weight
+            1,                             // duration
+            GeometryID{0, false},          // geometry_id
+            false,                         // reversed
+            NodeBasedEdgeClassification(), // default flags
+            0};                            // AnnotationID
+}
 
-// bool compatible(Graph const &graph,
-//                 const std::vector<NodeBasedEdgeAnnotation> &node_data_container,
-//                 EdgeID const first,
-//                 EdgeID second)
-// {
-//     auto const &first_flags = graph.GetEdgeData(first).flags;
-//     auto const &second_flags = graph.GetEdgeData(second).flags;
-//     if (!(first_flags == second_flags))
-//         return false;
+bool compatible(Graph const &graph,
+                const std::vector<NodeBasedEdgeAnnotation> &node_data_container,
+                EdgeID const first,
+                EdgeID second)
+{
+    auto const &first_flags = graph.GetEdgeData(first).flags;
+    auto const &second_flags = graph.GetEdgeData(second).flags;
+    if (!(first_flags == second_flags))
+        return false;
 
-//     if (graph.GetEdgeData(first).reversed != graph.GetEdgeData(second).reversed)
-//         return false;
+    if (graph.GetEdgeData(first).reversed != graph.GetEdgeData(second).reversed)
+        return false;
 
-//     auto const &first_annotation = node_data_container[graph.GetEdgeData(first).annotation_data];
-//     auto const &second_annotation =
-//     node_data_container[graph.GetEdgeData(second).annotation_data];
+    auto const &first_annotation = node_data_container[graph.GetEdgeData(first).annotation_data];
+    auto const &second_annotation = node_data_container[graph.GetEdgeData(second).annotation_data];
 
-//     return first_annotation.CanCombineWith(second_annotation);
-// }
+    return first_annotation.CanCombineWith(second_annotation);
+}
 
-// } // namespace
+} // namespace
 
-// BOOST_AUTO_TEST_CASE(long_road_test)
-// {
-//     //
-//     // 0---1---2---3---4
-//     //
-//     GraphCompressor compressor;
+BOOST_AUTO_TEST_CASE(long_road_test)
+{
+    //
+    // 0---1---2---3---4
+    //
+    GraphCompressor compressor;
 
-//     std::unordered_set<NodeID> barrier_nodes;
-//     std::unordered_set<NodeID> traffic_lights;
-//     std::vector<TurnRestriction> restrictions;
-//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-//     std::vector<NodeBasedEdgeAnnotation> annotations(1);
-//     CompressedEdgeContainer container;
-//     test::MockScriptingEnvironment scripting_environment;
-//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+    std::unordered_set<NodeID> barrier_nodes;
+    std::unordered_set<NodeID> traffic_lights;
+    std::vector<TurnRestriction> restrictions;
+    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+    std::vector<NodeBasedEdgeAnnotation> annotations(1);
+    CompressedEdgeContainer container;
+    test::MockScriptingEnvironment scripting_environment;
+    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-//     std::vector<InputEdge> edges = {MakeUnitEdge(0, 1),
-//                                     MakeUnitEdge(1, 0),
-//                                     MakeUnitEdge(1, 2),
-//                                     MakeUnitEdge(2, 1),
-//                                     MakeUnitEdge(2, 3),
-//                                     MakeUnitEdge(3, 2),
-//                                     MakeUnitEdge(3, 4),
-//                                     MakeUnitEdge(4, 3)};
+    std::vector<InputEdge> edges = {MakeUnitEdge(0, 1),
+                                    MakeUnitEdge(1, 0),
+                                    MakeUnitEdge(1, 2),
+                                    MakeUnitEdge(2, 1),
+                                    MakeUnitEdge(2, 3),
+                                    MakeUnitEdge(3, 2),
+                                    MakeUnitEdge(3, 4),
+                                    MakeUnitEdge(4, 3)};
 
-//     Graph graph(5, edges);
-//     BOOST_CHECK(compatible(graph, annotations, 0, 2));
-//     BOOST_CHECK(compatible(graph, annotations, 2, 4));
-//     BOOST_CHECK(compatible(graph, annotations, 4, 6));
+    Graph graph(5, edges);
+    BOOST_CHECK(compatible(graph, annotations, 0, 2));
+    BOOST_CHECK(compatible(graph, annotations, 2, 4));
+    BOOST_CHECK(compatible(graph, annotations, 4, 6));
 
-//     compressor.Compress(barrier_nodes,
-//                         traffic_lights,
-//                         scripting_environment,
-//                         restrictions,
-//                         conditional_restrictions,
-//                         maneuver_overrides,
-//                         graph,
-//                         annotations,
-//                         container);
-//     BOOST_CHECK_EQUAL(graph.FindEdge(0, 1), SPECIAL_EDGEID);
-//     BOOST_CHECK_EQUAL(graph.FindEdge(1, 2), SPECIAL_EDGEID);
-//     BOOST_CHECK_EQUAL(graph.FindEdge(2, 3), SPECIAL_EDGEID);
-//     BOOST_CHECK_EQUAL(graph.FindEdge(3, 4), SPECIAL_EDGEID);
-//     BOOST_CHECK(graph.FindEdge(0, 4) != SPECIAL_EDGEID);
-// }
+    compressor.Compress(barrier_nodes,
+                        traffic_lights,
+                        scripting_environment,
+                        restrictions,
+                        conditional_restrictions,
+                        maneuver_overrides,
+                        graph,
+                        annotations,
+                        container);
+    BOOST_CHECK_EQUAL(graph.FindEdge(0, 1), SPECIAL_EDGEID);
+    BOOST_CHECK_EQUAL(graph.FindEdge(1, 2), SPECIAL_EDGEID);
+    BOOST_CHECK_EQUAL(graph.FindEdge(2, 3), SPECIAL_EDGEID);
+    BOOST_CHECK_EQUAL(graph.FindEdge(3, 4), SPECIAL_EDGEID);
+    BOOST_CHECK(graph.FindEdge(0, 4) != SPECIAL_EDGEID);
+}
 
-// BOOST_AUTO_TEST_CASE(loop_test)
-// {
-//     //
-//     // 0---1---2
-//     // |       |
-//     // 5---4---3
-//     //
-//     GraphCompressor compressor;
+BOOST_AUTO_TEST_CASE(loop_test)
+{
+    //
+    // 0---1---2
+    // |       |
+    // 5---4---3
+    //
+    GraphCompressor compressor;
 
-//     std::unordered_set<NodeID> barrier_nodes;
-//     std::unordered_set<NodeID> traffic_lights;
-//     std::vector<TurnRestriction> restrictions;
-//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-//     CompressedEdgeContainer container;
-//     std::vector<NodeBasedEdgeAnnotation> annotations(1);
-//     test::MockScriptingEnvironment scripting_environment;
-//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+    std::unordered_set<NodeID> barrier_nodes;
+    std::unordered_set<NodeID> traffic_lights;
+    std::vector<TurnRestriction> restrictions;
+    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+    CompressedEdgeContainer container;
+    std::vector<NodeBasedEdgeAnnotation> annotations(1);
+    test::MockScriptingEnvironment scripting_environment;
+    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-//     std::vector<InputEdge> edges = {MakeUnitEdge(0, 1),
-//                                     MakeUnitEdge(0, 5),
-//                                     MakeUnitEdge(1, 0),
-//                                     MakeUnitEdge(1, 2),
-//                                     MakeUnitEdge(2, 1),
-//                                     MakeUnitEdge(2, 3),
-//                                     MakeUnitEdge(3, 2),
-//                                     MakeUnitEdge(3, 4),
-//                                     MakeUnitEdge(4, 3),
-//                                     MakeUnitEdge(4, 5),
-//                                     MakeUnitEdge(5, 0),
-//                                     MakeUnitEdge(5, 4)};
+    std::vector<InputEdge> edges = {MakeUnitEdge(0, 1),
+                                    MakeUnitEdge(0, 5),
+                                    MakeUnitEdge(1, 0),
+                                    MakeUnitEdge(1, 2),
+                                    MakeUnitEdge(2, 1),
+                                    MakeUnitEdge(2, 3),
+                                    MakeUnitEdge(3, 2),
+                                    MakeUnitEdge(3, 4),
+                                    MakeUnitEdge(4, 3),
+                                    MakeUnitEdge(4, 5),
+                                    MakeUnitEdge(5, 0),
+                                    MakeUnitEdge(5, 4)};
 
-//     Graph graph(6, edges);
-//     BOOST_CHECK(edges.size() == 12);
-//     BOOST_CHECK(compatible(graph, annotations, 0, 1));
-//     BOOST_CHECK(compatible(graph, annotations, 1, 2));
-//     BOOST_CHECK(compatible(graph, annotations, 2, 3));
-//     BOOST_CHECK(compatible(graph, annotations, 3, 4));
-//     BOOST_CHECK(compatible(graph, annotations, 4, 5));
-//     BOOST_CHECK(compatible(graph, annotations, 5, 6));
-//     BOOST_CHECK(compatible(graph, annotations, 6, 7));
-//     BOOST_CHECK(compatible(graph, annotations, 7, 8));
-//     BOOST_CHECK(compatible(graph, annotations, 8, 9));
-//     BOOST_CHECK(compatible(graph, annotations, 9, 10));
-//     BOOST_CHECK(compatible(graph, annotations, 10, 11));
-//     BOOST_CHECK(compatible(graph, annotations, 11, 0));
+    Graph graph(6, edges);
+    BOOST_CHECK(edges.size() == 12);
+    BOOST_CHECK(compatible(graph, annotations, 0, 1));
+    BOOST_CHECK(compatible(graph, annotations, 1, 2));
+    BOOST_CHECK(compatible(graph, annotations, 2, 3));
+    BOOST_CHECK(compatible(graph, annotations, 3, 4));
+    BOOST_CHECK(compatible(graph, annotations, 4, 5));
+    BOOST_CHECK(compatible(graph, annotations, 5, 6));
+    BOOST_CHECK(compatible(graph, annotations, 6, 7));
+    BOOST_CHECK(compatible(graph, annotations, 7, 8));
+    BOOST_CHECK(compatible(graph, annotations, 8, 9));
+    BOOST_CHECK(compatible(graph, annotations, 9, 10));
+    BOOST_CHECK(compatible(graph, annotations, 10, 11));
+    BOOST_CHECK(compatible(graph, annotations, 11, 0));
 
-//     compressor.Compress(barrier_nodes,
-//                         traffic_lights,
-//                         scripting_environment,
-//                         restrictions,
-//                         conditional_restrictions,
-//                         maneuver_overrides,
-//                         graph,
-//                         annotations,
-//                         container);
+    compressor.Compress(barrier_nodes,
+                        traffic_lights,
+                        scripting_environment,
+                        restrictions,
+                        conditional_restrictions,
+                        maneuver_overrides,
+                        graph,
+                        annotations,
+                        container);
 
-//     BOOST_CHECK_EQUAL(graph.FindEdge(5, 0), SPECIAL_EDGEID);
-//     BOOST_CHECK_EQUAL(graph.FindEdge(0, 1), SPECIAL_EDGEID);
-//     BOOST_CHECK_EQUAL(graph.FindEdge(1, 2), SPECIAL_EDGEID);
-//     BOOST_CHECK_EQUAL(graph.FindEdge(2, 3), SPECIAL_EDGEID);
-//     BOOST_CHECK(graph.FindEdge(5, 3) != SPECIAL_EDGEID);
-//     BOOST_CHECK(graph.FindEdge(3, 4) != SPECIAL_EDGEID);
-//     BOOST_CHECK(graph.FindEdge(4, 5) != SPECIAL_EDGEID);
-// }
+    BOOST_CHECK_EQUAL(graph.FindEdge(5, 0), SPECIAL_EDGEID);
+    BOOST_CHECK_EQUAL(graph.FindEdge(0, 1), SPECIAL_EDGEID);
+    BOOST_CHECK_EQUAL(graph.FindEdge(1, 2), SPECIAL_EDGEID);
+    BOOST_CHECK_EQUAL(graph.FindEdge(2, 3), SPECIAL_EDGEID);
+    BOOST_CHECK(graph.FindEdge(5, 3) != SPECIAL_EDGEID);
+    BOOST_CHECK(graph.FindEdge(3, 4) != SPECIAL_EDGEID);
+    BOOST_CHECK(graph.FindEdge(4, 5) != SPECIAL_EDGEID);
+}
 
-// BOOST_AUTO_TEST_CASE(t_intersection)
-// {
-//     //
-//     // 0---1---2
-//     //     |
-//     //     3
-//     //
-//     GraphCompressor compressor;
+BOOST_AUTO_TEST_CASE(t_intersection)
+{
+    //
+    // 0---1---2
+    //     |
+    //     3
+    //
+    GraphCompressor compressor;
 
-//     std::unordered_set<NodeID> barrier_nodes;
-//     std::unordered_set<NodeID> traffic_lights;
-//     std::vector<NodeBasedEdgeAnnotation> annotations(1);
-//     std::vector<TurnRestriction> restrictions;
-//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-//     CompressedEdgeContainer container;
-//     test::MockScriptingEnvironment scripting_environment;
-//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+    std::unordered_set<NodeID> barrier_nodes;
+    std::unordered_set<NodeID> traffic_lights;
+    std::vector<NodeBasedEdgeAnnotation> annotations(1);
+    std::vector<TurnRestriction> restrictions;
+    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+    CompressedEdgeContainer container;
+    test::MockScriptingEnvironment scripting_environment;
+    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-//     std::vector<InputEdge> edges = {MakeUnitEdge(0, 1),
-//                                     MakeUnitEdge(1, 0),
-//                                     MakeUnitEdge(1, 2),
-//                                     MakeUnitEdge(1, 3),
-//                                     MakeUnitEdge(2, 1),
-//                                     MakeUnitEdge(3, 1)};
+    std::vector<InputEdge> edges = {MakeUnitEdge(0, 1),
+                                    MakeUnitEdge(1, 0),
+                                    MakeUnitEdge(1, 2),
+                                    MakeUnitEdge(1, 3),
+                                    MakeUnitEdge(2, 1),
+                                    MakeUnitEdge(3, 1)};
 
-//     Graph graph(4, edges);
-//     BOOST_CHECK(compatible(graph, annotations, 0, 1));
-//     BOOST_CHECK(compatible(graph, annotations, 1, 2));
-//     BOOST_CHECK(compatible(graph, annotations, 2, 3));
-//     BOOST_CHECK(compatible(graph, annotations, 3, 4));
-//     BOOST_CHECK(compatible(graph, annotations, 4, 5));
+    Graph graph(4, edges);
+    BOOST_CHECK(compatible(graph, annotations, 0, 1));
+    BOOST_CHECK(compatible(graph, annotations, 1, 2));
+    BOOST_CHECK(compatible(graph, annotations, 2, 3));
+    BOOST_CHECK(compatible(graph, annotations, 3, 4));
+    BOOST_CHECK(compatible(graph, annotations, 4, 5));
 
-//     compressor.Compress(barrier_nodes,
-//                         traffic_lights,
-//                         scripting_environment,
-//                         restrictions,
-//                         conditional_restrictions,
-//                         maneuver_overrides,
-//                         graph,
-//                         annotations,
-//                         container);
+    compressor.Compress(barrier_nodes,
+                        traffic_lights,
+                        scripting_environment,
+                        restrictions,
+                        conditional_restrictions,
+                        maneuver_overrides,
+                        graph,
+                        annotations,
+                        container);
 
-//     BOOST_CHECK(graph.FindEdge(0, 1) != SPECIAL_EDGEID);
-//     BOOST_CHECK(graph.FindEdge(1, 2) != SPECIAL_EDGEID);
-//     BOOST_CHECK(graph.FindEdge(1, 3) != SPECIAL_EDGEID);
-// }
+    BOOST_CHECK(graph.FindEdge(0, 1) != SPECIAL_EDGEID);
+    BOOST_CHECK(graph.FindEdge(1, 2) != SPECIAL_EDGEID);
+    BOOST_CHECK(graph.FindEdge(1, 3) != SPECIAL_EDGEID);
+}
 
-// BOOST_AUTO_TEST_CASE(street_name_changes)
-// {
-//     //
-//     // 0---1---2
-//     //
-//     GraphCompressor compressor;
+BOOST_AUTO_TEST_CASE(street_name_changes)
+{
+    //
+    // 0---1---2
+    //
+    GraphCompressor compressor;
 
-//     std::unordered_set<NodeID> barrier_nodes;
-//     std::unordered_set<NodeID> traffic_lights;
-//     std::vector<NodeBasedEdgeAnnotation> annotations(2);
-//     std::vector<TurnRestriction> restrictions;
-//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-//     CompressedEdgeContainer container;
-//     test::MockScriptingEnvironment scripting_environment;
-//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+    std::unordered_set<NodeID> barrier_nodes;
+    std::unordered_set<NodeID> traffic_lights;
+    std::vector<NodeBasedEdgeAnnotation> annotations(2);
+    std::vector<TurnRestriction> restrictions;
+    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+    CompressedEdgeContainer container;
+    test::MockScriptingEnvironment scripting_environment;
+    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-//     std::vector<InputEdge> edges = {
-//         MakeUnitEdge(0, 1), MakeUnitEdge(1, 0), MakeUnitEdge(1, 2), MakeUnitEdge(2, 1)};
+    std::vector<InputEdge> edges = {
+        MakeUnitEdge(0, 1), MakeUnitEdge(1, 0), MakeUnitEdge(1, 2), MakeUnitEdge(2, 1)};
 
-//     annotations[1].name_id = 1;
-//     edges[2].data.annotation_data = edges[3].data.annotation_data = 1;
+    annotations[1].name_id = 1;
+    edges[2].data.annotation_data = edges[3].data.annotation_data = 1;
 
-//     Graph graph(5, edges);
-//     BOOST_CHECK(compatible(graph, annotations, 0, 1));
-//     BOOST_CHECK(compatible(graph, annotations, 2, 3));
+    Graph graph(5, edges);
+    BOOST_CHECK(compatible(graph, annotations, 0, 1));
+    BOOST_CHECK(compatible(graph, annotations, 2, 3));
 
-//     compressor.Compress(barrier_nodes,
-//                         traffic_lights,
-//                         scripting_environment,
-//                         restrictions,
-//                         conditional_restrictions,
-//                         maneuver_overrides,
-//                         graph,
-//                         annotations,
-//                         container);
+    compressor.Compress(barrier_nodes,
+                        traffic_lights,
+                        scripting_environment,
+                        restrictions,
+                        conditional_restrictions,
+                        maneuver_overrides,
+                        graph,
+                        annotations,
+                        container);
 
-//     BOOST_CHECK(graph.FindEdge(0, 1) != SPECIAL_EDGEID);
-//     BOOST_CHECK(graph.FindEdge(1, 2) != SPECIAL_EDGEID);
-// }
+    BOOST_CHECK(graph.FindEdge(0, 1) != SPECIAL_EDGEID);
+    BOOST_CHECK(graph.FindEdge(1, 2) != SPECIAL_EDGEID);
+}
 
-// BOOST_AUTO_TEST_CASE(direction_changes)
-// {
-//     //
-//     // 0-->1---2
-//     //
-//     GraphCompressor compressor;
+BOOST_AUTO_TEST_CASE(direction_changes)
+{
+    //
+    // 0-->1---2
+    //
+    GraphCompressor compressor;
 
-//     std::unordered_set<NodeID> barrier_nodes;
-//     std::unordered_set<NodeID> traffic_lights;
-//     std::vector<NodeBasedEdgeAnnotation> annotations(1);
-//     std::vector<TurnRestriction> restrictions;
-//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-//     CompressedEdgeContainer container;
-//     test::MockScriptingEnvironment scripting_environment;
-//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+    std::unordered_set<NodeID> barrier_nodes;
+    std::unordered_set<NodeID> traffic_lights;
+    std::vector<NodeBasedEdgeAnnotation> annotations(1);
+    std::vector<TurnRestriction> restrictions;
+    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+    CompressedEdgeContainer container;
+    test::MockScriptingEnvironment scripting_environment;
+    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-//     std::vector<InputEdge> edges = {
-//         MakeUnitEdge(0, 1), MakeUnitEdge(1, 0), MakeUnitEdge(1, 2), MakeUnitEdge(2, 1)};
-//     // make first edge point forward
-//     edges[1].data.reversed = true;
+    std::vector<InputEdge> edges = {
+        MakeUnitEdge(0, 1), MakeUnitEdge(1, 0), MakeUnitEdge(1, 2), MakeUnitEdge(2, 1)};
+    // make first edge point forward
+    edges[1].data.reversed = true;
 
-//     Graph graph(5, edges);
-//     compressor.Compress(barrier_nodes,
-//                         traffic_lights,
-//                         scripting_environment,
-//                         restrictions,
-//                         conditional_restrictions,
-//                         maneuver_overrides,
-//                         graph,
-//                         annotations,
-//                         container);
+    Graph graph(5, edges);
+    compressor.Compress(barrier_nodes,
+                        traffic_lights,
+                        scripting_environment,
+                        restrictions,
+                        conditional_restrictions,
+                        maneuver_overrides,
+                        graph,
+                        annotations,
+                        container);
 
-//     BOOST_CHECK(graph.FindEdge(0, 1) != SPECIAL_EDGEID);
-//     BOOST_CHECK(graph.FindEdge(1, 2) != SPECIAL_EDGEID);
-// }
+    BOOST_CHECK(graph.FindEdge(0, 1) != SPECIAL_EDGEID);
+    BOOST_CHECK(graph.FindEdge(1, 2) != SPECIAL_EDGEID);
+}
 
-// BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_SUITE_END()

unit_tests/extractor/intersection_analysis_tests.cpp

@@ -1,4 +1,4 @@
-// #include "extractor/intersection/intersection_analysis.hpp"
+#include "extractor/intersection/intersection_analysis.hpp"
 
 #include "extractor/graph_compressor.hpp"
 
@@ -17,306 +17,305 @@ using namespace osrm::extractor::intersection;
 using InputEdge = util::NodeBasedDynamicGraph::InputEdge;
 using Graph = util::NodeBasedDynamicGraph;
 
-// BOOST_AUTO_TEST_CASE(simple_intersection_connectivity)
-// {
-//     std::unordered_set<NodeID> barrier_nodes{6};
-//     std::unordered_set<NodeID> traffic_lights;
-//     std::vector<NodeBasedEdgeAnnotation> annotations{
-//         {EMPTY_NAMEID, 0, INAVLID_CLASS_DATA, TRAVEL_MODE_DRIVING, false},
-//         {EMPTY_NAMEID, 1, INAVLID_CLASS_DATA, TRAVEL_MODE_DRIVING, false}};
-//     std::vector<TurnRestriction> restrictions{TurnRestriction{NodeRestriction{0, 2, 1}, false}};
-//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-//     CompressedEdgeContainer container;
-//     test::MockScriptingEnvironment scripting_environment;
-//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+BOOST_AUTO_TEST_CASE(simple_intersection_connectivity)
+{
+    std::unordered_set<NodeID> barrier_nodes{6};
+    std::unordered_set<NodeID> traffic_lights;
+    std::vector<NodeBasedEdgeAnnotation> annotations{
+        {EMPTY_NAMEID, 0, INAVLID_CLASS_DATA, TRAVEL_MODE_DRIVING, false},
+        {EMPTY_NAMEID, 1, INAVLID_CLASS_DATA, TRAVEL_MODE_DRIVING, false}};
+    std::vector<TurnRestriction> restrictions{TurnRestriction{NodeRestriction{0, 2, 1}, false}};
+    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+    CompressedEdgeContainer container;
+    test::MockScriptingEnvironment scripting_environment;
+    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-//     TurnLanesIndexedArray turn_lanes_data{{0, 0, 3},
-//                                           {TurnLaneType::uturn | TurnLaneType::left,
-//                                            TurnLaneType::straight,
-//                                            TurnLaneType::straight | TurnLaneType::right}};
+    TurnLanesIndexedArray turn_lanes_data{{0, 0, 3},
+                                          {TurnLaneType::uturn | TurnLaneType::left,
+                                           TurnLaneType::straight,
+                                           TurnLaneType::straight | TurnLaneType::right}};
 
-//     // Graph with an additional turn restriction 0→2→1 and bollard at 6
-//     //   0→5↔6↔7
-//     //   ↕
-//     // 1↔2←3
-//     //   ↓
-//     //   4
-//     const auto unit_edge =
-//         [](const NodeID from, const NodeID to, bool allowed, AnnotationID annotation) {
-//             return InputEdge{from,
-//                              to,
-//                              1,
-//                              1,
-//                              GeometryID{0, false},
-//                              !allowed,
-//                              NodeBasedEdgeClassification(),
-//                              annotation};
-//         };
+    // Graph with an additional turn restriction 0→2→1 and bollard at 6
+    //   0→5↔6↔7
+    //   ↕
+    // 1↔2←3
+    //   ↓
+    //   4
+    const auto unit_edge =
+        [](const NodeID from, const NodeID to, bool allowed, AnnotationID annotation) {
+            return InputEdge{from,
+                             to,
+                             1,
+                             1,
+                             GeometryID{0, false},
+                             !allowed,
+                             NodeBasedEdgeClassification(),
+                             annotation};
+        };
 
-//     std::vector<InputEdge> edges = {unit_edge(0, 2, true, 1),
-//                                     unit_edge(0, 5, true, 0),
-//                                     unit_edge(1, 2, true, 0),
-//                                     unit_edge(2, 0, true, 0),
-//                                     unit_edge(2, 1, true, 0),
-//                                     unit_edge(2, 3, false, 0),
-//                                     unit_edge(2, 4, true, 0),
-//                                     unit_edge(3, 2, true, 0),
-//                                     unit_edge(4, 2, false, 0),
-//                                     unit_edge(5, 0, false, 0),
-//                                     unit_edge(5, 6, true, 0),
-//                                     unit_edge(6, 5, true, 0),
-//                                     unit_edge(6, 7, true, 0),
-//                                     unit_edge(7, 6, true, 0)};
-//     IntersectionEdgeGeometries edge_geometries{
-//         {0, 180, 180, 10.},  // 0→2
-//         {1, 90, 90, 10.},    // 0→5
-//         {2, 90, 90, 10.},    // 1→2
-//         {3, 0, 0, 10.},      // 2→0
-//         {4, 270, 270, 10.},  // 2→1
-//         {5, 90, 90, 10.},    // 2→3
-//         {6, 180, 180, 10.},  // 2→4
-//         {7, 270, 270, 10.},  // 3→2
-//         {8, 0, 0, 10.},      // 4→2
-//         {9, 270, 270, 10.},  // 5→0
-//         {10, 90, 90, 10.},   // 5→6
-//         {11, 270, 270, 10.}, // 6→5
-//         {12, 90, 90, 10.},   // 6→7
-//         {13, 270, 270, 10.}  // 7→6
-//     };
+    std::vector<InputEdge> edges = {unit_edge(0, 2, true, 1),
+                                    unit_edge(0, 5, true, 0),
+                                    unit_edge(1, 2, true, 0),
+                                    unit_edge(2, 0, true, 0),
+                                    unit_edge(2, 1, true, 0),
+                                    unit_edge(2, 3, false, 0),
+                                    unit_edge(2, 4, true, 0),
+                                    unit_edge(3, 2, true, 0),
+                                    unit_edge(4, 2, false, 0),
+                                    unit_edge(5, 0, false, 0),
+                                    unit_edge(5, 6, true, 0),
+                                    unit_edge(6, 5, true, 0),
+                                    unit_edge(6, 7, true, 0),
+                                    unit_edge(7, 6, true, 0)};
+    IntersectionEdgeGeometries edge_geometries{
+        {0, 180, 180, 10.},  // 0→2
+        {1, 90, 90, 10.},    // 0→5
+        {2, 90, 90, 10.},    // 1→2
+        {3, 0, 0, 10.},      // 2→0
+        {4, 270, 270, 10.},  // 2→1
+        {5, 90, 90, 10.},    // 2→3
+        {6, 180, 180, 10.},  // 2→4
+        {7, 270, 270, 10.},  // 3→2
+        {8, 0, 0, 10.},      // 4→2
+        {9, 270, 270, 10.},  // 5→0
+        {10, 90, 90, 10.},   // 5→6
+        {11, 270, 270, 10.}, // 6→5
+        {12, 90, 90, 10.},   // 6→7
+        {13, 270, 270, 10.}  // 7→6
+    };
 
-//     Graph graph(8, edges);
+    Graph graph(8, edges);
 
-//     GraphCompressor().Compress(barrier_nodes,
-//                                traffic_lights,
-//                                scripting_environment,
-//                                restrictions,
-//                                conditional_restrictions,
-//                                maneuver_overrides,
-//                                graph,
-//                                annotations,
-//                                container);
+    GraphCompressor().Compress(barrier_nodes,
+                               traffic_lights,
+                               scripting_environment,
+                               restrictions,
+                               conditional_restrictions,
+                               maneuver_overrides,
+                               graph,
+                               annotations,
+                               container);
 
-//     REQUIRE_SIZE_RANGE(getIncomingEdges(graph, 2), 3);
-//     REQUIRE_SIZE_RANGE(getOutgoingEdges(graph, 2), 4);
+    REQUIRE_SIZE_RANGE(getIncomingEdges(graph, 2), 3);
+    REQUIRE_SIZE_RANGE(getOutgoingEdges(graph, 2), 4);
 
-//     EdgeBasedNodeDataContainer node_data_container(
-//         std::vector<EdgeBasedNode>(graph.GetNumberOfEdges()), annotations);
-//     RestrictionMap restriction_map(restrictions, IndexNodeByFromAndVia());
+    EdgeBasedNodeDataContainer node_data_container(
+        std::vector<EdgeBasedNode>(graph.GetNumberOfEdges()), annotations);
+    RestrictionMap restriction_map(restrictions, IndexNodeByFromAndVia());
 
-//     const auto connectivity_matrix = [&](NodeID node) {
-//         std::vector<bool> result;
-//         const auto incoming_edges = getIncomingEdges(graph, node);
-//         const auto outgoing_edges = getOutgoingEdges(graph, node);
-//         for (const auto incoming_edge : incoming_edges)
-//         {
-//             for (const auto outgoing_edge : outgoing_edges)
-//             {
-//                 result.push_back(isTurnAllowed(graph,
-//                                                node_data_container,
-//                                                restriction_map,
-//                                                barrier_nodes,
-//                                                edge_geometries,
-//                                                turn_lanes_data,
-//                                                incoming_edge,
-//                                                outgoing_edge));
-//             }
-//         }
-//         return result;
-//     };
+    const auto connectivity_matrix = [&](NodeID node) {
+        std::vector<bool> result;
+        const auto incoming_edges = getIncomingEdges(graph, node);
+        const auto outgoing_edges = getOutgoingEdges(graph, node);
+        for (const auto incoming_edge : incoming_edges)
+        {
+            for (const auto outgoing_edge : outgoing_edges)
+            {
+                result.push_back(isTurnAllowed(graph,
+                                               node_data_container,
+                                               restriction_map,
+                                               barrier_nodes,
+                                               edge_geometries,
+                                               turn_lanes_data,
+                                               incoming_edge,
+                                               outgoing_edge));
+            }
+        }
+        return result;
+    };
 
-//     CHECK_EQUAL_RANGE(connectivity_matrix(0), 1, 1); // from node 2 allowed U-turn and to node 5
-//     CHECK_EQUAL_RANGE(connectivity_matrix(1), 1);    // from node 2 allowed U-turn
-//     CHECK_EQUAL_RANGE(connectivity_matrix(2),
-//                       // clang-format off
-//                       1, 0, 0, 1, // from node 0 to node 4 and a U-turn at 2
-//                       1, 0, 0, 1, // from node 1 to nodes 0 and 4
-//                       1, 1, 0, 1  // from node 3 to nodes 0, 1 and 4
-//                       // clang-format on
-//                       );
-//     REQUIRE_SIZE_RANGE(connectivity_matrix(3), 0); // no incoming edges, empty matrix
-//     CHECK_EQUAL_RANGE(connectivity_matrix(4), 0);  // from node 2 not allowed U-turn
-//     CHECK_EQUAL_RANGE(connectivity_matrix(5),
-//                       // clang-format off
-//                       0, 1, // from node 0 to node 6
-//                       0, 1, // from node 6 a U-turn to node 6
-//                       // clang-format on
-//                       );
+    CHECK_EQUAL_RANGE(connectivity_matrix(0), 1, 1); // from node 2 allowed U-turn and to node 5
+    CHECK_EQUAL_RANGE(connectivity_matrix(1), 1);    // from node 2 allowed U-turn
+    CHECK_EQUAL_RANGE(connectivity_matrix(2),
+                      // clang-format off
+                      1, 0, 0, 1, // from node 0 to node 4 and a U-turn at 2
+                      1, 0, 0, 1, // from node 1 to nodes 0 and 4
+                      1, 1, 0, 1  // from node 3 to nodes 0, 1 and 4
+                      // clang-format on
+                      );
+    REQUIRE_SIZE_RANGE(connectivity_matrix(3), 0); // no incoming edges, empty matrix
+    CHECK_EQUAL_RANGE(connectivity_matrix(4), 0);  // from node 2 not allowed U-turn
+    CHECK_EQUAL_RANGE(connectivity_matrix(5),
+                      // clang-format off
+                      0, 1, // from node 0 to node 6
+                      0, 1, // from node 6 a U-turn to node 6
+                      // clang-format on
+                      );
 
-//     CHECK_EQUAL_RANGE(connectivity_matrix(6),
-//                       // clang-format off
-//                       1, 0, // from node 5 a U-turn to node 5
-//                       0, 1, // from node 7 a U-turn to node 7
-//                       // clang-format on
-//                       );
-// }
+    CHECK_EQUAL_RANGE(connectivity_matrix(6),
+                      // clang-format off
+                      1, 0, // from node 5 a U-turn to node 5
+                      0, 1, // from node 7 a U-turn to node 7
+                      // clang-format on
+                      );
+}
 
-// BOOST_AUTO_TEST_CASE(roundabout_intersection_connectivity)
-// {
-//     std::unordered_set<NodeID> barrier_nodes;
-//     std::unordered_set<NodeID> traffic_lights;
-//     std::vector<NodeBasedEdgeAnnotation> annotations;
-//     std::vector<TurnRestriction> restrictions;
-//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-//     CompressedEdgeContainer container;
-//     test::MockScriptingEnvironment scripting_environment;
-//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+BOOST_AUTO_TEST_CASE(roundabout_intersection_connectivity)
+{
+    std::unordered_set<NodeID> barrier_nodes;
+    std::unordered_set<NodeID> traffic_lights;
+    std::vector<NodeBasedEdgeAnnotation> annotations;
+    std::vector<TurnRestriction> restrictions;
+    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+    CompressedEdgeContainer container;
+    test::MockScriptingEnvironment scripting_environment;
+    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-//     TurnLanesIndexedArray turn_lanes_data;
+    TurnLanesIndexedArray turn_lanes_data;
 
-//     // Graph with roundabout edges 5→0→2
-//     //  1  2  3
-//     //   ↘ ↑ ↙
-//     //     0
-//     //   ↙ ↑ ↘
-//     //  4  5  6
-//     const auto unit_edge = [](const NodeID from, const NodeID to, bool allowed, bool roundabout)
-//     {
-//         return InputEdge{from,
-//                          to,
-//                          1,
-//                          1,
-//                          GeometryID{0, false},
-//                          !allowed,
-//                          NodeBasedEdgeClassification{
-//                              true, false, false, roundabout, false, false, false, {}, 0, 0},
-//                          0};
-//     };
-//     std::vector<InputEdge> edges = {unit_edge(0, 1, false, false),
-//                                     unit_edge(0, 2, true, true),
-//                                     unit_edge(0, 3, false, false),
-//                                     unit_edge(0, 4, true, false),
-//                                     unit_edge(0, 5, false, true),
-//                                     unit_edge(0, 6, true, false),
-//                                     unit_edge(1, 0, true, false),
-//                                     unit_edge(2, 0, false, true),
-//                                     unit_edge(3, 0, true, false),
-//                                     unit_edge(4, 0, false, false),
-//                                     unit_edge(5, 0, true, true),
-//                                     unit_edge(6, 0, false, false)};
-//     IntersectionEdgeGeometries edge_geometries{
-//         {0, 315, 315, 10}, // 0→1
-//         {1, 0, 0, 10},     // 0→2
-//         {2, 45, 45, 10},   // 0→3
-//         {3, 225, 225, 10}, // 0→4
-//         {4, 180, 180, 10}, // 0→5
-//         {5, 135, 135, 10}, // 0→6
-//         {6, 135, 135, 10}, // 1→0
-//         {7, 180, 180, 10}, // 2→0
-//         {8, 225, 225, 10}, // 3→0
-//         {9, 45, 45, 10},   // 4→0
-//         {10, 0, 0, 10},    // 5→0
-//         {11, 315, 315, 10} // 6→0
-//     };
+    // Graph with roundabout edges 5→0→2
+    //  1  2  3
+    //   ↘ ↑ ↙
+    //     0
+    //   ↙ ↑ ↘
+    //  4  5  6
+    const auto unit_edge = [](const NodeID from, const NodeID to, bool allowed, bool roundabout) {
+        return InputEdge{from,
+                         to,
+                         1,
+                         1,
+                         GeometryID{0, false},
+                         !allowed,
+                         NodeBasedEdgeClassification{
+                             true, false, false, roundabout, false, false, false, {}, 0, 0},
+                         0};
+    };
+    std::vector<InputEdge> edges = {unit_edge(0, 1, false, false),
+                                    unit_edge(0, 2, true, true),
+                                    unit_edge(0, 3, false, false),
+                                    unit_edge(0, 4, true, false),
+                                    unit_edge(0, 5, false, true),
+                                    unit_edge(0, 6, true, false),
+                                    unit_edge(1, 0, true, false),
+                                    unit_edge(2, 0, false, true),
+                                    unit_edge(3, 0, true, false),
+                                    unit_edge(4, 0, false, false),
+                                    unit_edge(5, 0, true, true),
+                                    unit_edge(6, 0, false, false)};
+    IntersectionEdgeGeometries edge_geometries{
+        {0, 315, 315, 10}, // 0→1
+        {1, 0, 0, 10},     // 0→2
+        {2, 45, 45, 10},   // 0→3
+        {3, 225, 225, 10}, // 0→4
+        {4, 180, 180, 10}, // 0→5
+        {5, 135, 135, 10}, // 0→6
+        {6, 135, 135, 10}, // 1→0
+        {7, 180, 180, 10}, // 2→0
+        {8, 225, 225, 10}, // 3→0
+        {9, 45, 45, 10},   // 4→0
+        {10, 0, 0, 10},    // 5→0
+        {11, 315, 315, 10} // 6→0
+    };
 
-//     Graph graph(7, edges);
+    Graph graph(7, edges);
 
-//     GraphCompressor().Compress(barrier_nodes,
-//                                traffic_lights,
-//                                scripting_environment,
-//                                restrictions,
-//                                conditional_restrictions,
-//                                maneuver_overrides,
-//                                graph,
-//                                annotations,
-//                                container);
+    GraphCompressor().Compress(barrier_nodes,
+                               traffic_lights,
+                               scripting_environment,
+                               restrictions,
+                               conditional_restrictions,
+                               maneuver_overrides,
+                               graph,
+                               annotations,
+                               container);
 
-//     REQUIRE_SIZE_RANGE(getIncomingEdges(graph, 0), 3);
-//     REQUIRE_SIZE_RANGE(getOutgoingEdges(graph, 0), 6);
+    REQUIRE_SIZE_RANGE(getIncomingEdges(graph, 0), 3);
+    REQUIRE_SIZE_RANGE(getOutgoingEdges(graph, 0), 6);
 
-//     EdgeBasedNodeDataContainer node_data_container(
-//         std::vector<EdgeBasedNode>(graph.GetNumberOfEdges()), annotations);
-//     RestrictionMap restriction_map(restrictions, IndexNodeByFromAndVia());
+    EdgeBasedNodeDataContainer node_data_container(
+        std::vector<EdgeBasedNode>(graph.GetNumberOfEdges()), annotations);
+    RestrictionMap restriction_map(restrictions, IndexNodeByFromAndVia());
 
-//     const auto connectivity_matrix = [&](NodeID node) {
-//         std::vector<bool> result;
-//         const auto incoming_edges = getIncomingEdges(graph, node);
-//         const auto outgoing_edges = getOutgoingEdges(graph, node);
-//         for (const auto incoming_edge : incoming_edges)
-//         {
-//             for (const auto outgoing_edge : outgoing_edges)
-//             {
-//                 result.push_back(isTurnAllowed(graph,
-//                                                node_data_container,
-//                                                restriction_map,
-//                                                barrier_nodes,
-//                                                edge_geometries,
-//                                                turn_lanes_data,
-//                                                incoming_edge,
-//                                                outgoing_edge));
-//             }
-//         }
-//         return result;
-//     };
+    const auto connectivity_matrix = [&](NodeID node) {
+        std::vector<bool> result;
+        const auto incoming_edges = getIncomingEdges(graph, node);
+        const auto outgoing_edges = getOutgoingEdges(graph, node);
+        for (const auto incoming_edge : incoming_edges)
+        {
+            for (const auto outgoing_edge : outgoing_edges)
+            {
+                result.push_back(isTurnAllowed(graph,
+                                               node_data_container,
+                                               restriction_map,
+                                               barrier_nodes,
+                                               edge_geometries,
+                                               turn_lanes_data,
+                                               incoming_edge,
+                                               outgoing_edge));
+            }
+        }
+        return result;
+    };
 
-//     CHECK_EQUAL_RANGE(connectivity_matrix(0),
-//                       // clang-format off
-//                       0, 1, 0, 0, 0, 1, // from node 1 to nodes 2 and 6
-//                       0, 1, 0, 1, 0, 0, // from node 3 to nodes 2 and 4
-//                       0, 1, 0, 1, 0, 1  // from node 5 to nodes 2, 4 and 6
-//                       // clang-format on
-//                       );
-// }
+    CHECK_EQUAL_RANGE(connectivity_matrix(0),
+                      // clang-format off
+                      0, 1, 0, 0, 0, 1, // from node 1 to nodes 2 and 6
+                      0, 1, 0, 1, 0, 0, // from node 3 to nodes 2 and 4
+                      0, 1, 0, 1, 0, 1  // from node 5 to nodes 2, 4 and 6
+                      // clang-format on
+                      );
+}
 
-// BOOST_AUTO_TEST_CASE(skip_degree_two_nodes)
-// {
-//     std::unordered_set<NodeID> barrier_nodes{1};
-//     std::unordered_set<NodeID> traffic_lights{2};
-//     std::vector<NodeBasedEdgeAnnotation> annotations(1);
-//     std::vector<TurnRestriction> restrictions;
-//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-//     CompressedEdgeContainer container;
-//     test::MockScriptingEnvironment scripting_environment;
-//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+BOOST_AUTO_TEST_CASE(skip_degree_two_nodes)
+{
+    std::unordered_set<NodeID> barrier_nodes{1};
+    std::unordered_set<NodeID> traffic_lights{2};
+    std::vector<NodeBasedEdgeAnnotation> annotations(1);
+    std::vector<TurnRestriction> restrictions;
+    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+    CompressedEdgeContainer container;
+    test::MockScriptingEnvironment scripting_environment;
+    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-//     TurnLanesIndexedArray turn_lanes_data;
+    TurnLanesIndexedArray turn_lanes_data;
 
-//     // Graph
-//     //
-//     //  0↔1→2↔3↔4→5         7
-//     //          ↑          ↕ ↕
-//     //          6         8 ↔ 9
-//     //
-//     const auto unit_edge = [](const NodeID from, const NodeID to, bool allowed) {
-//         return InputEdge{
-//             from, to, 1, 1, GeometryID{0, false}, !allowed, NodeBasedEdgeClassification{}, 0};
-//     };
-//     std::vector<InputEdge> edges = {unit_edge(0, 1, true), // 0
-//                                     unit_edge(1, 0, true),
-//                                     unit_edge(1, 2, true),
-//                                     unit_edge(2, 1, false),
-//                                     unit_edge(2, 3, true),
-//                                     unit_edge(3, 2, true), // 5
-//                                     unit_edge(3, 4, true),
-//                                     unit_edge(4, 3, true),
-//                                     unit_edge(4, 5, true),
-//                                     unit_edge(4, 6, false),
-//                                     unit_edge(5, 4, false), // 10
-//                                     unit_edge(6, 4, true),
-//                                     // Circle
-//                                     unit_edge(7, 8, true), // 12
-//                                     unit_edge(7, 9, true),
-//                                     unit_edge(8, 7, true),
-//                                     unit_edge(8, 9, true),
-//                                     unit_edge(9, 7, true),
-//                                     unit_edge(9, 8, true)};
+    // Graph
+    //
+    //  0↔1→2↔3↔4→5         7
+    //          ↑          ↕ ↕
+    //          6         8 ↔ 9
+    //
+    const auto unit_edge = [](const NodeID from, const NodeID to, bool allowed) {
+        return InputEdge{
+            from, to, 1, 1, GeometryID{0, false}, !allowed, NodeBasedEdgeClassification{}, 0};
+    };
+    std::vector<InputEdge> edges = {unit_edge(0, 1, true), // 0
+                                    unit_edge(1, 0, true),
+                                    unit_edge(1, 2, true),
+                                    unit_edge(2, 1, false),
+                                    unit_edge(2, 3, true),
+                                    unit_edge(3, 2, true), // 5
+                                    unit_edge(3, 4, true),
+                                    unit_edge(4, 3, true),
+                                    unit_edge(4, 5, true),
+                                    unit_edge(4, 6, false),
+                                    unit_edge(5, 4, false), // 10
+                                    unit_edge(6, 4, true),
+                                    // Circle
+                                    unit_edge(7, 8, true), // 12
+                                    unit_edge(7, 9, true),
+                                    unit_edge(8, 7, true),
+                                    unit_edge(8, 9, true),
+                                    unit_edge(9, 7, true),
+                                    unit_edge(9, 8, true)};
 
-//     Graph graph(10, edges);
+    Graph graph(10, edges);
 
-//     GraphCompressor().Compress(barrier_nodes,
-//                                traffic_lights,
-//                                scripting_environment,
-//                                restrictions,
-//                                conditional_restrictions,
-//                                maneuver_overrides,
-//                                graph,
-//                                annotations,
-//                                container);
+    GraphCompressor().Compress(barrier_nodes,
+                               traffic_lights,
+                               scripting_environment,
+                               restrictions,
+                               conditional_restrictions,
+                               maneuver_overrides,
+                               graph,
+                               annotations,
+                               container);
 
-//     BOOST_CHECK_EQUAL(graph.GetTarget(skipDegreeTwoNodes(graph, {0, 0}).edge), 4);
-//     BOOST_CHECK_EQUAL(graph.GetTarget(skipDegreeTwoNodes(graph, {4, 7}).edge), 0);
-//     BOOST_CHECK_EQUAL(graph.GetTarget(skipDegreeTwoNodes(graph, {5, 10}).edge), 4);
-//     BOOST_CHECK_EQUAL(graph.GetTarget(skipDegreeTwoNodes(graph, {6, 11}).edge), 4);
-//     BOOST_CHECK_EQUAL(graph.GetTarget(skipDegreeTwoNodes(graph, {7, 12}).edge), 7);
-// }
+    BOOST_CHECK_EQUAL(graph.GetTarget(skipDegreeTwoNodes(graph, {0, 0}).edge), 4);
+    BOOST_CHECK_EQUAL(graph.GetTarget(skipDegreeTwoNodes(graph, {4, 7}).edge), 0);
+    BOOST_CHECK_EQUAL(graph.GetTarget(skipDegreeTwoNodes(graph, {5, 10}).edge), 4);
+    BOOST_CHECK_EQUAL(graph.GetTarget(skipDegreeTwoNodes(graph, {6, 11}).edge), 4);
+    BOOST_CHECK_EQUAL(graph.GetTarget(skipDegreeTwoNodes(graph, {7, 12}).edge), 7);
+}
 
 BOOST_AUTO_TEST_SUITE_END()

unit_tests/library/extract.cpp

@@ -16,13 +16,13 @@ BOOST_AUTO_TEST_CASE(test_extract_with_invalid_config)
                       std::exception); // including osrm::util::exception, osmium::io_error, etc.
 }
 
-// BOOST_AUTO_TEST_CASE(test_extract_with_valid_config)
-// {
-//     osrm::ExtractorConfig config;
-//     config.input_path = OSRM_TEST_DATA_DIR "/monaco.osm.pbf";
-//     config.UseDefaultOutputNames(OSRM_TEST_DATA_DIR "/monaco.osm.pbf");
-//     config.requested_num_threads = tbb::task_scheduler_init::default_num_threads();
-//     BOOST_CHECK_NO_THROW(osrm::extract(config));
-// }
+BOOST_AUTO_TEST_CASE(test_extract_with_valid_config)
+{
+    osrm::ExtractorConfig config;
+    config.input_path = OSRM_TEST_DATA_DIR "/monaco.osm.pbf";
+    config.UseDefaultOutputNames(OSRM_TEST_DATA_DIR "/monaco.osm.pbf");
+    config.requested_num_threads = tbb::task_scheduler_init::default_num_threads();
+    BOOST_CHECK_NO_THROW(osrm::extract(config));
+}
 
 BOOST_AUTO_TEST_SUITE_END()

unit_tests/partitioner/renumber.cpp

@@ -32,9 +32,9 @@ auto makeGraph(const std::vector<MockEdge> &mock_edges)
         max_id = std::max<std::size_t>(max_id, std::max(m.start, m.target));
 
         edges.push_back(InputEdge{
-            m.start, m.target, EdgeBasedGraphEdgeData{SPECIAL_NODEID, 1, 1, 1, true, false}});
+            m.start, m.target, EdgeBasedGraphEdgeData{SPECIAL_NODEID, 1, 1, true, false}});
         edges.push_back(InputEdge{
-            m.target, m.start, EdgeBasedGraphEdgeData{SPECIAL_NODEID, 1, 1, 1, false, true}});
+            m.target, m.start, EdgeBasedGraphEdgeData{SPECIAL_NODEID, 1, 1, false, true}});
     }
     std::sort(edges.begin(), edges.end());
     return DynamicEdgeBasedGraph(max_id + 1, edges);

unit_tests/updater/timezoner.cpp

@@ -12,50 +12,46 @@ using namespace osrm::updater;
 
 BOOST_AUTO_TEST_CASE(timezoner_test)
 {
-    // const char json[] =
-    //     "{ \"type\" : \"FeatureCollection\", \"features\": ["
-    //     "{ \"type\" : \"Feature\","
-    //     "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\":
-    //     \"polygon\", "
-    //     "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-    //     "48.88277], [8.57757, 49.07206], [8.28369, "
-    //     "49.07206], [8.28369, 48.88277]]] }} ]}";
-    // std::time_t now = time(0);
-    // BOOST_CHECK_NO_THROW(Timezoner tz(json, now));
+    const char json[] =
+        "{ \"type\" : \"FeatureCollection\", \"features\": ["
+        "{ \"type\" : \"Feature\","
+        "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\": \"polygon\", "
+        "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+        "48.88277], [8.57757, 49.07206], [8.28369, "
+        "49.07206], [8.28369, 48.88277]]] }} ]}";
+    std::time_t now = time(0);
+    BOOST_CHECK_NO_THROW(Timezoner tz(json, now));
 
-    // boost::filesystem::path test_path(TEST_DATA_DIR "/test.geojson");
-    // BOOST_CHECK_NO_THROW(Timezoner tz(test_path, now));
+    boost::filesystem::path test_path(TEST_DATA_DIR "/test.geojson");
+    BOOST_CHECK_NO_THROW(Timezoner tz(test_path, now));
 
     // missing opening bracket
-    // const char bad[] =
-    //     "\"type\" : \"FeatureCollection\", \"features\": ["
-    //     "{ \"type\" : \"Feature\","
-    //     "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\":
-    //     \"polygon\", "
-    //     "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-    //     "48.88277], [8.57757, 49.07206], [8.28369, "
-    //     "49.07206], [8.28369, 48.88277]]] }} ]}";
-    // BOOST_CHECK_THROW(Timezoner tz(bad, now), util::exception);
+    const char bad[] =
+        "\"type\" : \"FeatureCollection\", \"features\": ["
+        "{ \"type\" : \"Feature\","
+        "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\": \"polygon\", "
+        "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+        "48.88277], [8.57757, 49.07206], [8.28369, "
+        "49.07206], [8.28369, 48.88277]]] }} ]}";
+    BOOST_CHECK_THROW(Timezoner tz(bad, now), util::exception);
 
     // missing/malformed FeatureCollection type field
-    // const char missing_type[] =
-    //     "{ \"FeatureCollection\", \"features\": ["
-    //     "{ \"type\" : \"Feature\","
-    //     "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\":
-    //     \"polygon\", "
-    //     "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-    //     "48.88277], [8.57757, 49.07206], [8.28369, "
-    //     "49.07206], [8.28369, 48.88277]]] }} ]}";
-    // BOOST_CHECK_THROW(Timezoner tz(missing_type, now), util::exception);
+    const char missing_type[] =
+        "{ \"FeatureCollection\", \"features\": ["
+        "{ \"type\" : \"Feature\","
+        "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\": \"polygon\", "
+        "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+        "48.88277], [8.57757, 49.07206], [8.28369, "
+        "49.07206], [8.28369, 48.88277]]] }} ]}";
+    BOOST_CHECK_THROW(Timezoner tz(missing_type, now), util::exception);
 
-    // const char missing_featc[] =
-    //     "{ \"type\" : \"Collection\", \"features\": ["
-    //     "{ \"type\" : \"Feature\","
-    //     "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\":
-    //     \"polygon\", "
-    //     "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-    //     "48.88277], [8.57757, 49.07206], [8.28369, "
-    //     "49.07206], [8.28369, 48.88277]]] }} ]}";
-    // BOOST_CHECK_THROW(Timezoner tz(missing_featc, now), util::exception);
+    const char missing_featc[] =
+        "{ \"type\" : \"Collection\", \"features\": ["
+        "{ \"type\" : \"Feature\","
+        "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\": \"polygon\", "
+        "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+        "48.88277], [8.57757, 49.07206], [8.28369, "
+        "49.07206], [8.28369, 48.88277]]] }} ]}";
+    BOOST_CHECK_THROW(Timezoner tz(missing_featc, now), util::exception);
 }
 BOOST_AUTO_TEST_SUITE_END()

unit_tests/updater/validation.cpp

@@ -71,74 +71,68 @@ BOOST_AUTO_TEST_CASE(timezone_validation_test)
                           "48.88277], [8.57757, 49.07206], [8.28369, "
                           "49.07206], [8.28369, 48.88277]]] }}";
     doc.Parse(missing_tzid);
-    // BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
+    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 
-    // char tzid_err[] = "{ \"type\" : \"Feature\","
-    //                   "\"properties\" : { \"TZID\" : []}, \"geometry\" : { \"type\": \"polygon\",
-    //                   "
-    //                   "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-    //                   "48.88277], [8.57757, 49.07206], [8.28369, "
-    //                   "49.07206], [8.28369, 48.88277]]] }}";
-    // doc.Parse(tzid_err);
-    // BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
+    char tzid_err[] = "{ \"type\" : \"Feature\","
+                      "\"properties\" : { \"TZID\" : []}, \"geometry\" : { \"type\": \"polygon\", "
+                      "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+                      "48.88277], [8.57757, 49.07206], [8.28369, "
+                      "49.07206], [8.28369, 48.88277]]] }}";
+    doc.Parse(tzid_err);
+    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 
-    // char missing_geom[] = "{ \"type\" : \"Feature\","
-    //                       "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometries\" : { "
-    //                       "\"type\": \"polygon\", "
-    //                       "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-    //                       "48.88277], [8.57757, 49.07206], [8.28369, "
-    //                       "49.07206], [8.28369, 48.88277]]] }}";
-    // doc.Parse(missing_geom);
-    // BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
+    char missing_geom[] = "{ \"type\" : \"Feature\","
+                          "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometries\" : { "
+                          "\"type\": \"polygon\", "
+                          "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+                          "48.88277], [8.57757, 49.07206], [8.28369, "
+                          "49.07206], [8.28369, 48.88277]]] }}";
+    doc.Parse(missing_geom);
+    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 
-    // char nonobj_geom[] =
-    //     "{ \"type\" : \"Feature\","
-    //     "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : [ \"type\",
-    //     \"polygon\", "
-    //     "\"coordinates\", [[[8.28369,48.88277], [8.57757, "
-    //     "48.88277], [8.57757, 49.07206], [8.28369, "
-    //     "49.07206], [8.28369, 48.88277]]] ]}";
-    // doc.Parse(nonobj_geom);
-    // BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
+    char nonobj_geom[] =
+        "{ \"type\" : \"Feature\","
+        "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : [ \"type\", \"polygon\", "
+        "\"coordinates\", [[[8.28369,48.88277], [8.57757, "
+        "48.88277], [8.57757, 49.07206], [8.28369, "
+        "49.07206], [8.28369, 48.88277]]] ]}";
+    doc.Parse(nonobj_geom);
+    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 
-    // char missing_geom_type[] = "{ \"type\" : \"Feature\","
-    //                            "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" :
-    //                            { "
-    //                            "\"no_type\": \"polygon\", "
-    //                            "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-    //                            "48.88277], [8.57757, 49.07206], [8.28369, "
-    //                            "49.07206], [8.28369, 48.88277]]] }}";
-    // doc.Parse(missing_geom_type);
-    // BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
+    char missing_geom_type[] = "{ \"type\" : \"Feature\","
+                               "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { "
+                               "\"no_type\": \"polygon\", "
+                               "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+                               "48.88277], [8.57757, 49.07206], [8.28369, "
+                               "49.07206], [8.28369, 48.88277]]] }}";
+    doc.Parse(missing_geom_type);
+    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 
-    // char nonstring_geom_type[] = "{ \"type\" : \"Feature\","
-    //                              "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\"
-    //                              : "
-    //                              "{ \"type\": [\"polygon\"], "
-    //                              "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-    //                              "48.88277], [8.57757, 49.07206], [8.28369, "
-    //                              "49.07206], [8.28369, 48.88277]]] }}";
-    // doc.Parse(nonstring_geom_type);
-    // BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
+    char nonstring_geom_type[] = "{ \"type\" : \"Feature\","
+                                 "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : "
+                                 "{ \"type\": [\"polygon\"], "
+                                 "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+                                 "48.88277], [8.57757, 49.07206], [8.28369, "
+                                 "49.07206], [8.28369, 48.88277]]] }}";
+    doc.Parse(nonstring_geom_type);
+    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 
-    // char missing_coords[] =
-    //     "{ \"type\" : \"Feature\","
-    //     "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\":
-    //     \"polygon\", "
-    //     "\"coords\": [[[8.28369,48.88277], [8.57757, "
-    //     "48.88277], [8.57757, 49.07206], [8.28369, "
-    //     "49.07206], [8.28369, 48.88277]]] }}";
-    // doc.Parse(missing_coords);
-    // BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
+    char missing_coords[] =
+        "{ \"type\" : \"Feature\","
+        "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\": \"polygon\", "
+        "\"coords\": [[[8.28369,48.88277], [8.57757, "
+        "48.88277], [8.57757, 49.07206], [8.28369, "
+        "49.07206], [8.28369, 48.88277]]] }}";
+    doc.Parse(missing_coords);
+    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 
-    // char missing_outerring[] =
-    //     "{ \"type\" : \"Feature\","
-    //     "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\":
-    //     \"polygon\", "
-    //     "\"coordinates\": [[8.28369,48.88277], [8.57757, "
-    //     "48.88277], [8.57757, 49.07206], [8.28369, "
-    //     "49.07206], [8.28369, 48.88277]] }}";
-    // doc.Parse(missing_outerring);
-    // BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
+    char missing_outerring[] =
+        "{ \"type\" : \"Feature\","
+        "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\": \"polygon\", "
+        "\"coordinates\": [[8.28369,48.88277], [8.57757, "
+        "48.88277], [8.57757, 49.07206], [8.28369, "
+        "49.07206], [8.28369, 48.88277]] }}";
+    doc.Parse(missing_outerring);
+    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 }
 BOOST_AUTO_TEST_SUITE_END()