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

Use edge_id as index in ebg_node_data_container

Browse Source
This commit is contained in:
Michael Krasnyk 2017-05-03 11:48:43 +02:00 committed by Patrick Niklaus
parent f1e4349c82
commit be1acae20c
3 changed files with 65 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
include/extractor/edge_based_graph_factory.hpp
View File

@ -150,19 +150,14 @@ class EdgeBasedGraphFactory
unsigned RenumberEdges(); unsigned RenumberEdges();
std::vector<NBGToEBG> GenerateEdgeExpandedNodes(); std::vector<NBGToEBG> GenerateEdgeExpandedNodes(const std::string &node_data_filename);
std::unordered_map<EdgeID, NodeID> void GenerateEdgeExpandedEdges(ScriptingEnvironment &scripting_environment,
GenerateEdgeExpandedNodesData(const std::string &node_data_filename) const; const std::string &original_edge_data_filename,
const std::string &turn_lane_data_filename,
void const std::string &turn_weight_penalties_filename,
GenerateEdgeExpandedEdges(ScriptingEnvironment &scripting_environment, const std::string &turn_duration_penalties_filename,
const std::unordered_map<EdgeID, NodeID> &index_nbg_edgeid_ebg_nodeid, const std::string &turn_penalties_index_filename);
const std::string &original_edge_data_filename,
const std::string &turn_lane_data_filename,
const std::string &turn_weight_penalties_filename,
const std::string &turn_duration_penalties_filename,
const std::string &turn_penalties_index_filename);
NBGToEBG InsertEdgeBasedNode(const NodeID u, const NodeID v); NBGToEBG InsertEdgeBasedNode(const NodeID u, const NodeID v);

24
include/extractor/node_data_container.hpp
View File

@ -32,31 +32,37 @@ namespace detail
template <storage::Ownership Ownership> class EdgeBasedNodeDataContainerImpl template <storage::Ownership Ownership> class EdgeBasedNodeDataContainerImpl
{ {
template <typename T> using Vector = util::ViewOrVector<T, Ownership>; template <typename T> using Vector = util::ViewOrVector<T, Ownership>;
using TravelMode = extractor::TravelMode;
public: public:
EdgeBasedNodeDataContainerImpl() = default; EdgeBasedNodeDataContainerImpl() = default;
EdgeBasedNodeDataContainerImpl(std::size_t size)
: geometry_ids(size), name_ids(size), travel_modes(size)
{
}
EdgeBasedNodeDataContainerImpl(Vector<GeometryID> geometry_ids, EdgeBasedNodeDataContainerImpl(Vector<GeometryID> geometry_ids,
Vector<NameID> name_ids, Vector<NameID> name_ids,
Vector<extractor::TravelMode> travel_modes) Vector<TravelMode> travel_modes)
: geometry_ids(std::move(geometry_ids)), name_ids(std::move(name_ids)), : geometry_ids(std::move(geometry_ids)), name_ids(std::move(name_ids)),
travel_modes(std::move(travel_modes)) travel_modes(std::move(travel_modes))
{ {
} }
GeometryID GetGeometryID(const NodeID id) const { return geometry_ids[id]; } GeometryID GetGeometryID(const NodeID node_id) const { return geometry_ids[node_id]; }
extractor::TravelMode GetTravelMode(const NodeID id) const { return travel_modes[id]; } TravelMode GetTravelMode(const NodeID node_id) const { return travel_modes[node_id]; }
NameID GetNameID(const NodeID id) const { return name_ids[id]; } NameID GetNameID(const NodeID node_id) const { return name_ids[node_id]; }
// Used by EdgeBasedGraphFactory to fill data structure // Used by EdgeBasedGraphFactory to fill data structure
template <typename = std::enable_if<Ownership == storage::Ownership::Container>> template <typename = std::enable_if<Ownership == storage::Ownership::Container>>
void push_back(GeometryID geometry_id, NameID name_id, extractor::TravelMode travel_mode) void SetData(NodeID node_id, GeometryID geometry_id, NameID name_id, TravelMode travel_mode)
{ {
geometry_ids.push_back(geometry_id); geometry_ids[node_id] = geometry_id;
name_ids.push_back(name_id); name_ids[node_id] = name_id;
travel_modes.push_back(travel_mode); travel_modes[node_id] = travel_mode;
} }
friend void serialization::read<Ownership>(storage::io::FileReader &reader, friend void serialization::read<Ownership>(storage::io::FileReader &reader,
@ -68,7 +74,7 @@ template <storage::Ownership Ownership> class EdgeBasedNodeDataContainerImpl
private: private:
Vector<GeometryID> geometry_ids; Vector<GeometryID> geometry_ids;
Vector<NameID> name_ids; Vector<NameID> name_ids;
Vector<extractor::TravelMode> travel_modes; Vector<TravelMode> travel_modes;
}; };
} }

