refactor guidance

include/extractor/guidance/intersection_handler.hpp

@@ -61,6 +61,19 @@ class IntersectionHandler
                     ConnectedRoad &center,
                     ConnectedRoad &right) const;
 
+    // Trivial Turns use findBasicTurnType and getTurnDirection as only criteria
+    void assignTrivialTurns(const EdgeID via_eid,
+                            Intersection &intersection,
+                            const std::size_t begin,
+                            const std::size_t end) const;
+
+    // Counting Turns are Essentially unseparable turns. Begin > end is a valid input
+    void assignCountingTurns(const EdgeID via_eid,
+                             Intersection &intersection,
+                             const std::size_t begin,
+                             const std::size_t end,
+                             const DirectionModifier modifier) const;
+
     bool isThroughStreet(const std::size_t index, const Intersection &intersection) const;
 };
 

include/extractor/guidance/intersection_scenario_three_way.hpp

@@ -0,0 +1,27 @@
+#ifndef OSRM_EXTRACTOR_GUIDANCE_INTERSECTION_SCENARIO_THREE_WAY_HPP_
+#define OSRM_EXTRACTOR_GUIDANCE_INTERSECTION_SCENARIO_THREE_WAY_HPP_
+
+#include "extractor/guidance/intersection.hpp"
+
+namespace osrm
+{
+namespace extractor
+{
+namespace guidance
+{
+
+// possible fork
+bool isFork(const ConnectedRoad &uturn,
+            const ConnectedRoad &possible_right_fork,
+            const ConnectedRoad &possible_left_fork);
+
+// Ending in a T-Intersection
+bool isEndOfRoad(const ConnectedRoad &uturn,
+                 const ConnectedRoad &possible_right_turn,
+                 const ConnectedRoad &possible_left_turn);
+
+} // namespace guidance
+} // namespace extractor
+} // namespace osrm
+
+#endif /*OSRM_EXTRACTOR_GUIDANCE_INTERSECTION_SCENARIO_THREE_WAY_HPP_*/

include/extractor/guidance/motorway_handler.hpp

@@ -1,8 +1,8 @@
 #ifndef OSRM_EXTRACTOR_GUIDANCE_MOTORWAY_HANDLER_HPP_
 #define OSRM_EXTRACTOR_GUIDANCE_MOTORWAY_HANDLER_HPP_
 
-#include "extractor/guidance/intersection_handler.hpp"
 #include "extractor/guidance/intersection.hpp"
+#include "extractor/guidance/intersection_handler.hpp"
 #include "extractor/query_node.hpp"
 
 #include "util/name_table.hpp"

include/extractor/guidance/roundabout_handler.hpp

@@ -42,13 +42,19 @@ class RoundaboutHandler : public IntersectionHandler
     ~RoundaboutHandler() override final;
 
     // check whether the handler can actually handle the intersection
-    bool canProcess(const NodeID from_nid, const EdgeID via_eid, const Intersection &intersection) const override final;
+    bool canProcess(const NodeID from_nid,
+                    const EdgeID via_eid,
+                    const Intersection &intersection) const override final;
 
     // process the intersection
-    Intersection operator()(const NodeID from_nid, const EdgeID via_eid, Intersection intersection) const override final;
+    Intersection operator()(const NodeID from_nid,
+                            const EdgeID via_eid,
+                            Intersection intersection) const override final;
 
   private:
-    detail::RoundaboutFlags getRoundaboutFlags(const NodeID from_nid, const EdgeID via_eid, const Intersection &intersection) const;
+    detail::RoundaboutFlags getRoundaboutFlags(const NodeID from_nid,
+                                               const EdgeID via_eid,
+                                               const Intersection &intersection) const;
 
     // decide whether we lookk at a roundabout or a rotary
     bool isRotary(const NodeID nid) const;

include/extractor/guidance/toolkit.hpp

@@ -10,6 +10,7 @@
 
 #include "extractor/guidance/classification_data.hpp"
 #include "extractor/guidance/discrete_angle.hpp"
+#include "extractor/guidance/intersection.hpp"
 #include "extractor/guidance/turn_instruction.hpp"
 
 #include <algorithm>
@@ -397,6 +398,25 @@ inline bool canBeSeenAsFork(const FunctionalRoadClass first, const FunctionalRoa
     return std::abs(getPriority(first) - getPriority(second)) <= 1;
 }
 
+// To simplify handling of Left/Right hand turns, we can mirror turns and write an intersection
+// handler only for one side. The mirror function turns a left-hand turn in a equivalent right-hand
+// turn and vice versa.
+inline ConnectedRoad mirror(ConnectedRoad road)
+{
+    const constexpr DirectionModifier mirrored_modifiers[] = {
+        DirectionModifier::UTurn,      DirectionModifier::SharpLeft, DirectionModifier::Left,
+        DirectionModifier::SlightLeft, DirectionModifier::Straight,  DirectionModifier::SlightRight,
+        DirectionModifier::Right,      DirectionModifier::SharpRight};
+
+    if (angularDeviation(road.turn.angle, 0) > std::numeric_limits<double>::epsilon())
+    {
+        road.turn.angle = 360 - road.turn.angle;
+        road.turn.instruction.direction_modifier =
+            mirrored_modifiers[road.turn.instruction.direction_modifier];
+    }
+    return road;
+}
+
 } // namespace guidance
 } // namespace extractor
 } // namespace osrm

include/extractor/guidance/turn_analysis.hpp

@@ -4,10 +4,10 @@
 #include "extractor/compressed_edge_container.hpp"
 #include "extractor/guidance/intersection.hpp"
 #include "extractor/guidance/intersection_generator.hpp"
+#include "extractor/guidance/motorway_handler.hpp"
+#include "extractor/guidance/roundabout_handler.hpp"
 #include "extractor/guidance/toolkit.hpp"
 #include "extractor/guidance/turn_classification.hpp"
-#include "extractor/guidance/roundabout_handler.hpp"
-#include "extractor/guidance/motorway_handler.hpp"
 #include "extractor/guidance/turn_handler.hpp"
 #include "extractor/query_node.hpp"
 #include "extractor/restriction_map.hpp"

include/extractor/guidance/turn_classification.hpp

@@ -3,9 +3,9 @@
 
 #include "extractor/guidance/toolkit.hpp"
 
-#include "util/typedefs.hpp"
 #include "util/coordinate.hpp"
 #include "util/node_based_graph.hpp"
+#include "util/typedefs.hpp"
 
 #include "extractor/compressed_edge_container.hpp"
 #include "extractor/query_node.hpp"
@@ -84,8 +84,7 @@ classifyIntersection(NodeID nid,
     }
 
     std::sort(turns.begin(), turns.end(),
-              [](const TurnPossibility left, const TurnPossibility right)
-              {
+              [](const TurnPossibility left, const TurnPossibility right) {
                   return left.angle < right.angle;
               });
 

include/extractor/guidance/turn_handler.hpp

@@ -1,16 +1,16 @@
 #ifndef OSRM_EXTRACTOR_GUIDANCE_TURN_HANDLER_HPP_
 #define OSRM_EXTRACTOR_GUIDANCE_TURN_HANDLER_HPP_
 
-#include "extractor/guidance/intersection_handler.hpp"
 #include "extractor/guidance/intersection.hpp"
+#include "extractor/guidance/intersection_handler.hpp"
 #include "extractor/query_node.hpp"
 
 #include "util/name_table.hpp"
 #include "util/node_based_graph.hpp"
 
 #include <cstddef>
-#include <vector>
 #include <utility>
+#include <vector>
 
 namespace osrm
 {