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

Still use low precision bearings

Browse Source
This commit is contained in:
Michael Krasnyk 2017-12-07 00:27:53 +01:00
parent 153f9b02a5
commit 08b88bad63
9 changed files with 88 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
include/extractor/guidance/intersection_handler.hpp
View File

@ -579,13 +579,13 @@ std::size_t IntersectionHandler::findObviousTurn(const EdgeID via_edge,
return {}; return {};
return intersection::getConnectedRoads<false>(node_based_graph, return intersection::getConnectedRoads<false>(node_based_graph,
node_data_container, node_data_container,
node_coordinates, node_coordinates,
compressed_geometries, compressed_geometries,
node_restriction_map, node_restriction_map,
barrier_nodes, barrier_nodes,
turn_lanes_data, turn_lanes_data,
parameters); parameters);
}(); }();
if (!previous_intersection.empty()) if (!previous_intersection.empty())

14
include/extractor/guidance/node_based_graph_walker.hpp
View File

@ -223,13 +223,13 @@ NodeBasedGraphWalker::TraverseRoad(NodeID current_node_id,
// look at the next intersection // look at the next intersection
const auto next_intersection = const auto next_intersection =
intersection::getConnectedRoads<true>(node_based_graph, intersection::getConnectedRoads<true>(node_based_graph,
node_data_container, node_data_container,
node_coordinates, node_coordinates,
compressed_geometries, compressed_geometries,
node_restriction_map, node_restriction_map,
barrier_nodes, barrier_nodes,
turn_lanes_data, turn_lanes_data,
{current_node_id, current_edge_id}); {current_node_id, current_edge_id});
// don't follow u-turns or go past our initial intersection // don't follow u-turns or go past our initial intersection
if (next_intersection.size() <= 1) if (next_intersection.size() <= 1)

2
include/extractor/intersection/intersection_analysis.hpp
View File

@ -60,7 +60,7 @@ convertToIntersectionView(const util::NodeBasedDynamicGraph &graph,
// Check for restrictions/barriers and generate a list of valid and invalid turns present at // Check for restrictions/barriers and generate a list of valid and invalid turns present at
// the node reached from `incoming_edge`. The resulting candidates have to be analyzed // the node reached from `incoming_edge`. The resulting candidates have to be analyzed
// for their actual instructions later on. // for their actual instructions later on.
template<bool USE_CLOSE_BEARINGS> template <bool USE_CLOSE_COORDINATE>
guidance::IntersectionView guidance::IntersectionView
getConnectedRoads(const util::NodeBasedDynamicGraph &graph, getConnectedRoads(const util::NodeBasedDynamicGraph &graph,
const EdgeBasedNodeDataContainer &node_data_container, const EdgeBasedNodeDataContainer &node_data_container,

14
src/extractor/guidance/intersection_handler.cpp
View File

@ -483,13 +483,13 @@ IntersectionHandler::getNextIntersection(const NodeID at, const EdgeID via) cons
} }
auto intersection = intersection::getConnectedRoads<false>(node_based_graph, auto intersection = intersection::getConnectedRoads<false>(node_based_graph,
node_data_container, node_data_container,
node_coordinates, node_coordinates,
compressed_geometries, compressed_geometries,
node_restriction_map, node_restriction_map,
barrier_nodes, barrier_nodes,
turn_lanes_data, turn_lanes_data,
intersection_parameters); intersection_parameters);
auto intersection_node = node_based_graph.GetTarget(intersection_parameters.edge); auto intersection_node = node_based_graph.GetTarget(intersection_parameters.edge);
if (intersection.size() <= 2 || intersection.isTrafficSignalOrBarrier()) if (intersection.size() <= 2 || intersection.isTrafficSignalOrBarrier())

14
src/extractor/guidance/mergable_road_detector.cpp
View File

@ -559,13 +559,13 @@ bool MergableRoadDetector::IsLinkRoad(const NodeID intersection_node,
intersection::skipDegreeTwoNodes(node_based_graph, {intersection_node, road.eid}); intersection::skipDegreeTwoNodes(node_based_graph, {intersection_node, road.eid});
const auto next_intersection_along_road = const auto next_intersection_along_road =
intersection::getConnectedRoads<false>(node_based_graph, intersection::getConnectedRoads<false>(node_based_graph,
node_data_container, node_data_container,
node_coordinates, node_coordinates,
compressed_geometries, compressed_geometries,
node_restriction_map, node_restriction_map,
barrier_nodes, barrier_nodes,
turn_lanes_data, turn_lanes_data,
next_intersection_parameters); next_intersection_parameters);
const auto extract_name_id = [this](const MergableRoadData &road) { const auto extract_name_id = [this](const MergableRoadData &road) {
return node_data_container return node_data_container
.GetAnnotation(node_based_graph.GetEdgeData(road.eid).annotation_data) .GetAnnotation(node_based_graph.GetEdgeData(road.eid).annotation_data)

14
src/extractor/guidance/node_based_graph_walker.cpp
View File

@ -280,13 +280,13 @@ void IntersectionFinderAccumulator::update(const NodeID from_node,
via_edge_id = via_edge; via_edge_id = via_edge;
intersection = intersection::getConnectedRoads<true>(node_based_graph, intersection = intersection::getConnectedRoads<true>(node_based_graph,
node_data_container, node_data_container,
node_coordinates, node_coordinates,
compressed_geometries, compressed_geometries,
node_restriction_map, node_restriction_map,
barrier_nodes, barrier_nodes,
turn_lanes_data, turn_lanes_data,
{from_node, via_edge}); {from_node, via_edge});
} }
} // namespace guidance } // namespace guidance

42
src/extractor/guidance/turn_discovery.cpp
View File

@ -76,13 +76,13 @@ bool findPreviousIntersection(const NodeID node_v,
const auto node_v_reverse_intersection = const auto node_v_reverse_intersection =
intersection::getConnectedRoads<true>(node_based_graph, intersection::getConnectedRoads<true>(node_based_graph,
node_data_container, node_data_container,
node_coordinates, node_coordinates,
compressed_geometries, compressed_geometries,
node_restriction_map, node_restriction_map,
barrier_nodes, barrier_nodes,
turn_lanes_data, turn_lanes_data,
{node_w, u_turn_at_node_w}); {node_w, u_turn_at_node_w});
// Continue along the straightmost turn. If there is no straight turn, we cannot find a valid // Continue along the straightmost turn. If there is no straight turn, we cannot find a valid
// previous intersection. // previous intersection.
const auto straightmost_at_v_in_reverse = const auto straightmost_at_v_in_reverse =
@ -96,13 +96,13 @@ bool findPreviousIntersection(const NodeID node_v,
const auto node_u = node_based_graph.GetTarget(straightmost_at_v_in_reverse->eid); const auto node_u = node_based_graph.GetTarget(straightmost_at_v_in_reverse->eid);
const auto node_u_reverse_intersection = const auto node_u_reverse_intersection =
intersection::getConnectedRoads<true>(node_based_graph, intersection::getConnectedRoads<true>(node_based_graph,
node_data_container, node_data_container,
node_coordinates, node_coordinates,
compressed_geometries, compressed_geometries,
node_restriction_map, node_restriction_map,
barrier_nodes, barrier_nodes,
turn_lanes_data, turn_lanes_data,
{node_v, straightmost_at_v_in_reverse->eid}); {node_v, straightmost_at_v_in_reverse->eid});
// now check that the u-turn at the given intersection connects to via-edge // now check that the u-turn at the given intersection connects to via-edge
// The u-turn at the now found intersection should, hopefully, represent the previous edge. // The u-turn at the now found intersection should, hopefully, represent the previous edge.
@ -121,13 +121,13 @@ bool findPreviousIntersection(const NodeID node_v,
} }
result_intersection = intersection::getConnectedRoads<false>(node_based_graph, result_intersection = intersection::getConnectedRoads<false>(node_based_graph,
node_data_container, node_data_container,
node_coordinates, node_coordinates,
compressed_geometries, compressed_geometries,
node_restriction_map, node_restriction_map,
barrier_nodes, barrier_nodes,
turn_lanes_data, turn_lanes_data,
{node_u, result_via_edge}); {node_u, result_via_edge});
const auto check_via_edge = const auto check_via_edge =
result_intersection.end() != result_intersection.end() !=
std::find_if(result_intersection.begin(), std::find_if(result_intersection.begin(),

22
src/extractor/guidance/turn_lane_handler.cpp
View File

@ -572,17 +572,17 @@ std::pair<LaneDataVector, LaneDataVector> TurnLaneHandler::partitionLaneData(
// find out about the next intersection. To check for valid matches, we also need the turn // find out about the next intersection. To check for valid matches, we also need the turn
// types. We can skip merging/angle adjustments, though // types. We can skip merging/angle adjustments, though
const auto next_intersection = const auto next_intersection = turn_analysis.AssignTurnTypes(
turn_analysis.AssignTurnTypes(at, at,
straightmost->eid, straightmost->eid,
intersection::getConnectedRoads<false>(node_based_graph, intersection::getConnectedRoads<false>(node_based_graph,
node_data_container, node_data_container,
node_coordinates, node_coordinates,
compressed_geometries, compressed_geometries,
node_restriction_map, node_restriction_map,
barrier_nodes, barrier_nodes,
turn_lanes_data, turn_lanes_data,
{at, straightmost->eid})); {at, straightmost->eid}));
// check where we can match turn lanes // check where we can match turn lanes
std::size_t straightmost_tag_index = turn_lane_data.size(); std::size_t straightmost_tag_index = turn_lane_data.size();

43
src/extractor/intersection/intersection_analysis.cpp
View File

@ -202,7 +202,7 @@ auto getIntersectionLanes(const util::NodeBasedDynamicGraph &graph, const NodeID
return max_lanes_intersection; return max_lanes_intersection;
} }
template<bool USE_CLOSE_BEARINGS> template <bool USE_CLOSE_COORDINATE>
IntersectionEdgeGeometries IntersectionEdgeGeometries
getIntersectionOutgoingGeometries(const util::NodeBasedDynamicGraph &graph, getIntersectionOutgoingGeometries(const util::NodeBasedDynamicGraph &graph,
const extractor::CompressedEdgeContainer &compressed_geometries, const extractor::CompressedEdgeContainer &compressed_geometries,
@ -233,7 +233,7 @@ getIntersectionOutgoingGeometries(const util::NodeBasedDynamicGraph &graph,
util::coordinate_calculation::bearing(geometry[0], close_coordinate); util::coordinate_calculation::bearing(geometry[0], close_coordinate);
const auto representative_coordinate = const auto representative_coordinate =
USE_CLOSE_BEARINGS || graph.GetOutDegree(intersection_node) <= 2 USE_CLOSE_COORDINATE || graph.GetOutDegree(intersection_node) <= 2
? coordinate_extractor.GetCoordinateCloseToTurn( ? coordinate_extractor.GetCoordinateCloseToTurn(
intersection_node, outgoing_edge, false, remote_node) intersection_node, outgoing_edge, false, remote_node)
: coordinate_extractor.ExtractRepresentativeCoordinate(intersection_node, : coordinate_extractor.ExtractRepresentativeCoordinate(intersection_node,
@ -756,7 +756,7 @@ convertToIntersectionView(const util::NodeBasedDynamicGraph &graph,
// That means we not only get (from_node, turn_node, c) in the above example // That means we not only get (from_node, turn_node, c) in the above example
// but also (from_node, turn_node, a), (from_node, turn_node, b). These turns are // but also (from_node, turn_node, a), (from_node, turn_node, b). These turns are
// marked as invalid and only needed for intersection classification. // marked as invalid and only needed for intersection classification.
template<bool USE_CLOSE_BEARINGS> template <bool USE_CLOSE_COORDINATE>
guidance::IntersectionView guidance::IntersectionView
getConnectedRoads(const util::NodeBasedDynamicGraph &graph, getConnectedRoads(const util::NodeBasedDynamicGraph &graph,
const EdgeBasedNodeDataContainer &node_data_container, const EdgeBasedNodeDataContainer &node_data_container,
@ -769,7 +769,7 @@ getConnectedRoads(const util::NodeBasedDynamicGraph &graph,
{ {
const auto intersection_node = graph.GetTarget(incoming_edge.edge); const auto intersection_node = graph.GetTarget(incoming_edge.edge);
const auto &outgoing_edges = intersection::getOutgoingEdges(graph, intersection_node); const auto &outgoing_edges = intersection::getOutgoingEdges(graph, intersection_node);
auto edge_geometries = getIntersectionOutgoingGeometries<USE_CLOSE_BEARINGS>( auto edge_geometries = getIntersectionOutgoingGeometries<USE_CLOSE_COORDINATE>(
graph, compressed_geometries, node_coordinates, intersection_node); graph, compressed_geometries, node_coordinates, intersection_node);
// Add incoming edges with reversed bearings // Add incoming edges with reversed bearings
@ -800,28 +800,25 @@ getConnectedRoads(const util::NodeBasedDynamicGraph &graph,
std::unordered_set<EdgeID>()); std::unordered_set<EdgeID>());
} }
template template guidance::IntersectionView
guidance::IntersectionView
getConnectedRoads<false>(const util::NodeBasedDynamicGraph &graph, getConnectedRoads<false>(const util::NodeBasedDynamicGraph &graph,
const EdgeBasedNodeDataContainer &node_data_container, const EdgeBasedNodeDataContainer &node_data_container,
const std::vector<util::Coordinate> &node_coordinates, const std::vector<util::Coordinate> &node_coordinates,
const extractor::CompressedEdgeContainer &compressed_geometries, const extractor::CompressedEdgeContainer &compressed_geometries,
const RestrictionMap &node_restriction_map, const RestrictionMap &node_restriction_map,
const std::unordered_set<NodeID> &barrier_nodes, const std::unordered_set<NodeID> &barrier_nodes,
const guidance::TurnLanesIndexedArray &turn_lanes_data, const guidance::TurnLanesIndexedArray &turn_lanes_data,
const IntersectionEdge &incoming_edge); const IntersectionEdge &incoming_edge);
template template guidance::IntersectionView
guidance::IntersectionView
getConnectedRoads<true>(const util::NodeBasedDynamicGraph &graph, getConnectedRoads<true>(const util::NodeBasedDynamicGraph &graph,
const EdgeBasedNodeDataContainer &node_data_container, const EdgeBasedNodeDataContainer &node_data_container,
const std::vector<util::Coordinate> &node_coordinates, const std::vector<util::Coordinate> &node_coordinates,
const extractor::CompressedEdgeContainer &compressed_geometries, const extractor::CompressedEdgeContainer &compressed_geometries,
const RestrictionMap &node_restriction_map, const RestrictionMap &node_restriction_map,
const std::unordered_set<NodeID> &barrier_nodes, const std::unordered_set<NodeID> &barrier_nodes,
const guidance::TurnLanesIndexedArray &turn_lanes_data, const guidance::TurnLanesIndexedArray &turn_lanes_data,
const IntersectionEdge &incoming_edge); const IntersectionEdge &incoming_edge);
IntersectionEdge skipDegreeTwoNodes(const util::NodeBasedDynamicGraph &graph, IntersectionEdge road) IntersectionEdge skipDegreeTwoNodes(const util::NodeBasedDynamicGraph &graph, IntersectionEdge road)
{ {