Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Take stop signs into account during routing

Browse Source
This commit is contained in:
Siarhei Fedartsou 2022-10-28 22:04:02 +02:00
parent 72ea34f3b7
commit 36f3a5eec8
20 changed files with 132 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/extractor/edge_based_graph_factory.hpp
View File

@ -69,8 +69,8 @@ class EdgeBasedGraphFactory
EdgeBasedNodeDataContainer &node_data_container,
const CompressedEdgeContainer &compressed_edge_container,
const std::unordered_set<NodeID> &barrier_nodes,
const TrafficSignals &traffic_signals,
const StopSigns &stop_signs,
const TrafficFlowControlNodes &traffic_signals,
const TrafficFlowControlNodes &stop_signs,
const std::vector<util::Coordinate> &coordinates,
const NameTable &name_table,
const std::unordered_set<EdgeID> &segregated_edges,
@ -136,8 +136,8 @@ class EdgeBasedGraphFactory
const util::NodeBasedDynamicGraph &m_node_based_graph;
const std::unordered_set<NodeID> &m_barrier_nodes;
const TrafficSignals &m_traffic_signals;
const StopSigns &m_stop_signs;
const TrafficFlowControlNodes &m_traffic_signals;
const TrafficFlowControlNodes &m_stop_signs;
const CompressedEdgeContainer &m_compressed_edge_container;

33
include/extractor/extraction_containers.hpp
View File

@ -8,7 +8,6 @@
#include "extractor/scripting_environment.hpp"
#include "storage/tar_fwd.hpp"
#include "traffic_lights.hpp"
#include "traffic_signals.hpp"
#include <unordered_map>
@ -28,25 +27,22 @@ namespace extractor
class ExtractionContainers
{
using ReferencedWays = std::unordered_map<OSMWayID, NodesOfWay>;
using ReferencedTrafficSignals =
using ReferencedTrafficFlowControlNodes =
std::pair<std::unordered_set<OSMNodeID>, std::unordered_multimap<OSMNodeID, OSMNodeID>>;
using ReferencedStopSigns =
std::pair<std::unordered_set<OSMNodeID>, std::unordered_multimap<OSMNodeID, OSMNodeID>>;
// The relationship between way and nodes is lost during node preparation.
// We identify the ways and nodes relevant to restrictions/overrides/signals prior to
// node processing so that they can be referenced in the preparation phase.
ReferencedWays IdentifyRestrictionWays();
ReferencedWays IdentifyManeuverOverrideWays();
ReferencedTrafficSignals IdentifyTrafficSignals();
ReferencedStopSigns IdentifyStopSigns();
ReferencedTrafficFlowControlNodes IdentifyTrafficSignals();
ReferencedTrafficFlowControlNodes IdentifyStopSigns();
void PrepareNodes();
void PrepareManeuverOverrides(const ReferencedWays &maneuver_override_ways);
void PrepareRestrictions(const ReferencedWays &restriction_ways);
void PrepareTrafficSignals(const ReferencedTrafficSignals &referenced_traffic_signals);
void PrepareStopSigns(const ReferencedStopSigns &referenced_stop_signs);
void PrepareTrafficSignals(const ReferencedTrafficFlowControlNodes &referenced_traffic_signals);
void PrepareStopSigns(const ReferencedTrafficFlowControlNodes &referenced_stop_signs);
void PrepareEdges(ScriptingEnvironment &scripting_environment);
@ -61,10 +57,10 @@ class ExtractionContainers
using NameOffsets = std::vector<size_t>;
using WayIDVector = std::vector<OSMWayID>;
using WayNodeIDOffsets = std::vector<size_t>;
using InputTrafficSignal = std::pair<OSMNodeID, TrafficLightClass::Direction>;
using InputStopSign = std::pair<OSMNodeID, StopSign::Direction>;
using InputGiveWay = std::pair<OSMNodeID, GiveWay::Direction>;
using InputTrafficFlowControlNode = std::pair<OSMNodeID, TrafficFlowControlNodeDirection>;
std::vector<OSMNodeID> barrier_nodes;
NodeIDVector used_node_id_list;
NodeVector all_nodes_list;
@ -78,15 +74,14 @@ class ExtractionContainers
unsigned max_internal_node_id;
std::vector<InputTrafficSignal> external_traffic_signals;
TrafficSignals internal_traffic_signals;
std::vector<InputTrafficFlowControlNode> external_traffic_signals;
TrafficFlowControlNodes internal_traffic_signals;
std::vector<InputStopSign> external_stop_signs;
StopSigns internal_stop_signs;
std::vector<InputTrafficFlowControlNode> external_stop_signs;
TrafficFlowControlNodes internal_stop_signs;
std::vector<InputStopSign> external_give_ways;
GiveWaySigns internal_give_ways;
std::vector<InputTrafficFlowControlNode> external_give_ways;
TrafficFlowControlNodes internal_give_ways;
std::vector<NodeBasedEdge> used_edges;

16
include/extractor/extraction_node.hpp
View File

@ -1,7 +1,7 @@
#ifndef EXTRACTION_NODE_HPP
#define EXTRACTION_NODE_HPP
#include "traffic_lights.hpp"
#include "traffic_signals.hpp"
#include <cstdint>
namespace osrm
@ -12,20 +12,20 @@ namespace extractor
struct ExtractionNode
{
ExtractionNode() : traffic_lights(TrafficLightClass::NONE), barrier(false) {}
ExtractionNode() : traffic_lights(TrafficFlowControlNodeDirection::NONE), barrier(false) {}
void clear()
{
traffic_lights = TrafficLightClass::NONE;
stop_sign = StopSign::Direction::NONE;
give_way = GiveWay::Direction::NONE;
traffic_lights = TrafficFlowControlNodeDirection::NONE;
stop_sign = TrafficFlowControlNodeDirection::NONE;
give_way = TrafficFlowControlNodeDirection::NONE;
barrier = false;
}
TrafficLightClass::Direction traffic_lights;
TrafficFlowControlNodeDirection traffic_lights;
bool barrier;
StopSign::Direction stop_sign;
GiveWay::Direction give_way;
TrafficFlowControlNodeDirection stop_sign;
TrafficFlowControlNodeDirection give_way;
};
} // namespace extractor
} // namespace osrm

