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();
std::vector<NBGToEBG> GenerateEdgeExpandedNodes();
std::vector<NBGToEBG> GenerateEdgeExpandedNodes(const std::string &node_data_filename);
std::unordered_map<EdgeID, NodeID>
GenerateEdgeExpandedNodesData(const std::string &node_data_filename) const;
void
GenerateEdgeExpandedEdges(ScriptingEnvironment &scripting_environment,
const std::unordered_map<EdgeID, NodeID> &index_nbg_edgeid_ebg_nodeid,
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);
void GenerateEdgeExpandedEdges(ScriptingEnvironment &scripting_environment,
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);

24
include/extractor/node_data_container.hpp
View File

@ -32,31 +32,37 @@ namespace detail
template <storage::Ownership Ownership> class EdgeBasedNodeDataContainerImpl
{
template <typename T> using Vector = util::ViewOrVector<T, Ownership>;
using TravelMode = extractor::TravelMode;
public:
EdgeBasedNodeDataContainerImpl() = default;
EdgeBasedNodeDataContainerImpl(std::size_t size)
: geometry_ids(size), name_ids(size), travel_modes(size)
{
}
EdgeBasedNodeDataContainerImpl(Vector<GeometryID> geometry_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)),
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
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);
name_ids.push_back(name_id);
travel_modes.push_back(travel_mode);
geometry_ids[node_id] = geometry_id;
name_ids[node_id] = name_id;
travel_modes[node_id] = travel_mode;
}
friend void serialization::read<Ownership>(storage::io::FileReader &reader,
@ -68,7 +74,7 @@ template <storage::Ownership Ownership> class EdgeBasedNodeDataContainerImpl
private:
Vector<GeometryID> geometry_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,
const std::string &nodes_data_filename,
const std::string &node_data_filename,
const std::string &turn_data_filename,
const std::string &turn_lane_data_filename,
const std::string &turn_weight_penalties_filename,
@ -182,18 +182,13 @@ void EdgeBasedGraphFactory::Run(ScriptingEnvironment &scripting_environment,
TIMER_START(generate_nodes);
{
auto mapping = GenerateEdgeExpandedNodes();
auto mapping = GenerateEdgeExpandedNodes(node_data_filename);
files::writeNBGMapping(cnbg_ebg_mapping_path, mapping);
}
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);
GenerateEdgeExpandedEdges(scripting_environment,
index_nbg_edgeid_to_ebg_nodeid,
turn_data_filename,
turn_lane_data_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.
std::vector<NBGToEBG> EdgeBasedGraphFactory::GenerateEdgeExpandedNodes()
std::vector<NBGToEBG>
EdgeBasedGraphFactory::GenerateEdgeExpandedNodes(const std::string &node_data_filename)
{
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_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";
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...
void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
ScriptingEnvironment &scripting_environment,
const std::unordered_map<EdgeID, NodeID> &nbg_edgeid_to_ebg_nodeid,
const std::string &turn_data_filename,
const std::string &turn_lane_data_filename,
const std::string &turn_weight_penalties_filename,
@ -499,10 +494,8 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
BOOST_ASSERT(!edge_data2.reversed);
// 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(
nbg_edgeid_to_ebg_nodeid.find(incoming_edge)->second,
edge_data1.edge_id,
turn.instruction,
turn.lane_data_id,
entry_class_id,