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

Split QueryNode into coordinates and osm id

Browse Source
This commit is contained in:
Patrick Niklaus
2017-04-02 23:58:06 +00:00
committed by Patrick Niklaus
parent 786a3d8919
commit 7f6e0c478b
38 changed files with 236 additions and 248 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/extractor/edge_based_graph_factory.cpp
+10 -18
View File
@@ -41,13 +41,15 @@ EdgeBasedGraphFactory::EdgeBasedGraphFactory(
const std::unordered_set<NodeID> &barrier_nodes,
const std::unordered_set<NodeID> &traffic_lights,
std::shared_ptr<const RestrictionMap> restriction_map,
const std::vector<QueryNode> &node_info_list,
const std::vector<util::Coordinate> &coordinates,
const util::PackedVector<OSMNodeID> &osm_node_ids,
ProfileProperties profile_properties,
const util::NameTable &name_table,
std::vector<std::uint32_t> &turn_lane_offsets,
std::vector<guidance::TurnLaneType::Mask> &turn_lane_masks,
guidance::LaneDescriptionMap &lane_description_map)
: m_max_edge_id(0), m_node_info_list(node_info_list),
: m_max_edge_id(0), m_coordinates(coordinates),
m_osm_node_ids(osm_node_ids),
m_node_based_graph(std::move(node_based_graph)),
m_restriction_map(std::move(restriction_map)), m_barrier_nodes(barrier_nodes),
m_traffic_lights(traffic_lights), m_compressed_edge_container(compressed_edge_container),
@@ -67,15 +69,6 @@ void EdgeBasedGraphFactory::GetEdgeBasedEdges(
void EdgeBasedGraphFactory::GetEdgeBasedNodes(std::vector<EdgeBasedNode> &nodes)
{
#ifndef NDEBUG
for (const EdgeBasedNode &node : m_edge_based_node_list)
{
BOOST_ASSERT(
util::Coordinate(m_node_info_list[node.u].lon, m_node_info_list[node.u].lat).IsValid());
BOOST_ASSERT(
util::Coordinate(m_node_info_list[node.v].lon, m_node_info_list[node.v].lat).IsValid());
}
#endif
using std::swap; // Koenig swap
swap(nodes, m_edge_based_node_list);
}
@@ -325,7 +318,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
// linear number of turns only.
SuffixTable street_name_suffix_table(scripting_environment);
guidance::TurnAnalysis turn_analysis(*m_node_based_graph,
m_node_info_list,
m_coordinates,
*m_restriction_map,
m_barrier_nodes,
m_compressed_edge_container,
@@ -548,18 +541,17 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
const auto &from_node =
isTrivial
? m_node_info_list[node_along_road_entering]
: m_node_info_list[m_compressed_edge_container.GetLastEdgeSourceID(
? m_osm_node_ids[node_along_road_entering]
: m_osm_node_ids[m_compressed_edge_container.GetLastEdgeSourceID(
incoming_edge)];
const auto &via_node =
m_node_info_list[m_compressed_edge_container.GetLastEdgeTargetID(
m_osm_node_ids[m_compressed_edge_container.GetLastEdgeTargetID(
incoming_edge)];
const auto &to_node =
m_node_info_list[m_compressed_edge_container.GetFirstEdgeTargetID(
m_osm_node_ids[m_compressed_edge_container.GetFirstEdgeTargetID(
turn.eid)];
lookup::TurnIndexBlock turn_index_block = {
from_node.node_id, via_node.node_id, to_node.node_id};
lookup::TurnIndexBlock turn_index_block = {from_node, via_node, to_node};
turn_penalties_index_file.WriteOne(turn_index_block);
}
src/extractor/extractor.cpp
+25 -33
View File
@@ -262,10 +262,12 @@ int Extractor::run(ScriptingEnvironment &scripting_environment)
util::DeallocatingVector<EdgeBasedEdge> edge_based_edge_list;
std::vector<bool> node_is_startpoint;
std::vector<EdgeWeight> edge_based_node_weights;
std::vector<QueryNode> internal_to_external_node_map;
std::vector<util::Coordinate> coordinates;
util::PackedVector<OSMNodeID> osm_node_ids;
auto graph_size = BuildEdgeExpandedGraph(scripting_environment,
internal_to_external_node_map,
coordinates,
osm_node_ids,
edge_based_node_list,
node_is_startpoint,
edge_based_node_weights,
@@ -292,14 +294,12 @@ int Extractor::run(ScriptingEnvironment &scripting_environment)
util::Log() << "Building r-tree ...";
TIMER_START(rtree);
BuildRTree(std::move(edge_based_node_list),
std::move(node_is_startpoint),
internal_to_external_node_map);
BuildRTree(std::move(edge_based_node_list), std::move(node_is_startpoint), coordinates);
TIMER_STOP(rtree);
util::Log() << "Writing node map ...";
WriteNodeMapping(internal_to_external_node_map);
files::writeNodes<storage::Ownership::Container>(config.node_output_path, coordinates, osm_node_ids);
WriteEdgeBasedGraph(config.edge_graph_output_path, max_edge_id, edge_based_edge_list);
@@ -406,7 +406,8 @@ std::shared_ptr<RestrictionMap> Extractor::LoadRestrictionMap()
std::shared_ptr<util::NodeBasedDynamicGraph>
Extractor::LoadNodeBasedGraph(std::unordered_set<NodeID> &barriers,
std::unordered_set<NodeID> &traffic_signals,
std::vector<QueryNode> &internal_to_external_node_map)
std::vector<util::Coordinate> &coordiantes,
util::PackedVector<OSMNodeID> &osm_node_ids)
{
storage::io::FileReader file_reader(config.output_file_name,
storage::io::FileReader::VerifyFingerprint);
@@ -415,7 +416,7 @@ Extractor::LoadNodeBasedGraph(std::unordered_set<NodeID> &barriers,
auto traffic_signals_iter = inserter(traffic_signals, end(traffic_signals));
NodeID number_of_node_based_nodes = util::loadNodesFromFile(
file_reader, barriers_iter, traffic_signals_iter, internal_to_external_node_map);
file_reader, barriers_iter, traffic_signals_iter, coordiantes, osm_node_ids);
util::Log() << " - " << barriers.size() << " bollard nodes, " << traffic_signals.size()
<< " traffic lights";
@@ -437,7 +438,8 @@ Extractor::LoadNodeBasedGraph(std::unordered_set<NodeID> &barriers,
*/
std::pair<std::size_t, EdgeID>
Extractor::BuildEdgeExpandedGraph(ScriptingEnvironment &scripting_environment,
std::vector<QueryNode> &internal_to_external_node_map,
std::vector<util::Coordinate> &coordinates,
util::PackedVector<OSMNodeID> &osm_node_ids,
std::vector<EdgeBasedNode> &node_based_edge_list,
std::vector<bool> &node_is_startpoint,
std::vector<EdgeWeight> &edge_based_node_weights,
@@ -449,7 +451,7 @@ Extractor::BuildEdgeExpandedGraph(ScriptingEnvironment &scripting_environment,
auto restriction_map = LoadRestrictionMap();
auto node_based_graph =
LoadNodeBasedGraph(barrier_nodes, traffic_lights, internal_to_external_node_map);
LoadNodeBasedGraph(barrier_nodes, traffic_lights, coordinates, osm_node_ids);
CompressedEdgeContainer compressed_edge_container;
GraphCompressor graph_compressor;
@@ -473,7 +475,8 @@ Extractor::BuildEdgeExpandedGraph(ScriptingEnvironment &scripting_environment,
barrier_nodes,
traffic_lights,
std::const_pointer_cast<RestrictionMap const>(restriction_map),
internal_to_external_node_map,
coordinates,
osm_node_ids,
scripting_environment.GetProfileProperties(),
name_table,
turn_lane_offsets,
@@ -508,7 +511,7 @@ Extractor::BuildEdgeExpandedGraph(ScriptingEnvironment &scripting_environment,
compressed_node_based_graph_writing = std::async(std::launch::async, [&] {
WriteCompressedNodeBasedGraph(config.compressed_node_based_graph_output_path,
*node_based_graph,
internal_to_external_node_map);
coordinates);
});
WriteTurnLaneData(config.turn_lane_descriptions_file_name);
@@ -531,17 +534,6 @@ Extractor::BuildEdgeExpandedGraph(ScriptingEnvironment &scripting_environment,
return std::make_pair(number_of_node_based_nodes, max_edge_id);
}
/**
\brief Writing info on original (node-based) nodes
*/
void Extractor::WriteNodeMapping(const std::vector<QueryNode> &internal_to_external_node_map)
{
storage::io::FileWriter node_file(config.node_output_path,
storage::io::FileWriter::HasNoFingerprint);
node_file.SerializeVector(internal_to_external_node_map);
}
/**
\brief Building rtree-based nearest-neighbor data structure
@@ -549,11 +541,10 @@ void Extractor::WriteNodeMapping(const std::vector<QueryNode> &internal_to_exter
*/
void Extractor::BuildRTree(std::vector<EdgeBasedNode> node_based_edge_list,
std::vector<bool> node_is_startpoint,
const std::vector<QueryNode> &internal_to_external_node_map)
const std::vector<util::Coordinate> &coordinates)
{
util::Log() << "constructing r-tree of " << node_based_edge_list.size()
<< " edge elements build on-top of " << internal_to_external_node_map.size()
<< " coordinates";
<< " edge elements build on-top of " << coordinates.size() << " coordinates";
BOOST_ASSERT(node_is_startpoint.size() == node_based_edge_list.size());
@@ -580,10 +571,10 @@ void Extractor::BuildRTree(std::vector<EdgeBasedNode> node_based_edge_list,
node_based_edge_list.resize(new_size);
TIMER_START(construction);
util::StaticRTree<EdgeBasedNode, std::vector<QueryNode>> rtree(node_based_edge_list,
config.rtree_nodes_output_path,
config.rtree_leafs_output_path,
internal_to_external_node_map);
util::StaticRTree<EdgeBasedNode> rtree(node_based_edge_list,
config.rtree_nodes_output_path,
config.rtree_leafs_output_path,
coordinates);
TIMER_STOP(construction);
util::Log() << "finished r-tree construction in " << TIMER_SEC(construction) << " seconds";
@@ -678,7 +669,7 @@ void Extractor::WriteTurnLaneData(const std::string &turn_lane_file) const
void Extractor::WriteCompressedNodeBasedGraph(const std::string &path,
const util::NodeBasedDynamicGraph &graph,
const std::vector<QueryNode> &externals)
const std::vector<util::Coordinate> &coordinates)
{
const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
@@ -693,7 +684,7 @@ void Extractor::WriteCompressedNodeBasedGraph(const std::string &path,
const auto num_edges = graph.GetNumberOfEdges();
const auto num_nodes = graph.GetNumberOfNodes();
BOOST_ASSERT_MSG(num_nodes == externals.size(), "graph and embedding out of sync");
BOOST_ASSERT_MSG(num_nodes == coordinates.size(), "graph and embedding out of sync");
writer.WriteElementCount64(num_edges);
writer.WriteElementCount64(num_nodes);
@@ -710,7 +701,8 @@ void Extractor::WriteCompressedNodeBasedGraph(const std::string &path,
}
}
for (const auto &qnode : externals)
// FIXME this is unneccesary: We have this data
for (const auto &qnode : coordinates)
{
writer.WriteOne(qnode.lon);
writer.WriteOne(qnode.lat);
src/extractor/guidance/coordinate_extractor.cpp
+4 -4
View File
@@ -60,7 +60,7 @@ double GetOffsetCorrectionFactor(const RoadClassification &road_classification)
CoordinateExtractor::CoordinateExtractor(
const util::NodeBasedDynamicGraph &node_based_graph,
const extractor::CompressedEdgeContainer &compressed_geometries,
const std::vector<extractor::QueryNode> &node_coordinates)
const std::vector<util::Coordinate> &node_coordinates)
: node_based_graph(node_based_graph), compressed_geometries(compressed_geometries),
node_coordinates(node_coordinates)
{
@@ -95,9 +95,9 @@ util::Coordinate CoordinateExtractor::ExtractRepresentativeCoordinate(
{
// check if the coordinate is equal to the interseciton coordinate
const auto not_same_as_start = [&](const util::Coordinate coordinate) {
return util::Coordinate(traversed_in_reverse
? node_coordinates[to_node]
: node_coordinates[intersection_node]) != coordinate;
return node_coordinates[traversed_in_reverse
? to_node
: intersection_node] != coordinate;
};
// this is only used for debug purposes in assertions. We don't want warnings about it
(void)not_same_as_start;
src/extractor/guidance/intersection_generator.cpp
+4 -4
View File
@@ -33,11 +33,11 @@ IntersectionGenerator::IntersectionGenerator(
const util::NodeBasedDynamicGraph &node_based_graph,
const RestrictionMap &restriction_map,
const std::unordered_set<NodeID> &barrier_nodes,
const std::vector<QueryNode> &node_info_list,
const std::vector<util::Coordinate> &coordinates,
const CompressedEdgeContainer &compressed_edge_container)
: node_based_graph(node_based_graph), restriction_map(restriction_map),
barrier_nodes(barrier_nodes), node_info_list(node_info_list),
coordinate_extractor(node_based_graph, compressed_edge_container, node_info_list)
barrier_nodes(barrier_nodes), coordinates(coordinates),
coordinate_extractor(node_based_graph, compressed_edge_container, coordinates)
{
}
@@ -56,7 +56,7 @@ IntersectionGenerator::ComputeIntersectionShape(const NodeID node_at_center_of_i
// reserve enough items (+ the possibly missing u-turn edge)
const auto intersection_degree = node_based_graph.GetOutDegree(node_at_center_of_intersection);
intersection.reserve(intersection_degree);
const util::Coordinate turn_coordinate = node_info_list[node_at_center_of_intersection];
const util::Coordinate turn_coordinate = coordinates[node_at_center_of_intersection];
// number of lanes at the intersection changes how far we look down the road
const auto edge_range = node_based_graph.GetAdjacentEdgeRange(node_at_center_of_intersection);
src/extractor/guidance/intersection_handler.cpp
+4 -4
View File
@@ -31,11 +31,11 @@ inline bool requiresAnnouncement(const EdgeData &from, const EdgeData &to)
}
IntersectionHandler::IntersectionHandler(const util::NodeBasedDynamicGraph &node_based_graph,
const std::vector<QueryNode> &node_info_list,
const std::vector<util::Coordinate> &coordinates,
const util::NameTable &name_table,
const SuffixTable &street_name_suffix_table,
const IntersectionGenerator &intersection_generator)
: node_based_graph(node_based_graph), node_info_list(node_info_list), name_table(name_table),
: node_based_graph(node_based_graph), coordinates(coordinates), name_table(name_table),
street_name_suffix_table(street_name_suffix_table),
intersection_generator(intersection_generator),
graph_walker(node_based_graph, intersection_generator)
@@ -127,8 +127,8 @@ TurnInstruction IntersectionHandler::getInstructionForObvious(const std::size_t
// or actually follow the full road. When 2399 lands, we can exchange here for a
// precalculated distance value.
const auto distance = util::coordinate_calculation::haversineDistance(
node_info_list[node_based_graph.GetTarget(via_edge)],
node_info_list[node_based_graph.GetTarget(road.eid)]);
coordinates[node_based_graph.GetTarget(via_edge)],
coordinates[node_based_graph.GetTarget(road.eid)]);
return {
TurnType::Turn,
(angularDeviation(road.angle, STRAIGHT_ANGLE) < FUZZY_ANGLE_DIFFERENCE ||
src/extractor/guidance/intersection_normalizer.cpp
+2 -2
View File
@@ -16,13 +16,13 @@ namespace guidance
IntersectionNormalizer::IntersectionNormalizer(
const util::NodeBasedDynamicGraph &node_based_graph,
const std::vector<extractor::QueryNode> &node_coordinates,
const std::vector<util::Coordinate> &coordinates,
const util::NameTable &name_table,
const SuffixTable &street_name_suffix_table,
const IntersectionGenerator &intersection_generator)
: node_based_graph(node_based_graph), intersection_generator(intersection_generator),
mergable_road_detector(node_based_graph,
node_coordinates,
coordinates,
intersection_generator,
intersection_generator.GetCoordinateExtractor(),
name_table,
src/extractor/guidance/mergable_road_detector.cpp
+1 -1
View File
@@ -44,7 +44,7 @@ inline auto makeCheckRoadForName(const NameID name_id,
}
MergableRoadDetector::MergableRoadDetector(const util::NodeBasedDynamicGraph &node_based_graph,
const std::vector<QueryNode> &node_coordinates,
const std::vector<util::Coordinate> &node_coordinates,
const IntersectionGenerator &intersection_generator,
const CoordinateExtractor &coordinate_extractor,
const util::NameTable &name_table,
src/extractor/guidance/motorway_handler.cpp
+2 -2
View File
@@ -40,12 +40,12 @@ inline bool isRampClass(EdgeID eid, const util::NodeBasedDynamicGraph &node_base
} // namespace
MotorwayHandler::MotorwayHandler(const util::NodeBasedDynamicGraph &node_based_graph,
const std::vector<QueryNode> &node_info_list,
const std::vector<util::Coordinate> &coordinates,
const util::NameTable &name_table,
const SuffixTable &street_name_suffix_table,
const IntersectionGenerator &intersection_generator)
: IntersectionHandler(node_based_graph,
node_info_list,
coordinates,
name_table,
street_name_suffix_table,
intersection_generator)
src/extractor/guidance/roundabout_handler.cpp
+7 -16
View File
@@ -23,19 +23,19 @@ namespace guidance
{
RoundaboutHandler::RoundaboutHandler(const util::NodeBasedDynamicGraph &node_based_graph,
const std::vector<QueryNode> &node_info_list,
const std::vector<util::Coordinate> &coordinates,
const CompressedEdgeContainer &compressed_edge_container,
const util::NameTable &name_table,
const SuffixTable &street_name_suffix_table,
const ProfileProperties &profile_properties,
const IntersectionGenerator &intersection_generator)
: IntersectionHandler(node_based_graph,
node_info_list,
coordinates,
name_table,
street_name_suffix_table,
intersection_generator),
compressed_edge_container(compressed_edge_container), profile_properties(profile_properties),
coordinate_extractor(node_based_graph, compressed_edge_container, node_info_list)
coordinate_extractor(node_based_graph, compressed_edge_container, coordinates)
{
}
@@ -149,10 +149,6 @@ void RoundaboutHandler::invalidateExitAgainstDirection(const NodeID from_nid,
bool RoundaboutHandler::qualifiesAsRoundaboutIntersection(
const std::unordered_set<NodeID> &roundabout_nodes) const
{
// translate a node ID into its respective coordinate stored in the node_info_list
const auto getCoordinate = [this](const NodeID node) {
return util::Coordinate(node_info_list[node].lon, node_info_list[node].lat);
};
const bool has_limited_size = roundabout_nodes.size() <= 4;
if (!has_limited_size)
return false;
@@ -169,7 +165,7 @@ bool RoundaboutHandler::qualifiesAsRoundaboutIntersection(
// Find all exit bearings. Only if they are well distinct (at least 60 degrees between
// them), we allow a roundabout turn
const auto exit_bearings = [this, &roundabout_nodes, getCoordinate]() {
const auto exit_bearings = [this, &roundabout_nodes]() {
std::vector<double> result;
for (const auto node : roundabout_nodes)
{
@@ -182,7 +178,7 @@ bool RoundaboutHandler::qualifiesAsRoundaboutIntersection(
continue;
// there is a single non-roundabout edge
const auto src_coordinate = getCoordinate(node);
const auto src_coordinate = coordinates[node];
const auto edge_range = node_based_graph.GetAdjacentEdgeRange(node);
const auto number_of_lanes_at_intersection = std::accumulate(
@@ -242,11 +238,6 @@ bool RoundaboutHandler::qualifiesAsRoundaboutIntersection(
RoundaboutType RoundaboutHandler::getRoundaboutType(const NodeID nid) const
{
// translate a node ID into its respective coordinate stored in the node_info_list
const auto getCoordinate = [this](const NodeID node) {
return util::Coordinate(node_info_list[node].lon, node_info_list[node].lat);
};
std::unordered_set<unsigned> roundabout_name_ids;
std::unordered_set<unsigned> connected_names;
@@ -305,11 +296,11 @@ RoundaboutType RoundaboutHandler::getRoundaboutType(const NodeID nid) const
const auto getEdgeLength = [&](const NodeID source_node, EdgeID eid) {
double length = 0.;
auto last_coord = getCoordinate(source_node);
auto last_coord = coordinates[source_node];
const auto &edge_bucket = compressed_edge_container.GetBucketReference(eid);
for (const auto &compressed_edge : edge_bucket)
{
const auto next_coord = getCoordinate(compressed_edge.node_id);
const auto next_coord = coordinates[compressed_edge.node_id];
length += util::coordinate_calculation::haversineDistance(last_coord, next_coord);
last_coord = next_coord;
}
src/extractor/guidance/sliproad_handler.cpp
+7 -7
View File
@@ -23,11 +23,11 @@ namespace guidance
SliproadHandler::SliproadHandler(const IntersectionGenerator &intersection_generator,
const util::NodeBasedDynamicGraph &node_based_graph,
const std::vector<QueryNode> &node_info_list,
const std::vector<util::Coordinate> &coordinates,
const util::NameTable &name_table,
const SuffixTable &street_name_suffix_table)
: IntersectionHandler(node_based_graph,
node_info_list,
coordinates,
name_table,
street_name_suffix_table,
intersection_generator)
@@ -374,8 +374,8 @@ operator()(const NodeID /*nid*/, const EdgeID source_edge_id, Intersection inter
// Only check for curvature and ~90 degree when it makes sense to do so.
const constexpr auto MIN_LENGTH = 3.;
const auto length = haversineDistance(node_info_list[intersection_node_id],
node_info_list[main_road_intersection->node]);
const auto length = haversineDistance(coordinates[intersection_node_id],
coordinates[main_road_intersection->node]);
const double perpendicular_angle = 90 + FUZZY_ANGLE_DIFFERENCE;
@@ -638,9 +638,9 @@ bool SliproadHandler::isValidSliproadArea(const double max_area,
{
using namespace util::coordinate_calculation;
const auto first = node_info_list[a];
const auto second = node_info_list[b];
const auto third = node_info_list[c];
const auto first = coordinates[a];
const auto second = coordinates[b];
const auto third = coordinates[c];
const auto length = haversineDistance(first, second);
const auto heigth = haversineDistance(second, third);
src/extractor/guidance/suppress_mode_handler.cpp
+2 -2
View File
@@ -13,11 +13,11 @@ namespace guidance
SuppressModeHandler::SuppressModeHandler(const IntersectionGenerator &intersection_generator,
const util::NodeBasedDynamicGraph &node_based_graph,
const std::vector<QueryNode> &node_info_list,
const std::vector<util::Coordinate> &coordinates,
const util::NameTable &name_table,
const SuffixTable &street_name_suffix_table)
: IntersectionHandler(node_based_graph,
node_info_list,
coordinates,
name_table,
street_name_suffix_table,
intersection_generator)
src/extractor/guidance/turn_analysis.cpp
+8 -8
View File
@@ -27,7 +27,7 @@ bool requiresAnnouncement(const EdgeData &from, const EdgeData &to)
}
TurnAnalysis::TurnAnalysis(const util::NodeBasedDynamicGraph &node_based_graph,
const std::vector<QueryNode> &node_info_list,
const std::vector<util::Coordinate> &coordinates,
const RestrictionMap &restriction_map,
const std::unordered_set<NodeID> &barrier_nodes,
const CompressedEdgeContainer &compressed_edge_container,
@@ -37,38 +37,38 @@ TurnAnalysis::TurnAnalysis(const util::NodeBasedDynamicGraph &node_based_graph,
: node_based_graph(node_based_graph), intersection_generator(node_based_graph,
restriction_map,
barrier_nodes,
node_info_list,
coordinates,
compressed_edge_container),
intersection_normalizer(node_based_graph,
node_info_list,
coordinates,
name_table,
street_name_suffix_table,
intersection_generator),
roundabout_handler(node_based_graph,
node_info_list,
coordinates,
compressed_edge_container,
name_table,
street_name_suffix_table,
profile_properties,
intersection_generator),
motorway_handler(node_based_graph,
node_info_list,
coordinates,
name_table,
street_name_suffix_table,
intersection_generator),
turn_handler(node_based_graph,
node_info_list,
coordinates,
name_table,
street_name_suffix_table,
intersection_generator),
sliproad_handler(intersection_generator,
node_based_graph,
node_info_list,
coordinates,
name_table,
street_name_suffix_table),
suppress_mode_handler(intersection_generator,
node_based_graph,
node_info_list,
coordinates,
name_table,
street_name_suffix_table)
{
src/extractor/guidance/turn_handler.cpp
+2 -2
View File
@@ -111,12 +111,12 @@ std::size_t TurnHandler::Fork::getLeftIndex() const
}
TurnHandler::TurnHandler(const util::NodeBasedDynamicGraph &node_based_graph,
const std::vector<QueryNode> &node_info_list,
const std::vector<util::Coordinate> &coordinates,
const util::NameTable &name_table,
const SuffixTable &street_name_suffix_table,
const IntersectionGenerator &intersection_generator)
: IntersectionHandler(node_based_graph,
node_info_list,
coordinates,
name_table,
street_name_suffix_table,
intersection_generator)
src/storage/storage.cpp
+8 -17
View File
@@ -1,7 +1,6 @@
#include "storage/storage.hpp"
#include "storage/io.hpp"
#include "storage/serialization.hpp"
#include "storage/shared_datatype.hpp"
#include "storage/shared_memory.hpp"
#include "storage/shared_memory_ownership.hpp"
@@ -64,8 +63,7 @@ namespace storage
{
using RTreeLeaf = engine::datafacade::BaseDataFacade::RTreeLeaf;
using RTreeNode = util::
StaticRTree<RTreeLeaf, util::vector_view<util::Coordinate>, storage::Ownership::View>::TreeNode;
using RTreeNode = util:: StaticRTree<RTreeLeaf, storage::Ownership::View>::TreeNode;
using QueryGraph = util::StaticGraph<contractor::QueryEdge::EdgeData>;
using EdgeBasedGraph = util::StaticGraph<extractor::EdgeBasedEdge::EdgeData>;
@@ -281,9 +279,7 @@ void Storage::PopulateLayout(DataLayout &layout)
}
{
// allocate space in shared memory for profile properties
const auto properties_size = serialization::readPropertiesCount();
layout.SetBlockSize<extractor::ProfileProperties>(DataLayout::PROPERTIES, properties_size);
layout.SetBlockSize<extractor::ProfileProperties>(DataLayout::PROPERTIES, 1);
}
// read timestampsize
@@ -323,14 +319,14 @@ void Storage::PopulateLayout(DataLayout &layout)
// load coordinate size
{
io::FileReader node_file(config.nodes_data_path, io::FileReader::HasNoFingerprint);
io::FileReader node_file(config.nodes_data_path, io::FileReader::VerifyFingerprint);
const auto coordinate_list_size = node_file.ReadElementCount64();
layout.SetBlockSize<util::Coordinate>(DataLayout::COORDINATE_LIST, coordinate_list_size);
// we'll read a list of OSM node IDs from the same data, so set the block size for the same
// number of items:
layout.SetBlockSize<std::uint64_t>(
DataLayout::OSM_NODE_ID_LIST,
util::PackedVector<OSMNodeID>::elements_to_blocks(coordinate_list_size));
util::PackedVectorView<OSMNodeID>::elements_to_blocks(coordinate_list_size));
}
// load geometries sizes
@@ -690,20 +686,15 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
// Loading list of coordinates
{
io::FileReader nodes_file(config.nodes_data_path, io::FileReader::HasNoFingerprint);
nodes_file.Skip<std::uint64_t>(1); // node_count
const auto coordinates_ptr =
layout.GetBlockPtr<util::Coordinate, true>(memory_ptr, DataLayout::COORDINATE_LIST);
const auto osmnodeid_ptr =
layout.GetBlockPtr<std::uint64_t, true>(memory_ptr, DataLayout::OSM_NODE_ID_LIST);
util::PackedVector<OSMNodeID, storage::Ownership::View> osmnodeid_list;
util::vector_view<util::Coordinate> coordinates(coordinates_ptr, layout.num_entries[DataLayout::COORDINATE_LIST]);
util::PackedVectorView<OSMNodeID> osm_node_ids;
osm_node_ids.reset(osmnodeid_ptr, layout.num_entries[DataLayout::OSM_NODE_ID_LIST]);
osmnodeid_list.reset(osmnodeid_ptr, layout.num_entries[DataLayout::OSM_NODE_ID_LIST]);
serialization::readNodes(nodes_file,
coordinates_ptr,
osmnodeid_list,
layout.num_entries[DataLayout::COORDINATE_LIST]);
extractor::files::readNodes<storage::Ownership::View>(config.nodes_data_path, coordinates, osm_node_ids);
}
// load turn weight penalties
src/tools/components.cpp
+12 -8
View File
@@ -32,7 +32,8 @@ using TarjanGraph = util::StaticGraph<void>;
using TarjanEdge = util::static_graph_details::SortableEdgeWithData<void>;
std::size_t loadGraph(const std::string &path,
std::vector<extractor::QueryNode> &coordinate_list,
std::vector<util::Coordinate> &coordinate_list,
util::PackedVector<OSMNodeID> &osm_node_ids,
std::vector<TarjanEdge> &graph_edge_list)
{
storage::io::FileReader file_reader(path, storage::io::FileReader::VerifyFingerprint);
@@ -41,7 +42,7 @@ std::size_t loadGraph(const std::string &path,
auto nop = boost::make_function_output_iterator([](auto) {});
const auto number_of_nodes = util::loadNodesFromFile(file_reader, nop, nop, coordinate_list);
const auto number_of_nodes = util::loadNodesFromFile(file_reader, nop, nop, coordinate_list, osm_node_ids);
util::loadEdgesFromFile(file_reader, edge_list);
@@ -75,7 +76,9 @@ struct FeatureWriter
}
void
AddLine(const extractor::QueryNode from, const extractor::QueryNode to, const std::string &type)
AddLine(const util::Coordinate from, const util::Coordinate to,
const OSMNodeID from_id, const OSMNodeID to_id,
const std::string &type)
{
const auto from_lon = static_cast<double>(util::toFloating(from.lon));
const auto from_lat = static_cast<double>(util::toFloating(from.lat));
@@ -89,8 +92,8 @@ struct FeatureWriter
out << ",";
}
out << "{\"type\":\"Feature\",\"properties\":{\"from\":" << from.node_id << ","
<< "\"to\":" << to.node_id << ",\"type\":\"" << type
out << "{\"type\":\"Feature\",\"properties\":{\"from\":" << from_id << ","
<< "\"to\":" << to_id << ",\"type\":\"" << type
<< "\"},\"geometry\":{\"type\":\"LineString\",\"coordinates\":[[" << from_lon << ","
<< from_lat << "],[" << to_lon << "," << to_lat << "]]}}";
@@ -110,7 +113,6 @@ int main(int argc, char *argv[])
{
using namespace osrm;
std::vector<extractor::QueryNode> coordinate_list;
util::LogPolicy::GetInstance().Unmute();
if (argc < 3)
@@ -137,7 +139,9 @@ int main(int argc, char *argv[])
}
std::vector<tools::TarjanEdge> graph_edge_list;
auto number_of_nodes = tools::loadGraph(inpath, coordinate_list, graph_edge_list);
std::vector<util::Coordinate> coordinate_list;
util::PackedVector<OSMNodeID> osm_node_ids;
auto number_of_nodes = tools::loadGraph(inpath, coordinate_list, osm_node_ids, graph_edge_list);
tbb::parallel_sort(graph_edge_list.begin(), graph_edge_list.end());
@@ -185,7 +189,7 @@ int main(int argc, char *argv[])
auto same_component = source_component_id == target_component_id;
std::string type = same_component ? "inner" : "border";
writer.AddLine(coordinate_list[source], coordinate_list[target], type);
writer.AddLine(coordinate_list[source], coordinate_list[target], osm_node_ids[source], osm_node_ids[target], type);
}
}
}
src/updater/updater.cpp
+12 -16
View File
@@ -143,10 +143,9 @@ updateSegmentData(const UpdaterConfig &config,
{
auto weight_multiplier = profile_properties.GetWeightMultiplier();
std::vector<extractor::QueryNode> internal_to_external_node_map;
storage::io::FileReader nodes_file(config.node_based_graph_path,
storage::io::FileReader::HasNoFingerprint);
nodes_file.DeserializeVector(internal_to_external_node_map);
std::vector<util::Coordinate> coordinates;
util::PackedVector<OSMNodeID> osm_node_ids;
extractor::files::readNodes(config.node_based_graph_path, coordinates, osm_node_ids);
// vector to count used speeds for logging
// size offset by one since index 0 is used for speeds not from external file
@@ -180,8 +179,7 @@ updateSegmentData(const UpdaterConfig &config,
segment_lengths.reserve(nodes_range.size() + 1);
util::for_each_pair(nodes_range, [&](const auto &u, const auto &v) {
segment_lengths.push_back(util::coordinate_calculation::greatCircleDistance(
util::Coordinate{internal_to_external_node_map[u]},
util::Coordinate{internal_to_external_node_map[v]}));
coordinates[u], coordinates[v]));
});
auto fwd_weights_range = segment_data.GetForwardWeights(geometry_id);
@@ -190,8 +188,8 @@ updateSegmentData(const UpdaterConfig &config,
bool fwd_was_updated = false;
for (const auto segment_offset : util::irange<std::size_t>(0, fwd_weights_range.size()))
{
auto u = internal_to_external_node_map[nodes_range[segment_offset]].node_id;
auto v = internal_to_external_node_map[nodes_range[segment_offset + 1]].node_id;
auto u = osm_node_ids[nodes_range[segment_offset]];
auto v = osm_node_ids[nodes_range[segment_offset + 1]];
if (auto value = segment_speed_lookup({u, v}))
{
auto new_duration =
@@ -224,8 +222,8 @@ updateSegmentData(const UpdaterConfig &config,
for (const auto segment_offset : util::irange<std::size_t>(0, rev_weights_range.size()))
{
auto u = internal_to_external_node_map[nodes_range[segment_offset]].node_id;
auto v = internal_to_external_node_map[nodes_range[segment_offset + 1]].node_id;
auto u = osm_node_ids[nodes_range[segment_offset]];
auto v = osm_node_ids[nodes_range[segment_offset + 1]];
if (auto value = segment_speed_lookup({v, u}))
{
auto new_duration =
@@ -301,9 +299,8 @@ updateSegmentData(const UpdaterConfig &config,
if (old_fwd_durations_range[segment_offset] >=
(new_fwd_durations_range[segment_offset] * config.log_edge_updates_factor))
{
auto from = internal_to_external_node_map[nodes_range[segment_offset]].node_id;
auto to =
internal_to_external_node_map[nodes_range[segment_offset + 1]].node_id;
auto from = osm_node_ids[nodes_range[segment_offset]];
auto to = osm_node_ids[nodes_range[segment_offset + 1]];
util::Log(logWARNING)
<< "[weight updates] Edge weight update from "
<< old_fwd_durations_range[segment_offset] / 10. << "s to "
@@ -323,9 +320,8 @@ updateSegmentData(const UpdaterConfig &config,
if (old_rev_durations_range[segment_offset] >=
(new_rev_durations_range[segment_offset] * config.log_edge_updates_factor))
{
auto from =
internal_to_external_node_map[nodes_range[segment_offset + 1]].node_id;
auto to = internal_to_external_node_map[nodes_range[segment_offset]].node_id;
auto from = osm_node_ids[nodes_range[segment_offset + 1]];
auto to = osm_node_ids[nodes_range[segment_offset]];
util::Log(logWARNING)
<< "[weight updates] Edge weight update from "
<< old_rev_durations_range[segment_offset] / 10. << "s to "