clean-up guidance code/code in general

removes duplicated includes
removes unused includes
eliminates dedicated toolkits that resulted in circular dependencies
moves functionality close to data, where possible

Author: Moritz Kobitzsch

include/engine/guidance/assemble_geometry.hpp

@@ -6,7 +6,6 @@
 #include "engine/datafacade/datafacade_base.hpp"
 #include "engine/guidance/leg_geometry.hpp"
 #include "engine/guidance/route_step.hpp"
-#include "engine/guidance/toolkit.hpp"
 #include "engine/internal_route_result.hpp"
 #include "engine/phantom_node.hpp"
 #include "util/coordinate.hpp"

include/engine/guidance/assemble_steps.hpp

@@ -8,14 +8,12 @@
 #include "engine/guidance/leg_geometry.hpp"
 #include "engine/guidance/route_step.hpp"
 #include "engine/guidance/step_maneuver.hpp"
-#include "engine/guidance/toolkit.hpp"
 #include "engine/internal_route_result.hpp"
 #include "engine/phantom_node.hpp"
 #include "util/bearing.hpp"
 #include "util/coordinate.hpp"
 #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"
 
@@ -156,7 +154,7 @@ inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &fa
                     intersection.entry.push_back(entry_class.allowsEntry(idx));
                 }
                 std::int16_t bearing_in_driving_direction =
