b17cbb4c47
Currently OSRM parses traffic signal nodes without consideration for the direction in which the signal applies. This can lead to duplicated routing penalties, especially when a forward and backward signal are in close proximity on a way. This commit adds support for directed signals to the extraction and graph creation. Signal penalties are only applied in the direction specified by the OSM tag. We add the assignment of traffic directions to the lua scripts, maintaining backwards compatibility with the existing boolean traffic states. As part of the changes to the internal structures used for tracking traffic signals during extraction, we stop serialising/deserialising signals to the `.osrm` file. The traffic signals are only used by `osrm-extract` so whilst this is a data format change, it will not break any existing user processes.
98 lines
3.7 KiB
C++
98 lines
3.7 KiB
C++
#ifndef EXTRACTION_CONTAINERS_HPP
|
|
#define EXTRACTION_CONTAINERS_HPP
|
|
|
|
#include "extractor/internal_extractor_edge.hpp"
|
|
#include "extractor/nodes_of_way.hpp"
|
|
#include "extractor/query_node.hpp"
|
|
#include "extractor/restriction.hpp"
|
|
#include "extractor/scripting_environment.hpp"
|
|
|
|
#include "storage/tar_fwd.hpp"
|
|
#include "traffic_lights.hpp"
|
|
#include "traffic_signals.hpp"
|
|
|
|
#include <unordered_map>
|
|
#include <unordered_set>
|
|
|
|
namespace osrm
|
|
{
|
|
namespace extractor
|
|
{
|
|
|
|
/**
|
|
* Uses memory containers to store all the data that
|
|
* is collected by the extractor callbacks.
|
|
*
|
|
* The data is the filtered, aggregated and finally written to disk.
|
|
*/
|
|
class ExtractionContainers
|
|
{
|
|
using ReferencedWays = std::unordered_map<OSMWayID, NodesOfWay>;
|
|
using ReferencedTrafficSignals =
|
|
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();
|
|
|
|
void PrepareNodes();
|
|
void PrepareManeuverOverrides(const ReferencedWays &maneuver_override_ways);
|
|
void PrepareRestrictions(const ReferencedWays &restriction_ways);
|
|
void PrepareTrafficSignals(const ReferencedTrafficSignals &referenced_traffic_signals);
|
|
void PrepareEdges(ScriptingEnvironment &scripting_environment);
|
|
|
|
void WriteNodes(storage::tar::FileWriter &file_out) const;
|
|
void WriteEdges(storage::tar::FileWriter &file_out) const;
|
|
void WriteMetadata(storage::tar::FileWriter &file_out) const;
|
|
void WriteCharData(const std::string &file_name);
|
|
|
|
public:
|
|
using NodeIDVector = std::vector<OSMNodeID>;
|
|
using NodeVector = std::vector<QueryNode>;
|
|
using EdgeVector = std::vector<InternalExtractorEdge>;
|
|
using AnnotationDataVector = std::vector<NodeBasedEdgeAnnotation>;
|
|
using NameCharData = std::vector<unsigned char>;
|
|
using NameOffsets = std::vector<size_t>;
|
|
using WayIDVector = std::vector<OSMWayID>;
|
|
using WayNodeIDOffsets = std::vector<size_t>;
|
|
using InputTrafficSignal = std::pair<OSMNodeID, TrafficLightClass::Direction>;
|
|
|
|
std::vector<OSMNodeID> barrier_nodes;
|
|
NodeIDVector used_node_id_list;
|
|
NodeVector all_nodes_list;
|
|
EdgeVector all_edges_list;
|
|
AnnotationDataVector all_edges_annotation_data_list;
|
|
NameCharData name_char_data;
|
|
NameOffsets name_offsets;
|
|
WayIDVector ways_list;
|
|
// Offsets into used nodes for each way_list entry
|
|
WayNodeIDOffsets way_node_id_offsets;
|
|
|
|
unsigned max_internal_node_id;
|
|
|
|
std::vector<InputTrafficSignal> external_traffic_signals;
|
|
TrafficSignals internal_traffic_signals;
|
|
|
|
// List of restrictions (conditional and unconditional) before we transform them into the
|
|
// output types. Input containers reference OSMNodeIDs. We can only transform them to the
|
|
// correct internal IDs after we've read everything. Without a multi-parse approach,
|
|
// we have to remember the output restrictions before converting them to the internal formats
|
|
std::vector<InputTurnRestriction> restrictions_list;
|
|
std::vector<TurnRestriction> turn_restrictions;
|
|
|
|
std::vector<InputManeuverOverride> external_maneuver_overrides_list;
|
|
std::vector<UnresolvedManeuverOverride> internal_maneuver_overrides;
|
|
|
|
ExtractionContainers();
|
|
|
|
void PrepareData(ScriptingEnvironment &scripting_environment,
|
|
const std::string &osrm_path,
|
|
const std::string &names_data_path);
|
|
};
|
|
} // namespace extractor
|
|
} // namespace osrm
|
|
|
|
#endif /* EXTRACTION_CONTAINERS_HPP */
|