93
src/extractor/edge_based_graph_factory.cpp
View File

@ -168,7 +168,7 @@ NBGToEBG EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u, const N
} }
void EdgeBasedGraphFactory::Run(ScriptingEnvironment &scripting_environment, void EdgeBasedGraphFactory::Run(ScriptingEnvironment &scripting_environment,
const std::string &nodes_data_filename, const std::string &node_data_filename,
const std::string &turn_data_filename, const std::string &turn_data_filename,
const std::string &turn_lane_data_filename, const std::string &turn_lane_data_filename,
const std::string &turn_weight_penalties_filename, const std::string &turn_weight_penalties_filename,
@ -182,18 +182,13 @@ void EdgeBasedGraphFactory::Run(ScriptingEnvironment &scripting_environment,
TIMER_START(generate_nodes); TIMER_START(generate_nodes);
{ {
auto mapping = GenerateEdgeExpandedNodes(); auto mapping = GenerateEdgeExpandedNodes(node_data_filename);
files::writeNBGMapping(cnbg_ebg_mapping_path, mapping); files::writeNBGMapping(cnbg_ebg_mapping_path, mapping);
} }
TIMER_STOP(generate_nodes); TIMER_STOP(generate_nodes);
TIMER_START(generate_nodes_data);
auto index_nbg_edgeid_to_ebg_nodeid = GenerateEdgeExpandedNodesData(nodes_data_filename);
TIMER_STOP(generate_nodes_data);
TIMER_START(generate_edges); TIMER_START(generate_edges);
GenerateEdgeExpandedEdges(scripting_environment, GenerateEdgeExpandedEdges(scripting_environment,
index_nbg_edgeid_to_ebg_nodeid,
turn_data_filename, turn_data_filename,
turn_lane_data_filename, turn_lane_data_filename,
turn_weight_penalties_filename, turn_weight_penalties_filename,
@ -244,7 +239,8 @@ unsigned EdgeBasedGraphFactory::RenumberEdges()
} }
/// Creates the nodes in the edge expanded graph from edges in the node-based graph. /// Creates the nodes in the edge expanded graph from edges in the node-based graph.
std::vector<NBGToEBG> EdgeBasedGraphFactory::GenerateEdgeExpandedNodes() std::vector<NBGToEBG>
EdgeBasedGraphFactory::GenerateEdgeExpandedNodes(const std::string &node_data_filename)
{ {
std::vector<NBGToEBG> mapping; std::vector<NBGToEBG> mapping;
@ -293,53 +289,52 @@ std::vector<NBGToEBG> EdgeBasedGraphFactory::GenerateEdgeExpandedNodes()
BOOST_ASSERT(m_edge_based_node_list.size() == m_edge_based_node_is_startpoint.size()); BOOST_ASSERT(m_edge_based_node_list.size() == m_edge_based_node_is_startpoint.size());
BOOST_ASSERT(m_max_edge_id + 1 == m_edge_based_node_weights.size()); BOOST_ASSERT(m_max_edge_id + 1 == m_edge_based_node_weights.size());
{
// TODO: refactor saving edge-based node data with InsertEdgeBasedNode
EdgeBasedNodeDataExternalContainer ebg_node_data_container(m_max_edge_id + 1);
for (const auto nbg_node_id : util::irange(0u, m_node_based_graph->GetNumberOfNodes()))
{
for (const auto nbg_edge_id : m_node_based_graph->GetAdjacentEdgeRange(nbg_node_id))
{
const auto &nbg_edge_data = m_node_based_graph->GetEdgeData(nbg_edge_id);
if (nbg_edge_data.edge_id == SPECIAL_EDGEID)
continue;
const bool is_encoded_forwards =
m_compressed_edge_container.HasZippedEntryForForwardID(nbg_edge_id);
const bool is_encoded_backwards =
m_compressed_edge_container.HasZippedEntryForReverseID(nbg_edge_id);
BOOST_ASSERT(is_encoded_forwards || is_encoded_backwards);
auto geometry_id =
is_encoded_forwards
? m_compressed_edge_container.GetZippedPositionForForwardID(nbg_edge_id)
: is_encoded_backwards
? m_compressed_edge_container.GetZippedPositionForReverseID(
nbg_edge_id)
: SPECIAL_GEOMETRYID;
ebg_node_data_container.SetData(nbg_edge_data.edge_id,
GeometryID{geometry_id, is_encoded_forwards},
nbg_edge_data.name_id,
nbg_edge_data.travel_mode);
}
}
files::writeNodeData(node_data_filename, ebg_node_data_container);
}
util::Log() << "Generated " << m_edge_based_node_list.size() << " nodes in edge-expanded graph"; util::Log() << "Generated " << m_edge_based_node_list.size() << " nodes in edge-expanded graph";
return mapping; return mapping;
} }
/// Actually it also generates turn data and serializes them...
std::unordered_map<EdgeID, NodeID>
EdgeBasedGraphFactory::GenerateEdgeExpandedNodesData(const std::string &node_data_filename) const
{
// parallel_for( blocked_range<int>( 0, n ), avg, auto_partitioner( ) );
NodeID ebg_node_id = 0;
std::unordered_map<EdgeID, NodeID> index;
EdgeBasedNodeDataExternalContainer node_data_container;
for (auto node_id : util::irange(0u, m_node_based_graph->GetNumberOfNodes()))
{
for (auto edge_id : m_node_based_graph->GetAdjacentEdgeRange(node_id))
{
const EdgeData &edge_data = m_node_based_graph->GetEdgeData(edge_id);
const bool is_encoded_forwards =
m_compressed_edge_container.HasZippedEntryForForwardID(edge_id);
const bool is_encoded_backwards =
m_compressed_edge_container.HasZippedEntryForReverseID(edge_id);
if (is_encoded_forwards || is_encoded_backwards)
{
auto geometry_id =
is_encoded_forwards
? m_compressed_edge_container.GetZippedPositionForForwardID(edge_id)
: m_compressed_edge_container.GetZippedPositionForReverseID(edge_id);
BOOST_ASSERT(index.find(edge_id) == index.end());
index.insert({edge_id, ebg_node_id++});
node_data_container.push_back(GeometryID{geometry_id, is_encoded_forwards},
edge_data.name_id,
edge_data.travel_mode);
}
}
}
files::writeNodeData(node_data_filename, node_data_container);
return index;
}
/// Actually it also generates turn data and serializes them... /// Actually it also generates turn data and serializes them...
void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges( void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
ScriptingEnvironment &scripting_environment, ScriptingEnvironment &scripting_environment,
const std::unordered_map<EdgeID, NodeID> &nbg_edgeid_to_ebg_nodeid,
const std::string &turn_data_filename, const std::string &turn_data_filename,
const std::string &turn_lane_data_filename, const std::string &turn_lane_data_filename,
const std::string &turn_weight_penalties_filename, const std::string &turn_weight_penalties_filename,
@ -499,10 +494,8 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
BOOST_ASSERT(!edge_data2.reversed); BOOST_ASSERT(!edge_data2.reversed);
// the following is the core of the loop. // the following is the core of the loop.
BOOST_ASSERT(nbg_edgeid_to_ebg_nodeid.find(incoming_edge) !=
nbg_edgeid_to_ebg_nodeid.end());
turn_data_container.push_back( turn_data_container.push_back(
nbg_edgeid_to_ebg_nodeid.find(incoming_edge)->second, edge_data1.edge_id,
turn.instruction, turn.instruction,
turn.lane_data_id, turn.lane_data_id,
entry_class_id, entry_class_id,