-                    util::bearing::reverseBearing(std::round(bearings.first));
+                    util::reverseBearing(std::round(bearings.first));
                 maneuver = {intersection.location,
                             bearing_in_driving_direction,
                             bearings.second,
@@ -216,14 +214,13 @@ inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &fa
     BOOST_ASSERT(segment_index == number_of_segments - 1);
     bearings = detail::getArriveBearings(leg_geometry);
 
-    intersection = {
-        target_node.location,
-        std::vector<short>({static_cast<short>(util::bearing::reverseBearing(bearings.first))}),
-        std::vector<bool>({true}),
-        0,
-        Intersection::NO_INDEX,
-        util::guidance::LaneTuple(),
-        {}};
+    intersection = {target_node.location,
+                    std::vector<short>({static_cast<short>(util::reverseBearing(bearings.first))}),
+                    std::vector<bool>({true}),
+                    0,
+                    Intersection::NO_INDEX,
+                    util::guidance::LaneTuple(),
+                    {}};
 
     // This step has length zero, the only reason we need it is the target location
     maneuver = {intersection.location,

include/engine/guidance/postprocessing_toolkit.hpp

@@ -0,0 +1,53 @@
+#ifndef OSRM_ENGINE_GUIDANCE_POSTPROCESSING_TOOLKIT_HPP_
+#define OSRM_ENGINE_GUIDANCE_POSTPROCESSING_TOOLKIT_HPP_
+
+#include "extractor/guidance/turn_instruction.hpp"
+#include "engine/guidance/route_step.hpp"
+
+#include <iterator>
+#include <utility>
+
+namespace osrm
+{
+namespace engine
+{
+namespace guidance
+{
+
+// Runs fn on RouteStep sub-ranges determined to be roundabouts.
+// The function fn is getting called with a roundabout range as in: [enter, .., leave].
+//
+// The following situations are taken care for (i.e. we discard them):
+//  - partial roundabout: enter without exit or exit without enter
+//  - data issues: no roundabout, exit before enter
+template <typename Iter, typename Fn> inline Fn forEachRoundabout(Iter first, Iter last, Fn fn)
+{
+    while (first != last)
+    {
+        const auto enter = std::find_if(first, last, [](const RouteStep &step) {
+            return entersRoundabout(step.maneuver.instruction);
+        });
+
+        // enter has to come before leave, otherwise: faulty data / partial roundabout, skip those
+        const auto leave = std::find_if(enter, last, [](const RouteStep &step) {
+            return leavesRoundabout(step.maneuver.instruction);
+        });
+
+        // No roundabouts, or partial one (like start / end inside a roundabout)
+        if (enter == last || leave == last)
+            break;
+
+        (void)fn(std::make_pair(enter, leave));
+
+        // Skip to first step after the currently handled enter / leave pair
+        first = std::next(leave);
+    }
+
+    return fn;
+}
+
+} // namespace guidance
+} // namespace engine
+} // namespace osrm
+
+#endif /* OSRM_ENGINE_GUIDANCE_POSTPROCESSING_TOOLKIT_HPP_ */

include/engine/guidance/route_step.hpp

@@ -11,10 +11,11 @@
 #include "util/guidance/turn_lanes.hpp"
 
 #include <cstddef>
-
 #include <string>
 #include <vector>
 
+#include <boost/range/iterator_range.hpp>
+
 namespace osrm
 {
 namespace engine
@@ -71,6 +72,33 @@ struct RouteStep
     std::size_t geometry_begin;
     std::size_t geometry_end;
     std::vector<Intersection> intersections;
+
+    LaneID numLanesToTheRight() const
+    {
+        return intersections.front().lanes.first_lane_from_the_right;
+    }
+
+    LaneID numLanesToTheLeft() const
+    {
+        LaneID const total = intersections.front().lane_description.size();
+        return total - (intersections.front().lanes.lanes_in_turn +
+                        intersections.front().lanes.first_lane_from_the_right);
+    }
+
+    auto lanesToTheLeft() const
+    {
+        const auto &description = intersections.front().lane_description;
+        LaneID num_lanes_left = numLanesToTheLeft();
+        return boost::make_iterator_range(description.begin(),
+                                          description.begin() + num_lanes_left);
+    }
+
+    auto lanesToTheRight() const
+    {
+        const auto &description = intersections.front().lane_description;
+        LaneID num_lanes_right = numLanesToTheRight();
+        return boost::make_iterator_range(description.end() - num_lanes_right, description.end());
+    }
 };
 
 inline RouteStep getInvalidRouteStep()

include/engine/guidance/toolkit.hpp

@@ -3,7 +3,6 @@
 
 #include "util/dist_table_wrapper.hpp"
 #include "util/typedefs.hpp"
-#include "util/typedefs.hpp"
 
 #include "osrm/json_container.hpp"
 #include <boost/assert.hpp>

include/engine/trip/trip_farthest_insertion.hpp

@@ -29,7 +29,6 @@
 #include <memory>
 #include <queue>
 #include <string>
-#include <string>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>

include/extractor/edge_based_graph_factory.hpp

@@ -12,7 +12,7 @@
 #include <limits>
 #include <string>
 
-#include "extractor/guidance/toolkit.hpp"
+#include "extractor/guidance/parsing_toolkit.hpp"
 
 namespace osrm
 {
@@ -109,13 +109,13 @@ inline unsigned parseDuration(const std::string &s)
 inline std::string
 trimLaneString(std::string lane_string, std::int32_t count_left, std::int32_t count_right)
 {
-    return extractor::guidance::trimLaneString(std::move(lane_string), count_left, count_right);
+    return guidance::trimLaneString(std::move(lane_string), count_left, count_right);
 }
 
 inline std::string applyAccessTokens(const std::string &lane_string,
                                      const std::string &access_tokens)
 {
-    return extractor::guidance::applyAccessTokens(lane_string, access_tokens);
+    return guidance::applyAccessTokens(lane_string, access_tokens);
 }
 
 // Takes a string representing a list separated by delim and canonicalizes containing spaces.

include/extractor/extraction_helper_functions.hpp

@@ -11,7 +11,8 @@
 
 #include "extractor/guidance/coordinate_extractor.hpp"
 #include "extractor/guidance/intersection.hpp"
-#include "extractor/guidance/toolkit.hpp"
+
+#include <boost/optional.hpp>
 
 namespace osrm
 {

include/extractor/geojson_debug_policies.hpp

@@ -9,7 +9,6 @@
 
 #include "util/attributes.hpp"
 #include "util/coordinate.hpp"
-#include "util/coordinate_calculation.hpp"
 #include "util/node_based_graph.hpp"
 
 namespace osrm