FakeTurn objects in ExtractionTurn are created as traffic_signals instead of specific obstacles

[Ephtolens]

Issue

While upgrading my OSRM setup to v6.0.0, I encountered a strange behavior that I eventually traced back to the new obstacles feature.

In my custom profile, I use a process_turn Lua function that adjusts turn weight based on the angle and on the presence of a traffic light. However, during testing, I noticed that nodes considered as obstacles (i.e. nodes registered in obstacles.lua) such as highway=crossing were receiving a turn penalty that should not have been applied.
This is unexpected because the obstacle created for a crossing has weight = 0 and duration = 0, so passing through that node should introduce no penalty.

Minimal test case

With a crossing node on a single continuous way, I get an unexpected 2-second penalty, even though my code only applies that penalty for traffic lights:

Given the node map
    """
    a-b-c
    """

And a grid size of 100 meters

And the ways
    | nodes | highway  |
    | abc   | cycleway |

And the nodes
    | node | highway  |
    | b    | crossing |

When I route I should get
    | from | to | speed   | weight | time | #            |
    | a    | c  | 15 km/h | 32.8   | 50s  | no crossroad |
    | a    | b  | 15 km/h | 15.4   | 24s  | no crossroad |
    | b    | c  | 10 km/h | 17.4   | 26s  | no crossroad |

Surprisingly, if I split the way into two segments, the penalty disappears:

Given the node map
    """
    a-b-c
    """

And a grid size of 100 meters

And the ways
    | nodes | highway  |
    | ab    | cycleway |
    | bc    | cycleway |

And the nodes
    | node | highway  |
    | b    | crossing |

When I route I should get
    | from | to | speed   | weight | time | #            |
    | a    | c  | 15 km/h | 30.8   | 48s  | no crossroad |
    | a    | b  | 15 km/h | 15.4   | 24s  | no crossroad |
    | b    | c  | 15 km/h | 15.4   | 24s  | no crossroad |

After digging deeper, I found the explanation in graph_compressor.cpp.

In the first test (single way), node b gets compressed, but before compression, turn penalties are computed because the node is detected as an obstacle. A fake turn is then created with has_traffic_light = true by default — even though this is not a traffic light but only a crossing.

This incorrect has_traffic_light = true is passed to my process_turn Lua function, which assumes there is a traffic light and applies the corresponding penalty.

What is even more surprising is that although obstacles allow specifying weight and duration during creation (in Lua), these values are not used during this phase.

Question

Is this behavior expected?
Should obstacle-defined weight/duration be used here, or should the fake turn not assume has_traffic_light = true for crossings?
How can I be sure the weight and duration penalties defined for obstacles in Lua are correctly applied to the graph ?
I’d be interested to know whether this is a bug or an intended design.

Steps to reproduce

Please provide the steps required to reproduce your problem.

• osrm-backend v6.0.0
• Custom process_turn lua function that apply penalty on weight and duration if turn.has_traffic_light = true

Thanks in advance !

[Ephtolens]

I've been digging a bit for a few days and it seems to me that the best solution is to replace this part in src/extractor/graph_compressor.cpp

    get_obstacle_penalty(
        node_u, node_v, node_w, f1_data, f2_data, forward_penalties);
    get_obstacle_penalty(
        node_w, node_v, node_u, b1_data, b2_data, backward_penalties);

By this

const std::vector<Obstacle> obstacles = scripting_environment.m_obstacle_map.get(node_v);
for (const auto &obstacle : obstacles)
{                   
    if (
        obstacle.direction == Obstacle::Direction::Forward ||
        obstacle.direction == Obstacle::Direction::Both || 
        obstacle.direction == Obstacle::Direction::None
        )
    {
        forward_penalties.duration +=
            to_alias<EdgeDuration>(obstacle.duration * SECOND_TO_DECISECOND);
        forward_penalties.weight +=
            to_alias<EdgeWeight>(obstacle.weight * weight_multiplier);
    }
    if (
        obstacle.direction == Obstacle::Direction::Backward ||
        obstacle.direction == Obstacle::Direction::Both ||
        obstacle.direction == Obstacle::Direction::None
    )
    {
        backward_penalties.duration +=
            to_alias<EdgeDuration>(obstacle.duration * SECOND_TO_DECISECOND);
        backward_penalties.weight +=
            to_alias<EdgeWeight>(obstacle.weight * weight_multiplier);
    }
}

By the way, I think I've spotted an error in the get() function of the Obstacles object:

if ((from_id == SPECIAL_NODEID || from_id == from)

should be

if ((from == SPECIAL_NODEID || from_id == from)

In order to retrieve all obstacles no matter the value of from_id (from_id will never be equal to SPECIAL_NODEID)

[Ephtolens]

Maybe it could be great if @MarcelloPerathoner could have a look i think ?

[MarcelloPerathoner]

I'm looking into this. turn.has_traffic_light should not be set.

[MarcelloPerathoner]

As quick fix you can try this: in extractor/extraction_turn.hpp line 154 replace the 4th parameter in the constructor of ExtractionTurn: replace true with false. This should fix your unnecessary penalty. Let me know.

[Ephtolens]

Thanks for your quick answer, I've spotted this at first but I'm thinking now that this is more deepeer than I thought. Where in the code the weight and duration of an obstacle are used to adapt penalties ? Why don't we use them at the step I've mentionned during graoh compression ?

[MarcelloPerathoner]

The bug, as far as I can see right now, is that in extractor/graph_compressor.cpp line 268 the fake_turn always has traffic_light set.

osrm-backend/src/extractor/graph_compressor.cpp

Lines 267 to 273 in 01605f7

	// generate an artificial turn for the turn penalty generation
	ExtractionTurn fake_turn{
	from, via, to, from_edge, to_edge, no_other_roads, no_other_roads};
	scripting_environment.ProcessTurn(fake_turn);
	penalties.duration +=
	to_alias<EdgeDuration>(fake_turn.duration * SECOND_TO_DECISECOND);
	penalties.weight += to_alias<EdgeWeight>(fake_turn.weight * weight_multiplier);

This should be easy to fix.

As for the penalties, during graph compression they are only transferred from the deleted edge to the surviving edge. They are used in a later stage when the graph is searched.

[Ephtolens]

I'm sorry but I cannot see where the duration and weight, set in an obstacle, are transferred to the surviving edge or used anywhere to impact the graph.
I think this use of a fake turn is kind of hack instead of a real handling of the obstacle that I suggest above.

[MarcelloPerathoner]

That isn't supposed to happen. You must explicitly add them in process_turn.

See this example from profiles.md:

function process_turn(profile, turn)
  for _, obs in pairs(obstacle_map:get(turn.via)) do
    if obs.type == obstacle_type.barrier then
      turn.duration = turn.duration + obs.duration
    end
  end
  for _, obs in pairs(obstacle_map:get(
      turn.from, turn.via, obstacle_type.traffic_signal)) do
    turn.duration = turn.duration + obs.duration
  end
end

[Ephtolens]

Thanks @MarcelloPerathoner, I've totally missed that, part about obstacle handling. I'll have a look, your fix sound great 👌