syncronize geometry and steps after post-processing

include/engine/api/route_api.hpp

@@ -127,6 +127,7 @@ class RouteAPI : public BaseAPI
                  */
 
                  leg.steps = guidance::postProcess(std::move(steps));
+                 leg_geometry = guidance::resyncGeometry(std::move(leg_geometry),leg.steps);
             }
 
             leg_geometries.push_back(std::move(leg_geometry));

include/engine/guidance/assemble_geometry.hpp

@@ -51,7 +51,7 @@ LegGeometry assembleGeometry(const DataFacadeT &facade,
         current_distance +=
             util::coordinate_calculation::haversineDistance(prev_coordinate, coordinate);
 
-        //all changes to this check have to be matched with assemble_steps
+        // all changes to this check have to be matched with assemble_steps
         if (path_point.turn_instruction.type != extractor::guidance::TurnType::NoTurn)
         {
             geometry.segment_distances.push_back(current_distance);

include/engine/guidance/post_processing.hpp

@@ -2,6 +2,7 @@
 #define ENGINE_GUIDANCE_POST_PROCESSING_HPP
 
 #include "engine/guidance/route_step.hpp"
+#include "engine/guidance/leg_geometry.hpp"
 
 #include <vector>
 
@@ -12,9 +13,16 @@ namespace engine
 namespace guidance
 {
 
-//passed as none-reference to modify in-place and move out again
+// passed as none-reference to modify in-place and move out again
 std::vector<RouteStep> postProcess(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.
+// If required, we can get both in sync again using this function.
+// Move in LegGeometry for modification in place.
+LegGeometry resyncGeometry(LegGeometry leg_geometry, const std::vector<RouteStep> &steps);
+
 } // namespace guidance
 } // namespace engine
 } // namespace osrm

src/engine/api/json_factory.cpp

@@ -150,10 +150,10 @@ util::json::Object makeStepManeuver(const guidance::StepManeuver &maneuver)
     if (maneuver.exit != 0)
         step_maneuver.values["exit"] = maneuver.exit;
 
-    //TODO currently we need this to comply with the api.
-    //We should move this to an additional entry, the moment we
-    //actually compute the correct locations of the intersections
-    if (!maneuver.intersections.empty() && maneuver.exit == 0 )
+    // TODO currently we need this to comply with the api.
+    // We should move this to an additional entry, the moment we
+    // actually compute the correct locations of the intersections
+    if (!maneuver.intersections.empty() && maneuver.exit == 0)
         step_maneuver.values["exit"] = maneuver.intersections.size();
     return step_maneuver;
 }

src/engine/guidance/post_processing.cpp

@@ -54,9 +54,9 @@ void fixFinalRoundabout(std::vector<RouteStep> &steps)
         }
         else if (propagation_step.maneuver.instruction.type == TurnType::StayOnRoundabout)
         {
-            //TODO this operates on the data that is in the instructions.
-            //We are missing out on the final segment after the last stay-on-roundabout
-            //instruction though. it is not contained somewhere until now
+            // TODO this operates on the data that is in the instructions.
+            // We are missing out on the final segment after the last stay-on-roundabout
+            // instruction though. it is not contained somewhere until now
             steps[propagation_index - 1] =
                 forwardInto(std::move(steps[propagation_index - 1]), propagation_step);
             propagation_step.maneuver.instruction =
@@ -292,6 +292,29 @@ std::vector<RouteStep> postProcess(std::vector<RouteStep> steps)
     return steps;
 }
 
+LegGeometry resyncGeometry(LegGeometry leg_geometry, const std::vector<RouteStep> &steps)
+{
+    // The geometry uses an adjacency array-like structure for representation.
+    // To sync it back up with the steps, we cann add a segment for every step.
+    leg_geometry.segment_offsets.clear();
+    leg_geometry.segment_distances.clear();
+    leg_geometry.segment_offsets.push_back(0);
+
+    for (const auto &step : steps)
+    {
+        leg_geometry.segment_distances.push_back(step.distance);
+        // the leg geometry does not follow the begin/end-convetion. So we have to subtract one
+        // to get the back-index.
+        leg_geometry.segment_offsets.push_back(step.geometry_end - 1);
+    }
+
+    //remove the data fromt the reached-target step again
+    leg_geometry.segment_offsets.pop_back();
+    leg_geometry.segment_distances.pop_back();
+
+    return leg_geometry;
+}
+
 } // namespace guidance
 } // namespace engine
 } // namespace osrm