Move guidance turn generation out of EBGF

include/guidance/guidance_processing.hpp

@@ -0,0 +1,49 @@
+#ifndef OSRM_GUIDANCE_GUIDANCE_RUNNER_HPP
+#define OSRM_GUIDANCE_GUIDANCE_RUNNER_HPP
+
+#include "guidance/turn_data_container.hpp"
+
+#include "extractor/compressed_edge_container.hpp"
+#include "extractor/node_data_container.hpp"
+#include "extractor/suffix_table.hpp"
+#include "extractor/turn_lane_types.hpp"
+#include "extractor/way_restriction_map.hpp"
+
+#include "util/coordinate.hpp"
+#include "util/guidance/bearing_class.hpp"
+#include "util/guidance/entry_class.hpp"
+#include "util/guidance/turn_lanes.hpp"
+#include "util/name_table.hpp"
+#include "util/node_based_graph.hpp"
+
+#include <unordered_set>
+
+namespace osrm
+{
+namespace guidance
+{
+using BearingClassesVector = std::vector<BearingClassID>;
+using BearingClassesMap = util::ConcurrentIDMap<util::guidance::BearingClass, BearingClassID>;
+using EntryClassesMap = util::ConcurrentIDMap<util::guidance::EntryClass, EntryClassID>;
+
+void annotateTurns(const util::NodeBasedDynamicGraph &node_based_graph,
+                   const extractor::EdgeBasedNodeDataContainer &edge_based_node_container,
+                   const std::vector<util::Coordinate> &node_coordinates,
+                   const extractor::CompressedEdgeContainer &compressed_edge_container,
+                   const std::unordered_set<NodeID> &barrier_nodes,
+                   const extractor::RestrictionMap &node_restriction_map,
+                   const extractor::WayRestrictionMap &way_restriction_map,
+                   const util::NameTable &name_table,
+                   const extractor::SuffixTable &suffix_table,
+                   const extractor::TurnLanesIndexedArray &turn_lanes_data,
+                   extractor::LaneDescriptionMap &lane_description_map,
+                   util::guidance::LaneDataIdMap &lane_data_map,
+                   guidance::TurnDataExternalContainer &turn_data_container,
+                   BearingClassesVector &bearing_class_by_node_based_node,
+                   BearingClassesMap &bearing_class_hash,
+                   EntryClassesMap &entry_class_hash);
+
+} // namespace customizer
+} // namespace osrm
+
+#endif

include/guidance/segregated_intersection_classification.hpp

@@ -12,6 +12,7 @@ class NameTable;
 namespace extractor
 {
 class NodeBasedGraphFactory;
+}
 
 namespace guidance
 {
@@ -20,8 +21,7 @@ namespace guidance
 // - middle edges between two osm ways in one logic road (U-turn)
 // - staggered intersections (X-cross)
 // - square/circle intersections
-std::unordered_set<EdgeID> findSegregatedNodes(const NodeBasedGraphFactory &factory,
+std::unordered_set<EdgeID> findSegregatedNodes(const extractor::NodeBasedGraphFactory &factory,
                                                const util::NameTable &names);
 }
 }
-}

include/guidance/turn_bearing.hpp

@@ -0,0 +1,38 @@
+#ifndef OSRM_INCLUDE_GUIDANCE_TURN_BEARING_HPP_
+#define OSRM_INCLUDE_GUIDANCE_TURN_BEARING_HPP_
+
+#include <cstdint>
+
+#include <boost/assert.hpp>
+
+namespace osrm
+{
+namespace guidance
+{
+namespace
+{
+const double bearing_scale = 360.0 / 256.0;
+}
+
+#pragma pack(push, 1)
+class TurnBearing
+{
+  public:
+    // discretizes a bearing into distinct units of 1.4 degrees
+    TurnBearing(const double value = 0) : bearing(value / bearing_scale)
+    {
+        BOOST_ASSERT_MSG(value >= 0 && value < 360.0,
+                         "Bearing value needs to be between 0 and 360 (exclusive)");
+    }
+
+    double Get() const { return bearing * bearing_scale; }
+
+  private:
+    std::uint8_t bearing;
+};
+#pragma pack(pop)
+
+} // namespace guidance
+} // namespace osrm
+
+#endif /* OSRM_INCLUDE_GUIDANCE_TURN_BEARING_HPP_ */