8
include/extractor/extractor.hpp
View File

@ -66,8 +66,8 @@ class Extractor
LaneDescriptionMap turn_lane_map;
std::vector<TurnRestriction> turn_restrictions;
std::vector<UnresolvedManeuverOverride> unresolved_maneuver_overrides;
TrafficSignals traffic_signals;
StopSigns stop_signs;
TrafficFlowControlNodes traffic_signals;
TrafficFlowControlNodes stop_signs;
std::unordered_set<NodeID> barriers;
std::vector<util::Coordinate> osm_coordinates;
extractor::PackedOSMIDs osm_node_ids;
@ -87,8 +87,8 @@ class Extractor
const std::vector<util::Coordinate> &coordinates,
const CompressedEdgeContainer &compressed_edge_container,
const std::unordered_set<NodeID> &barrier_nodes,
const TrafficSignals &traffic_signals,
const StopSigns &stop_signs,
const TrafficFlowControlNodes &traffic_signals,
const TrafficFlowControlNodes &stop_signs,
const RestrictionGraph &restriction_graph,
const std::unordered_set<EdgeID> &segregated_edges,
const NameTable &name_table,

2
include/extractor/extractor_callbacks.hpp
View File

@ -10,6 +10,7 @@
#include <string>
#include <unordered_map>
#include <unordered_set>
namespace osmium
{
@ -72,6 +73,7 @@ class ExtractorCallbacks
bool fallback_to_duration;
bool force_split_edges;
public:
using ClassesMap = std::unordered_map<std::string, ClassData>;

4
include/extractor/graph_compressor.hpp
View File

@ -26,8 +26,8 @@ class GraphCompressor
public:
void Compress(const std::unordered_set<NodeID> &barrier_nodes,
const TrafficSignals &traffic_signals,
const StopSigns &stop_signs,
const TrafficFlowControlNodes &traffic_signals,
const TrafficFlowControlNodes &stop_signs,
ScriptingEnvironment &scripting_environment,
std::vector<TurnRestriction> &turn_restrictions,
std::vector<UnresolvedManeuverOverride> &maneuver_overrides,

8
include/extractor/node_based_graph_factory.hpp
View File

@ -41,8 +41,8 @@ class NodeBasedGraphFactory
NodeBasedGraphFactory(ScriptingEnvironment &scripting_environment,
std::vector<TurnRestriction> &turn_restrictions,
std::vector<UnresolvedManeuverOverride> &maneuver_overrides,
const TrafficSignals &traffic_signals,
const StopSigns &stop_signs,
const TrafficFlowControlNodes &traffic_signals,
const TrafficFlowControlNodes &stop_signs,
std::unordered_set<NodeID> &&barriers,
std::vector<util::Coordinate> &&coordinates,
@ -75,8 +75,8 @@ class NodeBasedGraphFactory
void Compress(ScriptingEnvironment &scripting_environment,
std::vector<TurnRestriction> &turn_restrictions,
std::vector<UnresolvedManeuverOverride> &maneuver_overrides,
const TrafficSignals &traffic_signals,
const StopSigns &stop_signs);
const TrafficFlowControlNodes &traffic_signals,
const TrafficFlowControlNodes &stop_signs);
// Most ways are bidirectional, making the geometry in forward and backward direction the same,
// except for reversal. We make use of this fact by keeping only one representation of the

56
include/extractor/traffic_lights.hpp
View File

@ -1,56 +0,0 @@
#ifndef OSRM_EXTRACTOR_TRAFFIC_LIGHTS_DATA_HPP_
#define OSRM_EXTRACTOR_TRAFFIC_LIGHTS_DATA_HPP_
#include <cstdint>
namespace osrm
{
namespace extractor
{
namespace TrafficLightClass
{
// The traffic light annotation is extracted from node tags.
// The directions in which the traffic light applies are relative to the way containing the node.
enum Direction
{
NONE = 0,
DIRECTION_ALL = 1,
DIRECTION_FORWARD = 2,
DIRECTION_REVERSE = 3
};
} // namespace TrafficLightClass
// Stop Signs tagged on nodes can be present or not. In addition Stop Signs have
// an optional way direction they apply to. If the direction is unknown from the
// data we have to compute by checking the distance to the next intersection.
//
// Impl. detail: namespace + enum instead of enum class to make Luabind happy
namespace StopSign
{
enum Direction : std::uint8_t
{
NONE = 0,
DIRECTION_ALL = 1,
DIRECTION_FORWARD = 2,
DIRECTION_REVERSE = 3
};
}
// Give Way is the complement to priority roads. Tagging is the same as Stop Signs.
// See explanation above.
namespace GiveWay
{
enum Direction : std::uint8_t
{
NONE = 0,
DIRECTION_ALL = 1,
DIRECTION_FORWARD = 2,
DIRECTION_REVERSE = 3
};
}
} // namespace extractor
} // namespace osrm
#endif // OSRM_EXTRACTOR_TRAFFIC_LIGHTS_DATA_HPP_

30
include/extractor/traffic_signals.hpp
View File

@ -11,26 +11,36 @@ namespace osrm
namespace extractor
{
// TODO: better naming
struct RoadObjects
// Stop Signs tagged on nodes can be present or not. In addition Stop Signs have
// an optional way direction they apply to. If the direction is unknown from the
// data we have to compute by checking the distance to the next intersection.
//
// Impl. detail: namespace + enum instead of enum class to make Luabind happy
// The traffic light annotation is extracted from node tags.
// The directions in which the traffic light applies are relative to the way containing the node.
enum class TrafficFlowControlNodeDirection : std::uint8_t
{
NONE = 0,
ALL = 1,
FORWARD = 2,
REVERSE = 3
};
// represents traffic lights, stop signs, give way signs, etc.
struct TrafficFlowControlNodes
{
std::unordered_set<NodeID> bidirectional_nodes;
std::unordered_set<std::pair<NodeID, NodeID>, boost::hash<std::pair<NodeID, NodeID>>>
unidirectional_segments;
inline bool HasSignal(NodeID from, NodeID to) const
inline bool Has(NodeID from, NodeID to) const
{
return bidirectional_nodes.count(to) > 0 || unidirectional_segments.count({from, to}) > 0;
}
};
struct TrafficSignals final : public RoadObjects {};
// TODO: better naming ?
struct StopSigns final : public RoadObjects {};
struct GiveWaySigns final : public RoadObjects {};
} // namespace extractor
} // namespace osrm

10
profiles/lib/give_way.lua
View File

@ -6,17 +6,15 @@ function GiveWay.get_value(node)
local direction = node:get_value_by_key("direction")
if direction then
if "forward" == direction then
return give_way.direction_forward
return traffic_flow_control_direction.direction_forward
end
if "backward" == direction then
return give_way.direction_reverse
return traffic_flow_control_direction.direction_reverse
end
end
-- return give_way.direction_all
return true
return traffic_flow_control_direction.direction_all
end
-- return give_way.none
return false
return traffic_flow_control_direction.none
end
return GiveWay

8
profiles/lib/stop_sign.lua
View File

@ -6,15 +6,15 @@ function StopSign.get_value(node)
local direction = node:get_value_by_key("direction")
if direction then
if "forward" == direction then
return stop_sign.direction_forward
return traffic_flow_control_direction.direction_forward
end
if "backward" == direction then
return stop_sign.direction_reverse
return traffic_flow_control_direction.direction_reverse
end
end
return stop_sign.direction_all
return traffic_flow_control_direction.direction_all
end
return stop_sign.none
return traffic_flow_control_direction.none
end
return StopSign

8
src/extractor/edge_based_graph_factory.cpp
View File

@ -59,8 +59,8 @@ EdgeBasedGraphFactory::EdgeBasedGraphFactory(
EdgeBasedNodeDataContainer &node_data_container,
const CompressedEdgeContainer &compressed_edge_container,
const std::unordered_set<NodeID> &barrier_nodes,
const TrafficSignals &traffic_signals,
const StopSigns &stop_signs,
const TrafficFlowControlNodes &traffic_signals,
const TrafficFlowControlNodes &stop_signs,
const std::vector<util::Coordinate> &coordinates,
const NameTable &name_table,
const std::unordered_set<EdgeID> &segregated_edges,
@ -643,8 +643,8 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
// 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_stop_sign = m_stop_signs.HasSignal(from_node, intersection_node);
const auto is_traffic_light = m_traffic_signals.Has(from_node, intersection_node);
const auto is_stop_sign = m_stop_signs.Has(from_node, intersection_node);
std::cerr << "IS STOP SIGN " << is_stop_sign << std::endl;
const auto is_uturn =
guidance::getTurnDirection(turn_angle) == guidance::DirectionModifier::UTurn;

32
src/extractor/extraction_containers.cpp
View File

@ -939,7 +939,7 @@ ExtractionContainers::ReferencedWays ExtractionContainers::IdentifyManeuverOverr
}
void ExtractionContainers::PrepareTrafficSignals(
const ExtractionContainers::ReferencedTrafficSignals &referenced_traffic_signals)
const ReferencedTrafficFlowControlNodes &referenced_traffic_signals)
{
const auto &bidirectional_signal_nodes = referenced_traffic_signals.first;
const auto &unidirectional_signal_segments = referenced_traffic_signals.second;
@ -983,7 +983,7 @@ void ExtractionContainers::PrepareTrafficSignals(
}
// TODO: copy-paste
void ExtractionContainers::PrepareStopSigns(const ReferencedStopSigns &referenced_stop_signs) {
void ExtractionContainers::PrepareStopSigns(const ReferencedTrafficFlowControlNodes &referenced_stop_signs) {
const auto &bidirectional_signal_nodes = referenced_stop_signs.first;
const auto &unidirectional_signal_segments = referenced_stop_signs.second;
@ -1211,7 +1211,7 @@ ExtractionContainers::ReferencedWays ExtractionContainers::IdentifyRestrictionWa
}
// TODO: copy-paste
ExtractionContainers::ReferencedStopSigns ExtractionContainers::IdentifyStopSigns()
ExtractionContainers::ReferencedTrafficFlowControlNodes ExtractionContainers::IdentifyStopSigns()
{
util::UnbufferedLog log;
log << "Collecting traffic signal information on " << external_stop_signs.size()
@ -1219,7 +1219,7 @@ ExtractionContainers::ReferencedStopSigns ExtractionContainers::IdentifyStopSign
TIMER_START(identify_traffic_signals);
// Temporary store for nodes containing a unidirectional signal.
std::unordered_map<OSMNodeID, StopSign::Direction> unidirectional_signals;
std::unordered_map<OSMNodeID, TrafficFlowControlNodeDirection> unidirectional_signals;
// For each node that has a unidirectional traffic signal, we store the node(s)
// that lead up to the signal.
@ -1228,14 +1228,14 @@ ExtractionContainers::ReferencedStopSigns ExtractionContainers::IdentifyStopSign
std::unordered_set<OSMNodeID> bidirectional_signals;
const auto mark_signals = [&](auto const &traffic_signal) {
if (traffic_signal.second == StopSign::DIRECTION_FORWARD ||
traffic_signal.second == StopSign::DIRECTION_REVERSE)
if (traffic_signal.second == TrafficFlowControlNodeDirection::FORWARD ||
traffic_signal.second == TrafficFlowControlNodeDirection::REVERSE)
{
unidirectional_signals.insert({traffic_signal.first, traffic_signal.second});
}
else
{
BOOST_ASSERT(traffic_signal.second == StopSign::DIRECTION_ALL);
BOOST_ASSERT(traffic_signal.second == TrafficFlowControlNodeDirection::ALL);
bidirectional_signals.insert(traffic_signal.first);
}
};
@ -1253,7 +1253,7 @@ ExtractionContainers::ReferencedStopSigns ExtractionContainers::IdentifyStopSign
const auto sig = unidirectional_signals.find(*node_it);
if (sig != unidirectional_signals.end())
{
if (sig->second == StopSign::DIRECTION_FORWARD)
if (sig->second == TrafficFlowControlNodeDirection::FORWARD)
{
if (node_it != node_start_offset)
{
@ -1263,7 +1263,7 @@ ExtractionContainers::ReferencedStopSigns ExtractionContainers::IdentifyStopSign
}
else
{
BOOST_ASSERT(sig->second == StopSign::DIRECTION_REVERSE);
BOOST_ASSERT(sig->second == TrafficFlowControlNodeDirection::REVERSE);
if (node_it + 1 != node_end_offset)
{
// Next node leads to signal
@ -1299,7 +1299,7 @@ ExtractionContainers::ReferencedStopSigns ExtractionContainers::IdentifyStopSign
}
ExtractionContainers::ReferencedTrafficSignals ExtractionContainers::IdentifyTrafficSignals()
ExtractionContainers::ReferencedTrafficFlowControlNodes ExtractionContainers::IdentifyTrafficSignals()
{
util::UnbufferedLog log;
log << "Collecting traffic signal information on " << external_traffic_signals.size()
@ -1307,7 +1307,7 @@ ExtractionContainers::ReferencedTrafficSignals ExtractionContainers::IdentifyTra
TIMER_START(identify_traffic_signals);
// Temporary store for nodes containing a unidirectional signal.
std::unordered_map<OSMNodeID, TrafficLightClass::Direction> unidirectional_signals;
std::unordered_map<OSMNodeID, TrafficFlowControlNodeDirection> unidirectional_signals;
// For each node that has a unidirectional traffic signal, we store the node(s)
// that lead up to the signal.
@ -1316,14 +1316,14 @@ ExtractionContainers::ReferencedTrafficSignals ExtractionContainers::IdentifyTra
std::unordered_set<OSMNodeID> bidirectional_signals;
const auto mark_signals = [&](auto const &traffic_signal) {
if (traffic_signal.second == TrafficLightClass::DIRECTION_FORWARD ||
traffic_signal.second == TrafficLightClass::DIRECTION_REVERSE)
if (traffic_signal.second == TrafficFlowControlNodeDirection::FORWARD ||
traffic_signal.second == TrafficFlowControlNodeDirection::REVERSE)
{
unidirectional_signals.insert({traffic_signal.first, traffic_signal.second});
}
else
{
BOOST_ASSERT(traffic_signal.second == TrafficLightClass::DIRECTION_ALL);
BOOST_ASSERT(traffic_signal.second == TrafficFlowControlNodeDirection::ALL);
bidirectional_signals.insert(traffic_signal.first);
}
};
@ -1341,7 +1341,7 @@ ExtractionContainers::ReferencedTrafficSignals ExtractionContainers::IdentifyTra
const auto sig = unidirectional_signals.find(*node_it);
if (sig != unidirectional_signals.end())
{
if (sig->second == TrafficLightClass::DIRECTION_FORWARD)
if (sig->second == TrafficFlowControlNodeDirection::FORWARD)
{
if (node_it != node_start_offset)
{
@ -1351,7 +1351,7 @@ ExtractionContainers::ReferencedTrafficSignals ExtractionContainers::IdentifyTra
}
else
{
BOOST_ASSERT(sig->second == TrafficLightClass::DIRECTION_REVERSE);
BOOST_ASSERT(sig->second == TrafficFlowControlNodeDirection::REVERSE);
if (node_it + 1 != node_end_offset)
{
// Next node leads to signal

4
src/extractor/extractor.cpp
View File

@ -728,8 +728,8 @@ EdgeID Extractor::BuildEdgeExpandedGraph(
const std::vector<util::Coordinate> &coordinates,
const CompressedEdgeContainer &compressed_edge_container,
const std::unordered_set<NodeID> &barrier_nodes,
const TrafficSignals &traffic_signals,
const StopSigns &stop_signs,
const TrafficFlowControlNodes &traffic_signals,
const TrafficFlowControlNodes &stop_signs,
const RestrictionGraph &restriction_graph,
const std::unordered_set<EdgeID> &segregated_edges,
const NameTable &name_table,

4
src/extractor/extractor_callbacks.cpp
View File

@ -78,7 +78,7 @@ void ExtractorCallbacks::ProcessNode(const osmium::Node &input_node,
{
external_memory.barrier_nodes.push_back(id);
}
if (result_node.traffic_lights != TrafficLightClass::NONE)
if (result_node.traffic_lights != TrafficFlowControlNodeDirection::NONE)
{
external_memory.external_traffic_signals.push_back({id, result_node.traffic_lights});
}
@ -86,7 +86,7 @@ void ExtractorCallbacks::ProcessNode(const osmium::Node &input_node,
// {
// external_memory.external_give_ways.push_back({id, result_node.give_way});
// }
if (result_node.stop_sign != StopSign::Direction::NONE)
if (result_node.stop_sign != TrafficFlowControlNodeDirection::NONE)
{
std::cerr << "FOUND STOP SIGN\n";
external_memory.external_stop_signs.push_back({id, result_node.stop_sign});

14
src/extractor/graph_compressor.cpp
View File

@ -22,8 +22,8 @@ namespace extractor
static constexpr int SECOND_TO_DECISECOND = 10;
void GraphCompressor::Compress(const std::unordered_set<NodeID> &barrier_nodes,
const TrafficSignals &traffic_signals,
const StopSigns &stop_signs,
const TrafficFlowControlNodes &traffic_signals,
const TrafficFlowControlNodes &stop_signs,
ScriptingEnvironment &scripting_environment,
std::vector<TurnRestriction> &turn_restrictions,
std::vector<UnresolvedManeuverOverride> &maneuver_overrides,
@ -210,11 +210,11 @@ void GraphCompressor::Compress(const std::unordered_set<NodeID> &barrier_nodes,
rev_edge_data2.annotation_data, rev_edge_data1.annotation_data);
// Add node penalty when compress edge crosses a traffic signal
const bool has_forward_signal = traffic_signals.HasSignal(node_u, node_v);
const bool has_reverse_signal = traffic_signals.HasSignal(node_w, node_v);
const bool has_forward_signal = traffic_signals.Has(node_u, node_v);
const bool has_reverse_signal = traffic_signals.Has(node_w, node_v);
const bool has_forward_stop_sign = stop_signs.HasSignal(node_u, node_v);
const bool has_reverse_stop_sign = stop_signs.HasSignal(node_w, node_v);
const bool has_forward_stop_sign = stop_signs.Has(node_u, node_v);
const bool has_reverse_stop_sign = stop_signs.Has(node_w, node_v);
// TODO: can we have a case when we have both traffic signal and stop sign? how should we handle it?
EdgeDuration forward_node_duration_penalty = MAXIMAL_EDGE_DURATION;
@ -258,6 +258,8 @@ void GraphCompressor::Compress(const std::unordered_set<NodeID> &barrier_nodes,
roads_on_the_left);
scripting_environment.ProcessTurn(extraction_turn);
std::cerr << "HAS STOP SIGN = " << extraction_turn.has_stop_sign << " " << extraction_turn.duration << std::endl;
auto update_direction_penalty =
[&extraction_turn, weight_multiplier](bool signal,
EdgeDuration &duration_penalty,

8
src/extractor/node_based_graph_factory.cpp
View File

@ -20,8 +20,8 @@ NodeBasedGraphFactory::NodeBasedGraphFactory(
ScriptingEnvironment &scripting_environment,
std::vector<TurnRestriction> &turn_restrictions,
std::vector<UnresolvedManeuverOverride> &maneuver_overrides,
const TrafficSignals &traffic_signals,
const StopSigns &stop_signs,
const TrafficFlowControlNodes &traffic_signals,
const TrafficFlowControlNodes &stop_signs,
std::unordered_set<NodeID> &&barriers,
std::vector<util::Coordinate> &&coordinates,
extractor::PackedOSMIDs &&osm_node_ids,
@ -76,8 +76,8 @@ 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,
const StopSigns &stop_signs)
const TrafficFlowControlNodes &traffic_signals,
const TrafficFlowControlNodes &stop_signs)
{
GraphCompressor graph_compressor;
graph_compressor.Compress(barriers,

52
src/extractor/scripting_environment_lua.cpp
View File

@ -284,35 +284,26 @@ void Sol2ScriptingEnvironment::InitContext(LuaScriptingContext &context)
[&context, &get_location_tag](const osmium::Node &node, const char *key) {
return get_location_tag(context, node.location(), key);
});
// just for backward compatibility
// TODO: remove in v6
context.state.new_enum("traffic_lights",
"none",
extractor::TrafficLightClass::NONE,
extractor::TrafficFlowControlNodeDirection::NONE,
"direction_all",
extractor::TrafficLightClass::DIRECTION_ALL,
extractor::TrafficFlowControlNodeDirection::ALL,
"direction_forward",
extractor::TrafficLightClass::DIRECTION_FORWARD,
extractor::TrafficFlowControlNodeDirection::FORWARD,
"direction_reverse",
extractor::TrafficLightClass::DIRECTION_REVERSE);
context.state.new_enum("stop_sign",
extractor::TrafficFlowControlNodeDirection::REVERSE);
context.state.new_enum("traffic_flow_control_direction",
"none",
extractor::StopSign::NONE,
extractor::TrafficFlowControlNodeDirection::NONE,
"direction_all",
extractor::StopSign::DIRECTION_ALL,
extractor::TrafficFlowControlNodeDirection::ALL,
"direction_forward",
extractor::StopSign::DIRECTION_FORWARD,
extractor::TrafficFlowControlNodeDirection::FORWARD,
"direction_reverse",
extractor::StopSign::DIRECTION_REVERSE);
context.state.new_enum("give_way",
"none",
extractor::GiveWay::NONE,
"direction_all",
extractor::GiveWay::DIRECTION_ALL,
"direction_forward",
extractor::GiveWay::DIRECTION_FORWARD,
"direction_reverse",
extractor::GiveWay::DIRECTION_REVERSE);
extractor::TrafficFlowControlNodeDirection::REVERSE);
context.state.new_usertype<ExtractionNode>(
"ResultNode",
"traffic_lights",
@ -324,29 +315,29 @@ void Sol2ScriptingEnvironment::InitContext(LuaScriptingContext &context)
// state to the node is converted to the class enum
// TODO: Make a breaking API change and remove this option.
bool val = obj.as<bool>();
node.traffic_lights = (val) ? TrafficLightClass::DIRECTION_ALL
: TrafficLightClass::NONE;
node.traffic_lights = (val) ? TrafficFlowControlNodeDirection::ALL
: TrafficFlowControlNodeDirection::NONE;
return;
}
BOOST_ASSERT(obj.is<TrafficLightClass::Direction>());
BOOST_ASSERT(obj.is<TrafficFlowControlNodeDirection>());
{
TrafficLightClass::Direction val =
obj.as<TrafficLightClass::Direction>();
TrafficFlowControlNodeDirection val =
obj.as<TrafficFlowControlNodeDirection>();
node.traffic_lights = val;
}
}),
"stop_sign",
sol::property([](const ExtractionNode &node) { return node.stop_sign; },
[](ExtractionNode &node, const sol::object &obj) {
BOOST_ASSERT(obj.is<StopSign::Direction>());
node.stop_sign = obj.as<StopSign::Direction>();
BOOST_ASSERT(obj.is<TrafficFlowControlNodeDirection>());
node.stop_sign = obj.as<TrafficFlowControlNodeDirection>();
}),
"give_way",
sol::property([](const ExtractionNode &node) { return node.give_way; },
[](ExtractionNode &node, const sol::object &obj) {
BOOST_ASSERT(obj.is<GiveWay::Direction>());
node.give_way = obj.as<GiveWay::Direction>();
BOOST_ASSERT(obj.is<TrafficFlowControlNodeDirection>());
node.give_way = obj.as<TrafficFlowControlNodeDirection>();
}),
"barrier",
&ExtractionNode::barrier);
@ -1170,7 +1161,8 @@ void Sol2ScriptingEnvironment::ProcessTurn(ExtractionTurn &turn)
else {
// cap turn weight to max turn weight, which depend on weight precision
turn.weight = std::min(turn.weight, context.properties.GetMaxTurnWeight());
std::cerr << "NO FALLBACK " << turn.weight << std::endl;
std::cerr << "NO FALLBACK " << turn.weight << " " << turn.duration << std::endl;
}
}

10
unit_tests/extractor/graph_compressor.cpp
View File

@ -65,7 +65,7 @@ BOOST_AUTO_TEST_CASE(long_road_test)
GraphCompressor compressor;
std::unordered_set<NodeID> barrier_nodes;
TrafficSignals traffic_lights;
TrafficFlowControlNodes traffic_lights;
std::vector<TurnRestriction> restrictions;
std::vector<NodeBasedEdgeAnnotation> annotations(1);
CompressedEdgeContainer container;
@ -111,7 +111,7 @@ BOOST_AUTO_TEST_CASE(loop_test)
GraphCompressor compressor;
std::unordered_set<NodeID> barrier_nodes;
TrafficSignals traffic_lights;
TrafficFlowControlNodes traffic_lights;
std::vector<TurnRestriction> restrictions;
CompressedEdgeContainer container;
std::vector<NodeBasedEdgeAnnotation> annotations(1);
@ -174,7 +174,7 @@ BOOST_AUTO_TEST_CASE(t_intersection)
GraphCompressor compressor;
std::unordered_set<NodeID> barrier_nodes;
TrafficSignals traffic_lights;
TrafficFlowControlNodes traffic_lights;
std::vector<NodeBasedEdgeAnnotation> annotations(1);
std::vector<TurnRestriction> restrictions;
CompressedEdgeContainer container;
@ -217,7 +217,7 @@ BOOST_AUTO_TEST_CASE(street_name_changes)
GraphCompressor compressor;
std::unordered_set<NodeID> barrier_nodes;
TrafficSignals traffic_lights;
TrafficFlowControlNodes traffic_lights;
std::vector<NodeBasedEdgeAnnotation> annotations(2);
std::vector<TurnRestriction> restrictions;
CompressedEdgeContainer container;
@ -255,7 +255,7 @@ BOOST_AUTO_TEST_CASE(direction_changes)
GraphCompressor compressor;
std::unordered_set<NodeID> barrier_nodes;
TrafficSignals traffic_lights;
TrafficFlowControlNodes traffic_lights;
std::vector<NodeBasedEdgeAnnotation> annotations(1);
std::vector<TurnRestriction> restrictions;
CompressedEdgeContainer container;

6
unit_tests/extractor/intersection_analysis_tests.cpp
View File

@ -19,7 +19,7 @@ using Graph = util::NodeBasedDynamicGraph;
BOOST_AUTO_TEST_CASE(simple_intersection_connectivity)
{
std::unordered_set<NodeID> barrier_nodes{6};
TrafficSignals traffic_lights;
TrafficFlowControlNodes traffic_lights;
std::vector<NodeBasedEdgeAnnotation> annotations{
{EMPTY_NAMEID, 0, INAVLID_CLASS_DATA, TRAVEL_MODE_DRIVING, false},
{EMPTY_NAMEID, 1, INAVLID_CLASS_DATA, TRAVEL_MODE_DRIVING, false}};
@ -152,7 +152,7 @@ BOOST_AUTO_TEST_CASE(simple_intersection_connectivity)
BOOST_AUTO_TEST_CASE(roundabout_intersection_connectivity)
{
std::unordered_set<NodeID> barrier_nodes;
TrafficSignals traffic_lights;
TrafficFlowControlNodes traffic_lights;
std::vector<NodeBasedEdgeAnnotation> annotations;
std::vector<TurnRestriction> restrictions;
CompressedEdgeContainer container;
@ -259,7 +259,7 @@ BOOST_AUTO_TEST_CASE(roundabout_intersection_connectivity)
BOOST_AUTO_TEST_CASE(skip_degree_two_nodes)
{
std::unordered_set<NodeID> barrier_nodes{1};
TrafficSignals traffic_lights = {{2}, {}};
TrafficFlowControlNodes traffic_lights = {{2}, {}};
std::vector<NodeBasedEdgeAnnotation> annotations(1);
std::vector<TurnRestriction> restrictions;
CompressedEdgeContainer container;