Method ProcessLeapsJoints

libs/routing/index_router.cpp:1445–1623

}

RouterResultCode IndexRouter::ProcessLeapsJoints(vector<Segment> const & input, IndexGraphStarter & starter,
                                                 shared_ptr<AStarProgress> const & progress,
                                                 RoutesCalculator & calculator, RoutingResultT & result)
{
  LOG(LDEBUG, ("Process input:", input));

  // { fake, mwmId1, mwmId2, mwmId2, mwmId3, .. pairs of ids .. , fake }.
  ASSERT_GREATER_OR_EQUAL(input.size(), 4, ());
  ASSERT(input.size() % 2 == 0, ());

  WorldGraph & worldGraph = starter.GetGraph();

  // For all leaps except the first leap which connects start to mwm exit in LeapsOnly mode we need
  // to drop first segment of the leap because we already have its twin from the previous mwm.
  bool dropFirstSegment = false;

  // While route building in LeapOnly mode we estimate start to mwm exit distance. This estimation may
  // be incorrect and it causes appearance of unneeded loops: route goes from start to wrongly selected mwm exit,
  // then we have small unneeded leap in other mwm which returns us to start mwm, then we have leap in start mwm
  // to the correct start mwm exit and then we have normal route.
  // |input| mwm ids for such case look like
  // { fake, startId, otherId, otherId, startId, startId, .. pairs of ids for other leaps .. , finishId, fake }.

  // Stable solution here is to calculate all routes with and without loops, and choose the best one.
  // https://github.com/organicmaps/organicmaps/issues/821
  // https://github.com/organicmaps/organicmaps/issues/2085
  // https://github.com/organicmaps/organicmaps/issues/5069

  buffer_vector<size_t, 4> arrBeg, arrEnd;
  size_t const begIdx = 1;
  size_t const endIdx = input.size() - 2;

  auto const firstMwmId = input[begIdx].GetMwmId();
  for (size_t i = begIdx; i < endIdx; ++i)
    if (input[i].GetMwmId() == firstMwmId && (i % 2 == 1))
      arrBeg.push_back(i);

  auto const lastMwmId = input[endIdx].GetMwmId();
  for (size_t i = endIdx; i > begIdx; --i)
    if (input[i].GetMwmId() == lastMwmId && (i % 2 == 0))
      arrEnd.push_back(i);

  size_t const variantsCount = arrBeg.size() * arrEnd.size();
  ASSERT(variantsCount > 0, ());

  for (size_t startLeapEnd : arrBeg)
    for (size_t finishLeapStart : arrEnd)
    {
      size_t maxStart = 0;

      auto const runAStarAlgorithm = [&](size_t start, size_t end, WorldGraphMode mode)
      {
        ASSERT_LESS(start, input.size(), ());
        ASSERT_LESS(end, input.size(), ());

        maxStart = max(maxStart, start);
        auto const contribCoef = static_cast<double>(end - maxStart + 1) / input.size() / variantsCount;