Function CorrectRightmostAndLeftmost

libs/routing/car_directions.cpp:380–432

If the route goes along the rightmost or the leftmost way among available ones: 1. RightmostDirection or LeftmostDirection is selected 2. If the turn direction is |CarDirection::GoStraight| and there's another not sharp enough turn GoStraight is corrected to TurnSlightRight/TurnSlightLeft to avoid ambiguity for GoStraight direction: 2 or more almost straight turns.

// GoStraight is corrected to TurnSlightRight/TurnSlightLeft
// to avoid ambiguity for GoStraight direction: 2 or more almost straight turns.
void CorrectRightmostAndLeftmost(vector<TurnCandidate> const & turnCandidates, Segment const & firstOutgoingSeg,
                                 double const turnAngle, TurnItem & turn)
{
  // turnCandidates are sorted by angle from leftmost to rightmost.
  // Normally no duplicates should be found. But if they are present we can't identify the leftmost/rightmost by order.
  if (adjacent_find(turnCandidates.begin(), turnCandidates.end(), base::EqualsBy(&TurnCandidate::m_angle)) !=
      turnCandidates.end())
  {
    LOG(LWARNING, ("nodes.candidates are not expected to have same m_angle."));
    return;
  }

  double constexpr kMaxAbsAngleConsideredLeftOrRightMost = 90;

  // Go from left to right to findout if the route goes through the leftmost candidate and fixes can be applied.
  // Other candidates which are sharper than kMaxAbsAngleConsideredLeftOrRightMost are ignored.
  for (auto candidate = turnCandidates.begin(); candidate != turnCandidates.end(); ++candidate)
  {
    if (candidate->m_segment == firstOutgoingSeg && candidate + 1 != turnCandidates.end())
    {
      // The route goes along the leftmost candidate.
      turn.m_turn = LeftmostDirection(turnAngle);
      if (IntermediateDirection(turnAngle) != turn.m_turn)
        LOG(LDEBUG, ("Turn: ", turn.m_index, " LeftmostDirection correction."));
      // Compare with the next candidate to the right.
      CorrectGoStraight(*(candidate + 1), candidate->m_angle, CarDirection::TurnSlightLeft, turn);
      break;
    }
    // Check if this candidate is considered as leftmost as not too sharp.
    // If yes - this candidate is leftmost, not route's one.
    if (candidate->m_angle > -kMaxAbsAngleConsideredLeftOrRightMost)
      break;
  }
  // Go from right to left to findout if the route goes through the rightmost candidate anf fixes can be applied.
  // Other candidates which are sharper than kMaxAbsAngleConsideredLeftOrRightMost are ignored.
  for (auto candidate = turnCandidates.rbegin(); candidate != turnCandidates.rend(); ++candidate)
  {
    if (candidate->m_segment == firstOutgoingSeg && candidate + 1 != turnCandidates.rend())
    {
      // The route goes along the rightmost candidate.
      turn.m_turn = RightmostDirection(turnAngle);
      if (IntermediateDirection(turnAngle) != turn.m_turn)
        LOG(LDEBUG, ("Turn: ", turn.m_index, " RighmostDirection correction."));
      // Compare with the next candidate to the left.
      CorrectGoStraight(*(candidate + 1), candidate->m_angle, CarDirection::TurnSlightRight, turn);
      break;
    }
    // Check if this candidate is considered as rightmost as not too sharp.
    // If yes - this candidate is rightmost, not route's one.
    if (candidate->m_angle < kMaxAbsAngleConsideredLeftOrRightMost)
      break;
  }
}

void GetTurnDirectionBasic(IRoutingResult const & result, size_t const outgoingSegmentIndex,
                           NumMwmIds const & numMwmIds, RoutingSettings const & vehicleSettings, TurnItem & turn)