Implement Turn Lane Api

include/engine/guidance/assemble_steps.hpp

@@ -15,6 +15,7 @@
 #include "util/coordinate_calculation.hpp"
 #include "util/guidance/entry_class.hpp"
 #include "util/guidance/toolkit.hpp"
+#include "util/guidance/turn_lanes.hpp"
 #include "util/typedefs.hpp"
 
 #include <boost/optional.hpp>
@@ -70,7 +71,9 @@ inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &fa
                           bearings.second,
                           extractor::guidance::TurnInstruction::NO_TURN(),
                           WaypointType::Depart,
-                          0};
+                          0,
+                          util::guidance::LaneTupel(),
+                          ""};
     Intersection intersection{source_node.location,
                               std::vector<short>({bearings.second}),
                               std::vector<bool>({true}),
@@ -147,7 +150,11 @@ inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &fa
                             bearings.second,
                             path_point.turn_instruction,
                             WaypointType::None,
-                            0};
+                            0,
+                            path_point.lane_data.first,
+                            (path_point.lane_data.second != INVALID_LANE_STRINGID
+                                 ? facade.GetTurnStringForID(path_point.lane_data.second)
+                                 : "")};
                 segment_index++;
                 segment_duration = 0;
             }
@@ -202,7 +209,9 @@ inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &fa
                 bearings.second,
                 extractor::guidance::TurnInstruction::NO_TURN(),
                 WaypointType::Arrive,
-                0};
+                0,
+                util::guidance::LaneTupel(),
+                ""};
     intersection = {
         target_node.location,
         std::vector<short>({static_cast<short>(util::bearing::reverseBearing(bearings.first))}),
@@ -233,6 +242,9 @@ inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &fa
     BOOST_ASSERT(steps.back().intersections.front().bearings.size() == 1);
     BOOST_ASSERT(steps.back().intersections.front().entry.size() == 1);
     BOOST_ASSERT(steps.back().maneuver.waypoint_type == WaypointType::Arrive);
+    BOOST_ASSERT(steps.back().maneuver.lanes.lanes_in_turn == 0);
+    BOOST_ASSERT(steps.back().maneuver.lanes.first_lane_from_the_right == INVALID_LANEID);
+    BOOST_ASSERT(steps.back().maneuver.turn_lane_string == "");
     return steps;
 }
 

include/engine/guidance/lane_processing.hpp

@@ -0,0 +1,24 @@
+#ifndef OSRM_ENGINE_GUIDANCE_LANE_PROCESSING_HPP_
+#define OSRM_ENGINE_GUIDANCE_LANE_PROCESSING_HPP_
+
+#include <vector>
+
+#include "engine/guidance/route_step.hpp"
+
+namespace osrm
+{
+namespace engine
+{
+namespace guidance
+{
+
+// Constrains lanes for multi-hop situations where lane changes depend on earlier ones.
+// Instead of forcing users to change lanes rapidly in a short amount of time,
+// we anticipate lane changes emitting only matching lanes early on.
+std::vector<RouteStep> anticipateLaneChange(std::vector<RouteStep> steps);
+
+} // namespace guidance
+} // namespace engine
+} // namespace osrm
+
+#endif /* OSRM_ENGINE_GUIDANCE_LANE_PROCESSING_HPP_ */

include/engine/guidance/post_processing.hpp

@@ -43,11 +43,6 @@ std::vector<RouteStep> buildIntersections(std::vector<RouteStep> steps);
 // remove steps invalidated by post-processing
 std::vector<RouteStep> removeNoTurnInstructions(std::vector<RouteStep> steps);
 
-// Constrains lanes for multi-hop situations where lane changes depend on earlier ones.
-// Instead of forcing users to change lanes rapidly in a short amount of time,
-// we anticipate lane changes emitting only matching lanes early on.
-std::vector<RouteStep> anticipateLaneChange(std::vector<RouteStep> steps);
-
 // postProcess will break the connection between the leg geometry
 // for which a segment is supposed to represent exactly the coordinates
 // between routing maneuvers and the route steps itself.

include/engine/guidance/step_maneuver.hpp

@@ -3,8 +3,10 @@
 
 #include "extractor/guidance/turn_instruction.hpp"
 #include "util/coordinate.hpp"
+#include "util/guidance/turn_lanes.hpp"
 
 #include <cstdint>
+#include <string>
 #include <vector>
 
 namespace osrm
@@ -27,8 +29,12 @@ struct StepManeuver
     short bearing_before;
     short bearing_after;
     extractor::guidance::TurnInstruction instruction;
+
     WaypointType waypoint_type;
     unsigned exit;
+
+    util::guidance::LaneTupel lanes;
+    std::string turn_lane_string;
 };
 
 inline StepManeuver getInvalidStepManeuver()
@@ -38,7 +44,9 @@ inline StepManeuver getInvalidStepManeuver()
             0,
             extractor::guidance::TurnInstruction::NO_TURN(),
             WaypointType::None,
-            0};
+            0,
+            util::guidance::LaneTupel(),
+            ""};
 }
 
 } // namespace guidance