include/guidance/turn_data_container.hpp

@@ -2,12 +2,12 @@
 #define OSRM_GUIDANCE_TURN_DATA_CONTAINER_HPP
 
 #include "extractor/travel_mode.hpp"
+#include "guidance/turn_bearing.hpp"
 #include "guidance/turn_instruction.hpp"
 
 #include "storage/io_fwd.hpp"
 #include "storage/shared_memory_ownership.hpp"
 
-#include "util/guidance/turn_bearing.hpp"
 #include "util/vector_view.hpp"
 
 #include "util/typedefs.hpp"
@@ -33,11 +33,11 @@ void write(storage::io::FileWriter &writer,
 
 struct TurnData
 {
-    guidance::TurnInstruction turn_instruction;
+    TurnInstruction turn_instruction;
     LaneDataID lane_data_id;
     EntryClassID entry_class_id;
-    util::guidance::TurnBearing pre_turn_bearing;
-    util::guidance::TurnBearing post_turn_bearing;
+    TurnBearing pre_turn_bearing;
+    TurnBearing post_turn_bearing;
 };
 
 namespace detail
@@ -49,11 +49,11 @@ template <storage::Ownership Ownership> class TurnDataContainerImpl
   public:
     TurnDataContainerImpl() = default;
 
-    TurnDataContainerImpl(Vector<guidance::TurnInstruction> turn_instructions,
+    TurnDataContainerImpl(Vector<TurnInstruction> turn_instructions,
                           Vector<LaneDataID> lane_data_ids,
                           Vector<EntryClassID> entry_class_ids,
-                          Vector<util::guidance::TurnBearing> pre_turn_bearings,
-                          Vector<util::guidance::TurnBearing> post_turn_bearings)
+                          Vector<TurnBearing> pre_turn_bearings,
+                          Vector<TurnBearing> post_turn_bearings)
         : turn_instructions(std::move(turn_instructions)), lane_data_ids(std::move(lane_data_ids)),
           entry_class_ids(std::move(entry_class_ids)),
           pre_turn_bearings(std::move(pre_turn_bearings)),
@@ -63,15 +63,9 @@ template <storage::Ownership Ownership> class TurnDataContainerImpl
 
     EntryClassID GetEntryClassID(const EdgeID id) const { return entry_class_ids[id]; }
 
-    util::guidance::TurnBearing GetPreTurnBearing(const EdgeID id) const
-    {
-        return pre_turn_bearings[id];
-    }
+    TurnBearing GetPreTurnBearing(const EdgeID id) const { return pre_turn_bearings[id]; }
 
-    util::guidance::TurnBearing GetPostTurnBearing(const EdgeID id) const
-    {
-        return post_turn_bearings[id];
-    }
+    TurnBearing GetPostTurnBearing(const EdgeID id) const { return post_turn_bearings[id]; }
 
     LaneDataID GetLaneDataID(const EdgeID id) const { return lane_data_ids[id]; }
 
@@ -106,11 +100,11 @@ template <storage::Ownership Ownership> class TurnDataContainerImpl
                                                 const TurnDataContainerImpl &turn_data_container);
 
   private:
-    Vector<guidance::TurnInstruction> turn_instructions;
+    Vector<TurnInstruction> turn_instructions;
     Vector<LaneDataID> lane_data_ids;
     Vector<EntryClassID> entry_class_ids;
-    Vector<util::guidance::TurnBearing> pre_turn_bearings;
-    Vector<util::guidance::TurnBearing> post_turn_bearings;
+    Vector<TurnBearing> pre_turn_bearings;
+    Vector<TurnBearing> post_turn_bearings;
 };
 }