Method ReconstructPath

tools/openlr/router.cpp:624–706

}

bool Router::ReconstructPath(std::vector<Edge> & edges, Path & path)
{
  CHECK_GREATER_OR_EQUAL(m_points.size(), 2, ());

  using EdgeIt = std::vector<Edge>::iterator;
  using EdgeItRev = std::vector<Edge>::reverse_iterator;

  double const kFakeCoverageThreshold = 0.5;

  base::EraseIf(edges, [](auto && e) { return e.IsSpecial(); });

  {
    auto toPair = [](auto && e) { return e.ToPair(); };
    size_t const n = FindPrefixLengthToConsume(make_transform_iterator(edges.begin(), toPair),
                                               make_transform_iterator(edges.end(), toPair), m_positiveOffsetM);
    CHECK_LESS_OR_EQUAL(n, edges.size(), ());
    edges.erase(edges.begin(), edges.begin() + n);
  }

  {
    auto toPairRev = [](auto && e) { return e.ToPairRev(); };
    size_t const n = FindPrefixLengthToConsume(make_transform_iterator(edges.rbegin(), toPairRev),
                                               make_transform_iterator(edges.rend(), toPairRev), m_negativeOffsetM);
    CHECK_LESS_OR_EQUAL(n, edges.size(), ());
    edges.erase(edges.begin() + edges.size() - n, edges.end());
  }

  double frontEdgeScore = -1.0;
  routing::Edge frontEdge;
  ForStagePrefix(edges.begin(), edges.end(), 0, [&](EdgeIt e)
  {
    ForEachNonFakeEdge(e->m_u, false /* outgoing */, m_points[0].m_lfrcnp, [&](routing::Edge const & edge)
    {
      auto toPairRev = [](auto && e) { return e.ToPairRev(); };
      double const score = GetMatchingScore(edge.GetEndJunction().GetPoint(), edge.GetStartJunction().GetPoint(),
                                            make_transform_iterator(EdgeItRev(e), toPairRev),
                                            make_transform_iterator(edges.rend(), toPairRev));
      if (score > frontEdgeScore)
      {
        frontEdgeScore = score;
        frontEdge = edge.GetReverseEdge();
      }
    });
  });

  double backEdgeScore = -1.0;
  routing::Edge backEdge;
  ForStagePrefix(edges.rbegin(), edges.rend(), m_points.size() - 2 /* stage */, [&](EdgeItRev e)
  {
    ForEachNonFakeEdge(e->m_v, true /* outgoing */, m_points[m_points.size() - 2].m_lfrcnp,
                       [&](routing::Edge const & edge)
    {
      auto toPair = [](auto && e) { return e.ToPair(); };
      double const score =
          GetMatchingScore(edge.GetStartJunction().GetPoint(), edge.GetEndJunction().GetPoint(),
                           make_transform_iterator(e.base(), toPair), make_transform_iterator(edges.end(), toPair));
      if (score > backEdgeScore)
      {