From 253496c7ee8bbf40f7acb16c7d5bf46f7faa8b10 Mon Sep 17 00:00:00 2001 From: Moritz Kobitzsch Date: Tue, 22 Mar 2016 16:27:18 +0100 Subject: [PATCH] improves consistency of fork handling --- src/extractor/guidance/turn_analysis.cpp | 120 +++++++++++++++-------- 1 file changed, 77 insertions(+), 43 deletions(-) diff --git a/src/extractor/guidance/turn_analysis.cpp b/src/extractor/guidance/turn_analysis.cpp index 0b26c1ec7..97a13b9ff 100644 --- a/src/extractor/guidance/turn_analysis.cpp +++ b/src/extractor/guidance/turn_analysis.cpp @@ -268,8 +268,9 @@ TurnAnalysis::fallbackTurnAssignmentMotorway(std::vector intersec return intersection; } -std::vector TurnAnalysis::handleFromMotorway( - const EdgeID via_edge, std::vector intersection) const +std::vector +TurnAnalysis::handleFromMotorway(const EdgeID via_edge, + std::vector intersection) const { const auto &in_data = node_based_graph.GetEdgeData(via_edge); BOOST_ASSERT(detail::isMotorwayClass(in_data.road_classification.road_class)); @@ -519,8 +520,9 @@ std::vector TurnAnalysis::handleFromMotorway( return intersection; } -std::vector TurnAnalysis::handleMotorwayRamp( - const EdgeID via_edge, std::vector intersection) const +std::vector +TurnAnalysis::handleMotorwayRamp(const EdgeID via_edge, + std::vector intersection) const { auto num_valid_turns = countValid(intersection); // ramp straight into a motorway/ramp @@ -659,8 +661,9 @@ std::vector TurnAnalysis::handleMotorwayRamp( return intersection; } -std::vector TurnAnalysis::handleMotorwayJunction( - const EdgeID via_edge, std::vector intersection) const +std::vector +TurnAnalysis::handleMotorwayJunction(const EdgeID via_edge, + std::vector intersection) const { // BOOST_ASSERT(!intersection[0].entry_allowed); //This fails due to @themarex handling of dead // end @@ -798,7 +801,8 @@ TurnAnalysis::handleThreeWayTurn(const EdgeID via_edge, { return (angularDeviation(road.turn.angle, STRAIGHT_ANGLE) < NARROW_TURN_ANGLE && angularDeviation(other.turn.angle, STRAIGHT_ANGLE) > 85) || - (angularDeviation(road.turn.angle,STRAIGHT_ANGLE) < std::numeric_limits::epsilon()) || + (angularDeviation(road.turn.angle, STRAIGHT_ANGLE) < + std::numeric_limits::epsilon()) || (angularDeviation(other.turn.angle, STRAIGHT_ANGLE) / angularDeviation(road.turn.angle, STRAIGHT_ANGLE) > 1.4); @@ -1004,10 +1008,10 @@ TurnAnalysis::handleThreeWayTurn(const EdgeID via_edge, getTurnDirection(intersection[2].turn.angle)}; } } -// unnamed intersections or basic three way turn + // unnamed intersections or basic three way turn -// remain at basic turns -// TODO handle obviousness, Handle Merges + // remain at basic turns + // TODO handle obviousness, Handle Merges return intersection; } @@ -1505,43 +1509,47 @@ void TurnAnalysis::assignFork(const EdgeID via_edge, node_based_graph.GetEdgeData(left.turn.eid).road_classification.road_class); const bool low_priority_right = isLowPriorityRoadClass( node_based_graph.GetEdgeData(right.turn.eid).road_classification.road_class); - { // left fork + if ((angularDeviation(left.turn.angle, STRAIGHT_ANGLE) < MAXIMAL_ALLOWED_NO_TURN_DEVIATION && + angularDeviation(right.turn.angle, STRAIGHT_ANGLE) > FUZZY_ANGLE_DIFFERENCE)) + { + // left side is actually straight const auto &out_data = node_based_graph.GetEdgeData(left.turn.eid); - if ((angularDeviation(left.turn.angle, STRAIGHT_ANGLE) < - MAXIMAL_ALLOWED_NO_TURN_DEVIATION && - angularDeviation(right.turn.angle, STRAIGHT_ANGLE) > FUZZY_ANGLE_DIFFERENCE)) + if (requiresAnnouncement(in_data, out_data)) { - if (requiresAnnouncement(in_data, out_data)) + if (low_priority_right && !low_priority_left) { - if (low_priority_right && !low_priority_left) - left.turn.instruction = getInstructionForObvious(3, via_edge, left); - else - { - if (low_priority_left && !low_priority_right) - left.turn.instruction = {TurnType::Turn, DirectionModifier::SlightLeft}; - else - left.turn.instruction = {TurnType::Fork, DirectionModifier::SlightLeft}; - } + left.turn.instruction = getInstructionForObvious(3, via_edge, left); + right.turn.instruction = {findBasicTurnType(via_edge, right), + DirectionModifier::SlightRight}; } else { - left.turn.instruction = {TurnType::Suppressed, DirectionModifier::Straight}; + if (low_priority_left && !low_priority_right) + { + left.turn.instruction = {findBasicTurnType(via_edge, left), + DirectionModifier::SlightLeft}; + right.turn.instruction = {findBasicTurnType(via_edge, right), + DirectionModifier::SlightRight}; + } + else + { + left.turn.instruction = {TurnType::Fork, DirectionModifier::SlightLeft}; + right.turn.instruction = {TurnType::Fork, DirectionModifier::SlightRight}; + } } } else { - if (low_priority_right && !low_priority_left) - left.turn.instruction = {TurnType::Suppressed, DirectionModifier::SlightLeft}; - else - { - if (low_priority_left && !low_priority_right) - left.turn.instruction = {TurnType::Turn, DirectionModifier::SlightLeft}; - else - left.turn.instruction = {TurnType::Fork, DirectionModifier::SlightLeft}; - } + left.turn.instruction = {TurnType::Suppressed, DirectionModifier::Straight}; + right.turn.instruction = {findBasicTurnType(via_edge, right), + DirectionModifier::SlightRight}; } } - { // right fork + else if (angularDeviation(right.turn.angle, STRAIGHT_ANGLE) < + MAXIMAL_ALLOWED_NO_TURN_DEVIATION && + angularDeviation(left.turn.angle, STRAIGHT_ANGLE) > FUZZY_ANGLE_DIFFERENCE) + { + // right side is actually straight const auto &out_data = node_based_graph.GetEdgeData(right.turn.eid); if (angularDeviation(right.turn.angle, STRAIGHT_ANGLE) < MAXIMAL_ALLOWED_NO_TURN_DEVIATION && @@ -1550,31 +1558,57 @@ void TurnAnalysis::assignFork(const EdgeID via_edge, if (requiresAnnouncement(in_data, out_data)) { if (low_priority_left && !low_priority_right) + { + left.turn.instruction = {findBasicTurnType(via_edge, left), + DirectionModifier::SlightLeft}; right.turn.instruction = getInstructionForObvious(3, via_edge, right); + } else { if (low_priority_right && !low_priority_left) - right.turn.instruction = {TurnType::Turn, DirectionModifier::SlightRight}; + { + left.turn.instruction = {findBasicTurnType(via_edge, left), + DirectionModifier::SlightLeft}; + right.turn.instruction = {findBasicTurnType(via_edge, right), + DirectionModifier::SlightRight}; + } else + { right.turn.instruction = {TurnType::Fork, DirectionModifier::SlightRight}; + left.turn.instruction = {TurnType::Fork, DirectionModifier::SlightLeft}; + } } } else { right.turn.instruction = {TurnType::Suppressed, DirectionModifier::Straight}; + left.turn.instruction = {findBasicTurnType(via_edge, left), + DirectionModifier::SlightLeft}; } } + } + else + { + // left side of fork + if (low_priority_right && !low_priority_left) + left.turn.instruction = {TurnType::Suppressed, DirectionModifier::SlightLeft}; else { if (low_priority_left && !low_priority_right) - right.turn.instruction = {TurnType::Suppressed, DirectionModifier::SlightLeft}; + left.turn.instruction = {TurnType::Turn, DirectionModifier::SlightLeft}; else - { - if (low_priority_right && !low_priority_left) - right.turn.instruction = {TurnType::Turn, DirectionModifier::SlightRight}; - else - right.turn.instruction = {TurnType::Fork, DirectionModifier::SlightRight}; - } + left.turn.instruction = {TurnType::Fork, DirectionModifier::SlightLeft}; + } + + // right side of fork + if (low_priority_left && !low_priority_right) + right.turn.instruction = {TurnType::Suppressed, DirectionModifier::SlightLeft}; + else + { + if (low_priority_right && !low_priority_left) + right.turn.instruction = {TurnType::Turn, DirectionModifier::SlightRight}; + else + right.turn.instruction = {TurnType::Fork, DirectionModifier::SlightRight}; } } }