Correctly handle compressed traffic signals (#6724)

Unidirectional traffic signal segments are currently not compressed.
This means traffic signals which are not on turns can be missed and
not applied the correct penalty.

This commit changes this behaviour to correctly handle the graph
compression. Additional tests are added to ensure there is no
regression for other cases (turns, restrictions).

Co-authored-by: Michael Bell <michael@mjjbell.com>

src/extractor/edge_based_graph_factory.cpp

@@ -608,26 +608,12 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
             BOOST_ASSERT(!edge_data1.reversed);
             BOOST_ASSERT(!edge_data2.reversed);
 
-            // We write out the mapping between the edge-expanded edges and the original nodes.
-            // Since each edge represents a possible maneuver, external programs can use this to
-            // quickly perform updates to edge weights in order to penalize certain turns.
-
-            // If this edge is 'trivial' -- where the compressed edge corresponds exactly to an
-            // original OSM segment -- we can pull the turn's preceding node ID directly with
-            // `node_along_road_entering`;
-            // otherwise, we need to look up the node immediately preceding the turn from the
-            // compressed edge container.
-            const bool isTrivial = m_compressed_edge_container.IsTrivial(node_based_edge_from);
-
-            const auto &from_node =
-                isTrivial ? node_along_road_entering
-                          : m_compressed_edge_container.GetLastEdgeSourceID(node_based_edge_from);
-
             // compute weight and duration penalties
             // In theory we shouldn't get a directed traffic light on a turn, as it indicates that
             // the traffic signal direction was potentially ambiguously annotated on the junction
             // node But we'll check anyway.
-            const auto is_traffic_light = m_traffic_signals.HasSignal(from_node, intersection_node);
+            const auto is_traffic_light =
+                m_traffic_signals.HasSignal(node_along_road_entering, intersection_node);
             const auto is_uturn =
                 guidance::getTurnDirection(turn_angle) == guidance::DirectionModifier::UTurn;
 
@@ -694,6 +680,21 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                                              true,
                                              false};
 
+            // We write out the mapping between the edge-expanded edges and the original nodes.
+            // Since each edge represents a possible maneuver, external programs can use this to
+            // quickly perform updates to edge weights in order to penalize certain turns.
+
+            // If this edge is 'trivial' -- where the compressed edge corresponds exactly to an
+            // original OSM segment -- we can pull the turn's preceding node ID directly with
+            // `node_along_road_entering`;
+            // otherwise, we need to look up the node immediately preceding the turn from the
+            // compressed edge container.
+            const bool isTrivial = m_compressed_edge_container.IsTrivial(node_based_edge_from);
+
+            const auto &from_node =
+                isTrivial ? node_along_road_entering
+                          : m_compressed_edge_container.GetLastEdgeSourceID(node_based_edge_from);
+
             const auto &to_node =
                 m_compressed_edge_container.GetFirstEdgeTargetID(node_based_edge_to);
 

src/extractor/graph_compressor.cpp

@@ -20,7 +20,7 @@ namespace osrm::extractor
 static constexpr int SECOND_TO_DECISECOND = 10;
 
 void GraphCompressor::Compress(const std::unordered_set<NodeID> &barrier_nodes,
-                               const TrafficSignals &traffic_signals,
+                               TrafficSignals &traffic_signals,
                                ScriptingEnvironment &scripting_environment,
                                std::vector<TurnRestriction> &turn_restrictions,
                                std::vector<UnresolvedManeuverOverride> &maneuver_overrides,
@@ -338,6 +338,9 @@ void GraphCompressor::Compress(const std::unordered_set<NodeID> &barrier_nodes,
                 // update any involved turn relations
                 turn_path_compressor.Compress(node_u, node_v, node_w);
 
+                // Update traffic signal paths containing compressed node.
+                traffic_signals.Compress(node_u, node_v, node_w);
+
                 // Forward and reversed compressed edge lengths need to match.
                 // Set a dummy empty penalty weight if opposite value exists.
                 auto set_dummy_penalty = [](EdgeWeight &weight_penalty,

src/extractor/node_based_graph_factory.cpp

@@ -17,7 +17,7 @@ NodeBasedGraphFactory::NodeBasedGraphFactory(
     ScriptingEnvironment &scripting_environment,
     std::vector<TurnRestriction> &turn_restrictions,
     std::vector<UnresolvedManeuverOverride> &maneuver_overrides,
-    const TrafficSignals &traffic_signals,
+    TrafficSignals &traffic_signals,
     std::unordered_set<NodeID> &&barriers,
     std::vector<util::Coordinate> &&coordinates,
     extractor::PackedOSMIDs &&osm_node_ids,
@@ -72,7 +72,7 @@ void NodeBasedGraphFactory::BuildCompressedOutputGraph(const std::vector<NodeBas
 void NodeBasedGraphFactory::Compress(ScriptingEnvironment &scripting_environment,
                                      std::vector<TurnRestriction> &turn_restrictions,
                                      std::vector<UnresolvedManeuverOverride> &maneuver_overrides,
-                                     const TrafficSignals &traffic_signals)
+                                     TrafficSignals &traffic_signals)
 {
     GraphCompressor graph_compressor;
     graph_compressor.Compress(barriers,