Merge pull request #6371 from bykoianko/master-segment-based-Route

Segment based route. Refactoring. Stage 1.

routing/bicycle_directions.cpp

@@ -143,10 +143,8 @@ bool IsJoint(IRoadGraph::TEdgeVector const & ingoingEdges,
 
 namespace routing
 {
-BicycleDirectionsEngine::BicycleDirectionsEngine(Index const & index,
-                                                 std::shared_ptr<NumMwmIds> numMwmIds,
-                                                 bool generateTrafficSegs)
-  : m_index(index), m_numMwmIds(numMwmIds), m_generateTrafficSegs(generateTrafficSegs)
+BicycleDirectionsEngine::BicycleDirectionsEngine(Index const & index, std::shared_ptr<NumMwmIds> numMwmIds)
+  : m_index(index), m_numMwmIds(numMwmIds)
 {
   CHECK(m_numMwmIds, ());
 }
@@ -154,14 +152,14 @@ BicycleDirectionsEngine::BicycleDirectionsEngine(Index const & index,
 void BicycleDirectionsEngine::Generate(RoadGraphBase const & graph, vector<Junction> const & path,
                                        my::Cancellable const & cancellable, Route::TTimes & times,
                                        Route::TTurns & turns, vector<Junction> & routeGeometry,
-                                       vector<Segment> & trafficSegs)
+                                       vector<Segment> & segments)
 {
   times.clear();
   turns.clear();
   routeGeometry.clear();
   m_adjacentEdges.clear();
   m_pathSegments.clear();
-  trafficSegs.clear();
+  segments.clear();
 
   size_t const pathSize = path.size();
   if (pathSize == 0)
@@ -210,13 +208,13 @@ void BicycleDirectionsEngine::Generate(RoadGraphBase const & graph, vector<Junct
   Route::TStreets streetNames;
 
   MakeTurnAnnotation(resultGraph, delegate, routeGeometry, turns, dummyTimes, streetNames,
-                     trafficSegs);
+                     segments);
   CHECK_EQUAL(routeGeometry.size(), pathSize, ());
   // In case of bicycle routing |m_pathSegments| may have an empty
-  // |LoadedPathSegment::m_trafficSegs| fields. In that case |trafficSegs| is empty
-  // so size of |trafficSegs| is not equal to size of |routeEdges|.
-  if (!trafficSegs.empty())
-    CHECK_EQUAL(trafficSegs.size(), routeEdges.size(), ());
+  // |LoadedPathSegment::m_trafficSegs| fields. In that case |segments| is empty
+  // so size of |segments| is not equal to size of |routeEdges|.
+  if (!segments.empty())
+    CHECK_EQUAL(segments.size(), routeEdges.size(), ());
 }
 
 Index::FeaturesLoaderGuard & BicycleDirectionsEngine::GetLoader(MwmSet::MwmId const & id)
@@ -353,7 +351,9 @@ void BicycleDirectionsEngine::FillPathSegmentsAndAdjacentEdgesMap(
       startSegId = inSegId;
 
     prevJunctions.push_back(prevJunction);
-    if (m_generateTrafficSegs && !inEdge.IsFake())
+    if (inEdge.IsFake())
+      prevSegments.push_back(Segment()); // Fake segment
+    else
       prevSegments.push_back(GetSegment(inFeatureId, inSegId, inIsForward));
 
     if (!IsJoint(ingoingEdges, outgoingEdges, inEdge, routeEdges[i], isCurrJunctionFinish,
@@ -385,7 +385,7 @@ void BicycleDirectionsEngine::FillPathSegmentsAndAdjacentEdgesMap(
     // It leads to preventing pushing item to |prevSegments|. So if there's no enough items in |prevSegments|
     // |pathSegment.m_trafficSegs| should be empty.
     // Note. For the time being BicycleDirectionsEngine is used for turn generation for bicycle and car routes.
-    if (m_generateTrafficSegs && prevSegments.size() + 1 == prevJunctionSize)
+    if (prevSegments.size() + 1 == prevJunctionSize)
       pathSegment.m_trafficSegs = std::move(prevSegments);
 
     auto const it = m_adjacentEdges.insert(make_pair(uniNodeId, std::move(adjacentEdges)));

routing/bicycle_directions.hpp

@@ -24,14 +24,12 @@ public:
 
   using AdjacentEdgesMap = std::map<UniNodeId, AdjacentEdges>;
 
-  BicycleDirectionsEngine(Index const & index,
-                          std::shared_ptr<NumMwmIds> numMwmIds,
-                          bool generateTrafficSegs);
+  BicycleDirectionsEngine(Index const & index, std::shared_ptr<NumMwmIds> numMwmIds);
 
   // IDirectionsEngine override:
   void Generate(RoadGraphBase const & graph, vector<Junction> const & path,
                 my::Cancellable const & cancellable, Route::TTimes & times, Route::TTurns & turns,
-                vector<Junction> & routeGeometry, vector<Segment> & trafficSegs) override;
+                vector<Junction> & routeGeometry, vector<Segment> & segments) override;
 
 private:
   Index::FeaturesLoaderGuard & GetLoader(MwmSet::MwmId const & id);
@@ -60,8 +58,5 @@ private:
   Index const & m_index;
   std::shared_ptr<NumMwmIds> m_numMwmIds;
   std::unique_ptr<Index::FeaturesLoaderGuard> m_loader;
-  // If |m_generateTrafficSegs| is set to true |LoadedPathSegment::m_trafficSeg| is filled
-  // and not otherwise.
-  bool const m_generateTrafficSegs;
 };
 }  // namespace routing

routing/directions_engine.hpp

@@ -21,7 +21,7 @@ public:
   virtual void Generate(RoadGraphBase const & graph, vector<Junction> const & path,
                         my::Cancellable const & cancellable, Route::TTimes & times,
                         Route::TTurns & turns, vector<Junction> & routeGeometry,
-                        vector<Segment> & trafficSegs) = 0;
+                        vector<Segment> & segments) = 0;
 
 protected:
   /// \brief constructs route based on |graph| and |path|. Fills |routeEdges| with the route.

routing/index_router.cpp

@@ -423,7 +423,7 @@ unique_ptr<IndexRouter> IndexRouter::CreateCarRouter(TCountryFileFn const & coun
   auto vehicleModelFactory = make_shared<CarModelFactory>();
   // @TODO Bicycle turn generation engine is used now. It's ok for the time being.
   // But later a special car turn generation engine should be implemented.
-  auto directionsEngine = make_unique<BicycleDirectionsEngine>(index, numMwmIds, true /* generateTrafficSegs */);
+  auto directionsEngine = make_unique<BicycleDirectionsEngine>(index, numMwmIds);
 
   double maxSpeed = 0.0;
   numMwmIds->ForEachId([&](NumMwmId id) {

routing/pedestrian_directions.cpp

@@ -38,7 +38,7 @@ void PedestrianDirectionsEngine::Generate(RoadGraphBase const & graph,
                                           my::Cancellable const & cancellable,
                                           Route::TTimes & times, Route::TTurns & turns,
                                           vector<Junction> & routeGeometry,
-                                          vector<Segment> & /* trafficSegs */)
+                                          vector<Segment> & /* segments */)
 {
   times.clear();
   turns.clear();

routing/pedestrian_directions.hpp

@@ -13,7 +13,7 @@ public:
   // IDirectionsEngine override:
   void Generate(RoadGraphBase const & graph, vector<Junction> const & path,
                 my::Cancellable const & cancellable, Route::TTimes & times, Route::TTurns & turns,
-                vector<Junction> & routeGeometry, vector<Segment> & /* trafficSegs */) override;
+                vector<Junction> & routeGeometry, vector<Segment> & /* segments */) override;
 
 private:
   void CalculateTurns(RoadGraphBase const & graph, vector<Edge> const & routeEdges,

routing/road_graph_router.cpp

@@ -254,7 +254,7 @@ unique_ptr<IRouter> CreateBicycleAStarBidirectionalRouter(Index & index,
   unique_ptr<VehicleModelFactory> vehicleModelFactory(new BicycleModelFactory());
   unique_ptr<IRoutingAlgorithm> algorithm(new AStarBidirectionalRoutingAlgorithm());
   unique_ptr<IDirectionsEngine> directionsEngine(
-      new BicycleDirectionsEngine(index, numMwmIds, false /* generateTrafficSegs */));
+    new BicycleDirectionsEngine(index, numMwmIds));
   unique_ptr<IRouter> router(new RoadGraphRouter(
       "astar-bidirectional-bicycle", index, countryFileFn, IRoadGraph::Mode::ObeyOnewayTag,
       move(vehicleModelFactory), move(algorithm), move(directionsEngine)));

routing/route.cpp

@@ -366,106 +366,6 @@ void Route::Update()
   m_currentTime = 0.0;
 }
 
-void Route::AppendTraffic(Route const & route)
-{
-  CHECK(route.IsValid(), ());
-
-  if (GetTraffic().empty() && route.GetTraffic().empty())
-    return;
-
-  if (!IsValid())
-  {
-    m_traffic = route.GetTraffic();
-    return;
-  }
-
-  // Note. At this point the last item of |m_poly| should be removed.
-  // So the size of |m_traffic| should be equal to size of |m_poly|.
-  if (GetTraffic().empty())
-    m_traffic.resize(m_poly.GetPolyline().GetSize(), SpeedGroup::Unknown);
-
-  CHECK_EQUAL(GetTraffic().size(), m_poly.GetPolyline().GetSize(), ());
-
-  if (route.GetTraffic().empty())
-  {
-    CHECK_GREATER_OR_EQUAL(route.m_poly.GetPolyline().GetSize(), 1, ());
-    // Note. It's necessary to deduct 1 because size of |route.m_poly|
-    // is one less then number of segments of |route.m_poly|. And if |route.m_traffic|
-    // were not empty it would had had route.m_poly.GetPolyline().GetSize() - 1 items.
-    m_traffic.insert(m_traffic.end(),
-                     route.m_poly.GetPolyline().GetSize() - 1 /* number of segments is less by one */,
-                     SpeedGroup::Unknown);
-  }
-  else
-  {
-    m_traffic.insert(m_traffic.end(), route.GetTraffic().cbegin(), route.GetTraffic().cend());
-  }
-}
-
-void Route::AppendRoute(Route const & route)
-{
-  if (!route.IsValid())
-    return;
-
-  double const estimatedTime = m_times.empty() ? 0.0 : m_times.back().second;
-  if (m_poly.GetPolyline().GetSize() != 0)
-  {
-    ASSERT(!m_turns.empty(), ());
-    ASSERT(!m_times.empty(), ());
-    if (!m_streets.empty())
-      ASSERT_LESS(m_streets.back().first + 1, m_poly.GetPolyline().GetSize(), ());
-
-    // Remove road end point and turn instruction.
-    ASSERT_LESS(MercatorBounds::DistanceOnEarth(m_poly.End().m_pt, route.m_poly.Begin().m_pt),
-                2 /* meters */, ());
-    m_poly.PopBack();
-    CHECK(!m_turns.empty(), ());
-    ASSERT_EQUAL(m_turns.back().m_turn, TurnDirection::ReachedYourDestination, ());
-    m_turns.pop_back();
-    CHECK(!m_times.empty(), ());
-    m_times.pop_back();
-  }
-
-  size_t const indexOffset = m_poly.GetPolyline().GetSize();
-
-  // Appending turns.
-  for (auto t : route.m_turns)
-  {
-    if (t.m_index == 0)
-      continue;
-    t.m_index += indexOffset;
-    m_turns.push_back(move(t));
-  }
-
-  // Appending street names.
-  for (auto s : route.m_streets)
-  {
-    if (s.first == 0)
-      continue;
-    s.first += indexOffset;
-    m_streets.push_back(move(s));
-  }
-
-  // Appending times.
-  for (auto t : route.m_times)
-  {
-    if (t.first == 0)
-      continue;
-    t.first += indexOffset;
-    t.second += estimatedTime;
-    m_times.push_back(move(t));
-  }
-
-  AppendTraffic(route);
-
-  m_poly.Append(route.m_poly);
-  if (!GetTraffic().empty())
-  {
-    CHECK_EQUAL(GetTraffic().size() + 1, m_poly.GetPolyline().GetSize(), ());
-  }
-  Update();
-}
-
 // Subroute interface fake implementation ---------------------------------------------------------
 // This implementation is valid for one subroute which is equal to the route.
 size_t Route::GetSubrouteCount() const { return IsValid() ? 1 : 0; }

routing/route.hpp

@@ -134,15 +134,6 @@ public:
   inline void SetStreetNames(TStreets && v) { m_streets = move(v); }
   inline void SetAltitudes(feature::TAltitudes && v) { m_altitudes = move(v); }
   inline void SetTraffic(vector<traffic::SpeedGroup> && v) { m_traffic = move(v); }
-  /// \brief Glues all |route| attributes to |this| except for |m_altitudes|.
-  // @TODO In the future this method should append |m_altitudes| as well.
-  // It's not implemented now because it's not easy to do it and it'll not be used in
-  // the short future. The problem is routes generated by osrm have empty |m_altitudes|.
-  // So |m_altitudes| should be filled (with correnct or default values) on osrm route
-  // reconstruction stage to be added with this method. On the other
-  // hand it seems this method'll not be not used for bicycle and pedestrian routing
-  // in short future. And altitude is not used for car routing.
-  void AppendRoute(Route const & route);
 
   uint32_t GetTotalTimeSec() const;
   uint32_t GetCurrentTimeToEndSec() const;
@@ -242,7 +233,6 @@ private:
   double GetPolySegAngle(size_t ind) const;
   TTurns::const_iterator GetCurrentTurn() const;
   TStreets::const_iterator GetCurrentStreetNameIterAfter(FollowedPolyline::Iter iter) const;
-  void AppendTraffic(Route const & route);
 
   Junction GetJunction(size_t pointIdx) const;
 

routing/routing_benchmarks/bicycle_routing_tests.cpp

@@ -29,7 +29,7 @@ protected:
     shared_ptr<routing::NumMwmIds> numMwmIds) override
   {
     unique_ptr<routing::IDirectionsEngine> engine(new routing::BicycleDirectionsEngine(
-        m_index, numMwmIds, false /* generateTrafficSegs */));
+        m_index, numMwmIds));
     return engine;
   }
 

routing/routing_helpers.cpp

@@ -29,8 +29,8 @@ void ReconstructRoute(IDirectionsEngine & engine, RoadGraphBase const & graph,
   vector<Junction> junctions;
   // @TODO(bykoianko) streetNames is not filled in Generate(). It should be done.
   Route::TStreets streetNames;
-  vector<Segment> trafficSegs;
-  engine.Generate(graph, path, cancellable, times, turnsDir, junctions, trafficSegs);
+  vector<Segment> segments;
+  engine.Generate(graph, path, cancellable, times, turnsDir, junctions, segments);
 
   if (cancellable.IsCancelled())
     return;
@@ -43,7 +43,7 @@ void ReconstructRoute(IDirectionsEngine & engine, RoadGraphBase const & graph,
   }
 
   // @TODO(bykoianko) If the start and the finish of a route lies on the same road segment
-  // engine->Generate() fills with empty vectors |times|, |turnsDir|, |junctions| and |trafficSegs|.
+  // engine->Generate() fills with empty vectors |times|, |turnsDir|, |junctions| and |segments|.
   // It's not correct and should be fixed. It's necessary to work corrrectly with such routes.
 
   vector<m2::PointD> routeGeometry;
@@ -61,10 +61,10 @@ void ReconstructRoute(IDirectionsEngine & engine, RoadGraphBase const & graph,
   }
 
   vector<traffic::SpeedGroup> traffic;
-  if (trafficStash && !trafficSegs.empty())
+  if (trafficStash && !segments.empty())
   {
-    traffic.reserve(trafficSegs.size());
-    for (Segment const & seg : trafficSegs)
+    traffic.reserve(segments.size());
+    for (Segment const & seg : segments)
     {
       traffic::TrafficInfo::RoadSegmentId roadSegment(
           seg.GetFeatureId(), seg.GetSegmentIdx(),
@@ -80,7 +80,7 @@ void ReconstructRoute(IDirectionsEngine & engine, RoadGraphBase const & graph,
       }
       traffic.push_back(segTraffic);
     }
-    CHECK_EQUAL(trafficSegs.size(), traffic.size(), ());
+    CHECK_EQUAL(segments.size(), traffic.size(), ());
   }
 
   route.SetTraffic(move(traffic));