Rember Intersection Shapes

Changes the processing order in the edge based graph factory.
Instead of iterating over all outgoing edges in order, we compute the edge
expanded graph in the order of intersections.
This allows to remember intersection shapes and re-use them for all possible ingoing edges.

Also: use low accuracry mode for intersections degree 2 intersections

We can use lower accuracy here, since the `bearing`
after the turn is not as relevant for off-route detection.
Getting lost is near impossible here.

include/extractor/guidance/intersection_normalizer.hpp

@@ -13,6 +13,7 @@
 #include "extractor/suffix_table.hpp"
 #include "util/name_table.hpp"
 
+#include <utility>
 #include <vector>
 
 namespace osrm
@@ -45,7 +46,8 @@ class IntersectionNormalizer
     // The function takes an intersection an converts it to a `perceived` intersection which closer
     // represents how a human might experience the intersection
     OSRM_ATTR_WARN_UNUSED
-    Intersection operator()(const NodeID node_at_intersection, Intersection intersection) const;
+    std::pair<IntersectionShape, std::vector<std::pair<EdgeID, EdgeID>>>
+    operator()(const NodeID node_at_intersection, IntersectionShape intersection) const;
 
   private:
     const util::NodeBasedDynamicGraph &node_based_graph;
@@ -57,12 +59,26 @@ class IntersectionNormalizer
 
     // check if two indices in an intersection can be seen as a single road in the perceived
     // intersection representation. See below for an example. Utility function for
-    // MergeSegregatedRoads
+    // MergeSegregatedRoads. It also checks for neighboring merges.
+    // This is due possible segments where multiple roads could end up being merged into one.
+    // We only support merging two roads, not three or more, though.
+    //       c                                  c
+    //      /                                  /
+    // a - b     -> a - b - (c,d) but not a - b d   -> a,b,(cde)
+    //      \                                  \
+    //       d                                  e
     bool CanMerge(const NodeID intersection_node,
-                  const Intersection &intersection,
+                  const IntersectionShape &intersection,
                   std::size_t first_index,
                   std::size_t second_index) const;
 
+    // A tool called by CanMerge. It checks whether two indices can be merged, not concerned without
+    // remaining parts of the intersection.
+    bool InnerCanMerge(const NodeID intersection_node,
+                       const IntersectionShape &intersection,
+                       std::size_t first_index,
+                       std::size_t second_index) const;
+
     // Merge segregated roads to omit invalid turns in favor of treating segregated roads as
     // one.
     // This function combines roads the following way:
@@ -75,8 +91,8 @@ class IntersectionNormalizer
     // The treatment results in a straight turn angle of 180º rather than a turn angle of approx
     // 160
     OSRM_ATTR_WARN_UNUSED
-    Intersection MergeSegregatedRoads(const NodeID intersection_node,
-                                      Intersection intersection) const;
+    std::pair<IntersectionShape, std::vector<std::pair<EdgeID, EdgeID>>>
+    MergeSegregatedRoads(const NodeID intersection_node, IntersectionShape intersection) const;
 
     // The counterpiece to mergeSegregatedRoads. While we can adjust roads that split up at the
     // intersection itself, it can also happen that intersections are connected to joining roads.
@@ -90,8 +106,8 @@ class IntersectionNormalizer
     //
     // for the local view of b at a.
     OSRM_ATTR_WARN_UNUSED
-    Intersection AdjustForJoiningRoads(const NodeID node_at_intersection,
-                                       Intersection intersection) const;
+    IntersectionShape AdjustBearingsForMergeAtDestination(const NodeID node_at_intersection,
+                                                          IntersectionShape intersection) const;
 };
 
 } // namespace guidance