Woring on preparing data for painting routing.master-route-painting

19 files changed, 112 insertions, 21 deletions

diff --git a/3party/Alohalytics b/3party/Alohalytics
-Subproject a3e1659ba90ed079b3021ea2fa45a628a832b8e
+Subproject 28f74496e58213dd0bc7d793fd17ba0e7f3d89b
diff --git a/map/framework.cpp b/map/framework.cpp
index 48605942f3..b7ddcc3f6d 100644
--- a/map/framework.cpp
+++ b/map/framework.cpp
@@ -2559,15 +2559,15 @@ void Framework::InsertRoute(Route const & route)
 
   // TODO(@bykoianko): set traffic by route.
   // TEMPORARY {
-  vector<traffic::SpeedGroup> traffic;
-  //traffic.resize(route.GetPoly().GetSize() - 1, traffic::SpeedGroup::Unknown);
-  //for (size_t i = 0; i < traffic.size(); i++)
-  //{
-  //  traffic[i] = static_cast<traffic::SpeedGroup>(rand() % static_cast<int>(traffic::SpeedGroup::Count));
-  //}
-  // } TEMPORARY
-
-  m_drapeEngine->AddRoute(route.GetPoly(), turns, routeColor, traffic, pattern);
+//  vector<traffic::SpeedGroup> traffic;
+//  traffic.resize(route.GetPoly().GetSize() - 1, traffic::SpeedGroup::Unknown);
+//  for (size_t i = 0; i < traffic.size(); i++)
+//  {
+//    traffic[i] = static_cast<traffic::SpeedGroup>(rand() % static_cast<int>(traffic::SpeedGroup::Count));
+//  }
+//   } TEMPORARY
+
+  m_drapeEngine->AddRoute(route.GetPoly(), turns, routeColor, route.GetTraffic(), pattern);
 }
 
 void Framework::CheckLocationForRouting(GpsInfo const & info)
diff --git a/routing/bicycle_directions.cpp b/routing/bicycle_directions.cpp
index 19f3ab28b0..46bd9a91ba 100644
--- a/routing/bicycle_directions.cpp
+++ b/routing/bicycle_directions.cpp
@@ -1,9 +1,12 @@
 #include "routing/bicycle_directions.hpp"
 #include "routing/car_model.hpp"
+#include "routing/road_point.hpp"
 #include "routing/router_delegate.hpp"
 #include "routing/routing_result_graph.hpp"
 #include "routing/turns_generator.hpp"
 
+#include "traffic/traffic_info.hpp"
+
 #include "indexer/ftypes_matcher.hpp"
 #include "indexer/index.hpp"
 #include "indexer/scales.hpp"
@@ -14,6 +17,7 @@ namespace
 {
 using namespace routing;
 using namespace routing::turns;
+using namespace traffic;
 
 class RoutingResult : public IRoutingResult
 {
@@ -83,6 +87,7 @@ BicycleDirectionsEngine::BicycleDirectionsEngine(Index const & index) : m_index(
 void BicycleDirectionsEngine::Generate(IRoadGraph const & graph, vector<Junction> const & path,
                                        Route::TTimes & times, Route::TTurns & turns,
                                        vector<Junction> & routeGeometry,
+                                       vector<traffic::TrafficInfo::RoadSegmentId> & routeSegs,
                                        my::Cancellable const & cancellable)
 {
   times.clear();
@@ -90,6 +95,7 @@ void BicycleDirectionsEngine::Generate(IRoadGraph const & graph, vector<Junction
   routeGeometry.clear();
   m_adjacentEdges.clear();
   m_pathSegments.clear();
+  routeSegs.clear();
 
   size_t const pathSize = path.size();
   if (pathSize == 0)
@@ -158,8 +164,16 @@ void BicycleDirectionsEngine::Generate(IRoadGraph const & graph, vector<Junction
     }
 
     LoadedPathSegment pathSegment;
+    // @TODO This place should be fixed. Putting |prevJunction| and |currJunction|
+    // for every route edge all route points are duplicated.
     if (inFeatureId.IsValid())
       LoadPathGeometry(inFeatureId, {prevJunction, currJunction}, pathSegment);
+    pathSegment.m_routeSegs = {
+      {inFeatureId.m_index,
+       static_cast<uint16_t>(routeEdges[i - 1].GetSegId()),
+       routeEdges[i - 1].IsForward() ? TrafficInfo::RoadSegmentId::kForwardDirection
+                                     : TrafficInfo::RoadSegmentId::kReverseDirection
+      }};
 
     m_adjacentEdges.insert(make_pair(inFeatureId.m_index, move(adjacentEdges)));
     m_pathSegments.push_back(move(pathSegment));
@@ -170,7 +184,9 @@ void BicycleDirectionsEngine::Generate(IRoadGraph const & graph, vector<Junction
   Route::TTimes turnAnnotationTimes;
   Route::TStreets streetNames;
 
-  MakeTurnAnnotation(resultGraph, delegate, routeGeometry, turns, turnAnnotationTimes, streetNames);
+  MakeTurnAnnotation(resultGraph, delegate, routeGeometry, turns, turnAnnotationTimes,
+                     streetNames, routeSegs);
+//  ASSERT_EQUAL(routeGeometry.size(), routeSegs.size(), ());
 }
 
 Index::FeaturesLoaderGuard & BicycleDirectionsEngine::GetLoader(MwmSet::MwmId const & id)
diff --git a/routing/bicycle_directions.hpp b/routing/bicycle_directions.hpp
index 160e0520cf..5d8284bbfb 100644
--- a/routing/bicycle_directions.hpp
+++ b/routing/bicycle_directions.hpp
@@ -29,6 +29,7 @@ public:
   // IDirectionsEngine override:
   void Generate(IRoadGraph const & graph, vector<Junction> const & path, Route::TTimes & times,
                 Route::TTurns & turns, vector<Junction> & routeGeometry,
+                vector<traffic::TrafficInfo::RoadSegmentId> & routeSegs,
                 my::Cancellable const & cancellable) override;
 
 private:
diff --git a/routing/car_router.cpp b/routing/car_router.cpp
index c02837ea42..432a2471c9 100644
--- a/routing/car_router.cpp
+++ b/routing/car_router.cpp
@@ -7,8 +7,11 @@
 #include "routing/osrm_helpers.hpp"
 #include "routing/osrm_path_segment_factory.hpp"
 #include "routing/road_graph_router.hpp"
+#include "routing/road_point.hpp"
 #include "routing/turns_generator.hpp"
 
+#include "traffic/traffic_info.hpp"
+
 #include "platform/country_file.hpp"
 #include "platform/platform.hpp"
 
@@ -204,6 +207,7 @@ IRouter::ResultCode FindSingleOsrmRoute(FeatureGraphNode const & source,
   Route::TTurns turns;
   Route::TTimes times;
   Route::TStreets streets;
+  vector<traffic::TrafficInfo::RoadSegmentId> routeSegs;
 
   LOG(LINFO, ("OSRM route from", MercatorBounds::ToLatLon(source.segmentPoint), "to",
               MercatorBounds::ToLatLon(target.segmentPoint)));
@@ -214,7 +218,7 @@ IRouter::ResultCode FindSingleOsrmRoute(FeatureGraphNode const & source,
 
   OSRMRoutingResult routingResult(index, *mapping, rawRoutingResult);
   routing::IRouter::ResultCode const result =
-      MakeTurnAnnotation(routingResult, delegate, geometry, turns, times, streets);
+      MakeTurnAnnotation(routingResult, delegate, geometry, turns, times, streets, routeSegs);
   if (result != routing::IRouter::NoError)
   {
     LOG(LWARNING, ("Can't load road path data from disk for", mapping->GetCountryName(),
@@ -225,6 +229,7 @@ IRouter::ResultCode FindSingleOsrmRoute(FeatureGraphNode const & source,
   route.SetTurnInstructions(move(turns));
   route.SetSectionTimes(move(times));
   route.SetStreetNames(move(streets));
+  route.SetTraffic({} /* No traffic info in case of OSRM */);
 
   vector<m2::PointD> mwmPoints;
   JunctionsToPoints(geometry, mwmPoints);
diff --git a/routing/directions_engine.hpp b/routing/directions_engine.hpp
index 7893e9b5c4..8fc71d79d9 100644
--- a/routing/directions_engine.hpp
+++ b/routing/directions_engine.hpp
@@ -1,8 +1,11 @@
 #pragma once
 
 #include "routing/road_graph.hpp"
+#include "routing/road_point.hpp"
 #include "routing/route.hpp"
 
+#include "traffic/traffic_info.hpp"
+
 #include "base/cancellable.hpp"
 
 #include "std/vector.hpp"
@@ -16,7 +19,9 @@ public:
 
   virtual void Generate(IRoadGraph const & graph, vector<Junction> const & path,
                         Route::TTimes & times, Route::TTurns & turns,
-                        vector<Junction> & routeGeometry, my::Cancellable const & cancellable) = 0;
+                        vector<Junction> & routeGeometry,
+                        vector<traffic::TrafficInfo::RoadSegmentId> & routeSegs,
+                        my::Cancellable const & cancellable) = 0;
 
 protected:
   /// \brief constructs route based on |graph| and |path|. Fills |routeEdges| with the route.
diff --git a/routing/loaded_path_segment.hpp b/routing/loaded_path_segment.hpp
index 7b5dad4741..729ac7b012 100644
--- a/routing/loaded_path_segment.hpp
+++ b/routing/loaded_path_segment.hpp
@@ -2,9 +2,12 @@
 
 #include "routing/osrm_helpers.hpp"
 #include "routing/road_graph.hpp"
+#include "routing/road_point.hpp"
 #include "routing/turns.hpp"
 #include "routing/turn_candidate.hpp"
 
+#include "traffic/traffic_info.hpp"
+
 #include "indexer/ftypes_matcher.hpp"
 
 #include "base/buffer_vector.hpp"
@@ -31,6 +34,7 @@ struct LoadedPathSegment
   string m_name;
   TEdgeWeight m_weight; /*!< Time in seconds to pass the segment. */
   TNodeId m_nodeId;     /*!< May be NodeId for OSRM router or FeatureId::index for graph router. */
+  vector<traffic::TrafficInfo::RoadSegmentId> m_routeSegs; /*!< Route segments for |m_path|. */
   ftypes::HighwayClass m_highwayClass;
   bool m_onRoundabout;
   bool m_isLink;
@@ -47,6 +51,7 @@ struct LoadedPathSegment
     m_name.clear();
     m_weight = 0;
     m_nodeId = 0;
+    m_routeSegs.clear();
     m_highwayClass = ftypes::HighwayClass::Undefined;
     m_onRoundabout = false;
     m_isLink = false;
diff --git a/routing/pedestrian_directions.cpp b/routing/pedestrian_directions.cpp
index 30660d3c1a..8ac564a274 100644
--- a/routing/pedestrian_directions.cpp
+++ b/routing/pedestrian_directions.cpp
@@ -35,6 +35,7 @@ PedestrianDirectionsEngine::PedestrianDirectionsEngine()
 void PedestrianDirectionsEngine::Generate(IRoadGraph const & graph, vector<Junction> const & path,
                                           Route::TTimes & times, Route::TTurns & turns,
                                           vector<Junction> & routeGeometry,
+                                          vector<traffic::TrafficInfo::RoadSegmentId> &,
                                           my::Cancellable const & cancellable)
 {
   times.clear();
diff --git a/routing/pedestrian_directions.hpp b/routing/pedestrian_directions.hpp
index 93cf0c91fd..f200bf4724 100644
--- a/routing/pedestrian_directions.hpp
+++ b/routing/pedestrian_directions.hpp
@@ -13,6 +13,7 @@ public:
   // IDirectionsEngine override:
   void Generate(IRoadGraph const & graph, vector<Junction> const & path, Route::TTimes & times,
                 Route::TTurns & turns, vector<Junction> & routeGeometry,
+                vector<traffic::TrafficInfo::RoadSegmentId> &,
                 my::Cancellable const & cancellable) override;
 
 private:
diff --git a/routing/road_graph_router.cpp b/routing/road_graph_router.cpp
index e22de1bcd8..127078329e 100644
--- a/routing/road_graph_router.cpp
+++ b/routing/road_graph_router.cpp
@@ -227,7 +227,7 @@ IRouter::ResultCode RoadGraphRouter::CalculateRoute(m2::PointD const & startPoin
     ASSERT_EQUAL(result.path.front(), startPos, ());
     ASSERT_EQUAL(result.path.back(), finalPos, ());
     ASSERT_GREATER(result.distance, 0., ());
-    ReconstructRoute(m_directionsEngine.get(), *m_roadGraph, delegate, result.path, route);
+    ReconstructRoute(m_directionsEngine.get(), *m_roadGraph, nullptr, delegate, result.path, route);
   }
 
   m_roadGraph->ResetFakes();
diff --git a/routing/route.cpp b/routing/route.cpp
index 7ad678977e..89bbd426a3 100644
--- a/routing/route.cpp
+++ b/routing/route.cpp
@@ -42,6 +42,7 @@ void Route::Swap(Route & rhs)
   swap(m_streets, rhs.m_streets);
   m_absentCountries.swap(rhs.m_absentCountries);
   m_altitudes.swap(rhs.m_altitudes);
+  m_traffic.swap(rhs.m_traffic);
 }
 
 void Route::AddAbsentCountry(string const & name)
@@ -376,6 +377,7 @@ void Route::AppendRoute(Route const & route)
     m_turns.pop_back();
     CHECK(!m_times.empty(), ());
     m_times.pop_back();
+    CHECK(!m_traffic.empty(), ());
   }
 
   size_t const indexOffset = m_poly.GetPolyline().GetSize();
@@ -409,6 +411,7 @@ void Route::AppendRoute(Route const & route)
   }
 
   m_poly.Append(route.m_poly);
+  m_traffic.insert(m_traffic.end(), route.m_traffic.cbegin(), route.m_traffic.cend());
   Update();
 }
 
diff --git a/routing/route.hpp b/routing/route.hpp
index f364fb747b..cd32da5ae9 100644
--- a/routing/route.hpp
+++ b/routing/route.hpp
@@ -3,6 +3,8 @@
 #include "routing/routing_settings.hpp"
 #include "routing/turns.hpp"
 
+#include "traffic/speed_groups.hpp"
+
 #include "indexer/feature_altitude.hpp"
 
 #include "geometry/polyline2d.hpp"
@@ -59,6 +61,7 @@ public:
   inline void SetSectionTimes(TTimes && v) { m_times = move(v); }
   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
@@ -78,6 +81,7 @@ public:
   m2::PolylineD const & GetPoly() const { return m_poly.GetPolyline(); }
   TTurns const & GetTurns() const { return m_turns; }
   feature::TAltitudes const & GetAltitudes() const { return m_altitudes; }
+  vector<traffic::SpeedGroup> const & GetTraffic() const { return m_traffic; }
   vector<double> const & GetSegDistanceM() const { return m_poly.GetSegDistanceM(); }
   void GetTurnsDistances(vector<double> & distances) const;
   string const & GetName() const { return m_name; }
@@ -153,6 +157,7 @@ private:
   TTimes m_times;
   TStreets m_streets;
   feature::TAltitudes m_altitudes;
+  vector<traffic::SpeedGroup> m_traffic;
 
   mutable double m_currentTime;
 };
diff --git a/routing/routing_helpers.cpp b/routing/routing_helpers.cpp
index c7450b9852..daf8dad02d 100644
--- a/routing/routing_helpers.cpp
+++ b/routing/routing_helpers.cpp
@@ -1,8 +1,14 @@
 #include "routing/routing_helpers.hpp"
+#include "routing/road_point.hpp"
+
+#include "traffic/traffic_info.hpp"
 
 namespace routing
 {
+using namespace traffic;
+
 void ReconstructRoute(IDirectionsEngine * engine, IRoadGraph const & graph,
+                      shared_ptr<traffic::TrafficInfo> trafficInfo,
                       my::Cancellable const & cancellable, vector<Junction> & path, Route & route)
 {
   if (path.empty())
@@ -22,8 +28,9 @@ void ReconstructRoute(IDirectionsEngine * engine, IRoadGraph const & graph,
   vector<Junction> junctions;
   // @TODO(bykoianko) streetNames is not filled in Generate(). It should be done.
   Route::TStreets streetNames;
+  vector<TrafficInfo::RoadSegmentId> routeSegs;
   if (engine)
-    engine->Generate(graph, path, times, turnsDir, junctions, cancellable);
+    engine->Generate(graph, path, times, turnsDir, junctions, routeSegs, cancellable);
 
   vector<m2::PointD> routeGeometry;
   JunctionsToPoints(junctions, routeGeometry);
@@ -35,5 +42,28 @@ void ReconstructRoute(IDirectionsEngine * engine, IRoadGraph const & graph,
   route.SetTurnInstructions(move(turnsDir));
   route.SetStreetNames(move(streetNames));
   route.SetAltitudes(move(altitudes));
+
+  vector<traffic::SpeedGroup> traffic;
+  traffic.reserve(routeSegs.size());
+  if (trafficInfo)
+  {
+    for (TrafficInfo::RoadSegmentId const & rp : routeSegs)
+    {
+      auto const it = trafficInfo->GetColoring().find(rp);
+      if (it == trafficInfo->GetColoring().cend())
+      {
+        LOG(LERROR, ("There's no TrafficInfo::RoadSegmentId", rp, "in traffic info for", trafficInfo->GetMwmId()));
+        return;
+      }
+      // @TODO It's written to compensate an error. The problem is in case of any routing except for osrm
+      //
+      traffic.push_back(it->second);
+      traffic.push_back(it->second);
+    }
+    if (!traffic.empty())
+      traffic.pop_back();
+  }
+
+  route.SetTraffic(move(traffic));
 }
 }  // namespace rouing
diff --git a/routing/routing_helpers.hpp b/routing/routing_helpers.hpp
index e05d4f0093..0133eb243f 100644
--- a/routing/routing_helpers.hpp
+++ b/routing/routing_helpers.hpp
@@ -7,8 +7,11 @@
 #include "routing/road_graph.hpp"
 #include "routing/route.hpp"
 
+#include "traffic/traffic_info.hpp"
+
 #include "base/cancellable.hpp"
 
+#include "std/shared_ptr.hpp"
 #include "std/vector.hpp"
 
 namespace routing
@@ -23,5 +26,6 @@ bool IsRoad(TTypes const & types)
 }
 
 void ReconstructRoute(IDirectionsEngine * engine, IRoadGraph const & graph,
+                      shared_ptr<traffic::TrafficInfo> trafficInfo,
                       my::Cancellable const & cancellable, vector<Junction> & path, Route & route);
 }  // namespace rouing
diff --git a/routing/single_mwm_router.cpp b/routing/single_mwm_router.cpp
index bfc45639a8..2f0799cc54 100644
--- a/routing/single_mwm_router.cpp
+++ b/routing/single_mwm_router.cpp
@@ -50,11 +50,13 @@ vector<Junction> ConvertToJunctions(IndexGraphStarter & starter, vector<Joint::I
 namespace routing
 {
 SingleMwmRouter::SingleMwmRouter(string const & name, Index const & index,
+                                 traffic::TrafficCache const & trafficCache,
                                  shared_ptr<VehicleModelFactory> vehicleModelFactory,
                                  shared_ptr<EdgeEstimator> estimator,
                                  unique_ptr<IDirectionsEngine> directionsEngine)
   : m_name(name)
   , m_index(index)
+  , m_trafficCache(trafficCache)
   , m_roadGraph(index, IRoadGraph::Mode::ObeyOnewayTag, vehicleModelFactory)
   , m_vehicleModelFactory(vehicleModelFactory)
   , m_estimator(estimator)
@@ -147,7 +149,8 @@ IRouter::ResultCode SingleMwmRouter::DoCalculateRoute(MwmSet::MwmId const & mwmI
   case AStarAlgorithm<IndexGraphStarter>::Result::Cancelled: return IRouter::Cancelled;
   case AStarAlgorithm<IndexGraphStarter>::Result::OK:
     vector<Junction> path = ConvertToJunctions(starter, routingResult.path);
-    ReconstructRoute(m_directionsEngine.get(), m_roadGraph, delegate, path, route);
+    shared_ptr<traffic::TrafficInfo> trafficInfo = m_trafficCache.GetTrafficInfo(mwmId);
+    ReconstructRoute(m_directionsEngine.get(), m_roadGraph, trafficInfo, delegate, path, route);
     return IRouter::NoError;
   }
 }
@@ -224,7 +227,7 @@ unique_ptr<SingleMwmRouter> SingleMwmRouter::CreateCarRouter(
   auto directionsEngine = make_unique<BicycleDirectionsEngine>(index);
   auto estimator = EdgeEstimator::CreateForCar(*vehicleModelFactory->GetVehicleModel(), trafficCache);
   auto router =
-      make_unique<SingleMwmRouter>("astar-bidirectional-car", index,
+      make_unique<SingleMwmRouter>("astar-bidirectional-car", index, trafficCache,
                                    move(vehicleModelFactory), estimator, move(directionsEngine));
   return router;
 }
diff --git a/routing/single_mwm_router.hpp b/routing/single_mwm_router.hpp
index fbc2413211..3b758a3db8 100644
--- a/routing/single_mwm_router.hpp
+++ b/routing/single_mwm_router.hpp
@@ -20,7 +20,7 @@ class IndexGraph;
 class SingleMwmRouter
 {
 public:
-  SingleMwmRouter(string const & name, Index const & index,
+  SingleMwmRouter(string const & name, Index const & index, traffic::TrafficCache const & trafficCache,
                   shared_ptr<VehicleModelFactory> vehicleModelFactory,
                   shared_ptr<EdgeEstimator> estimator,
                   unique_ptr<IDirectionsEngine> directionsEngine);
@@ -46,6 +46,7 @@ private:
 
   string const m_name;
   Index const & m_index;
+  traffic::TrafficCache const & m_trafficCache;
   FeaturesRoadGraph m_roadGraph;
   shared_ptr<VehicleModelFactory> m_vehicleModelFactory;
   shared_ptr<EdgeEstimator> m_estimator;
diff --git a/routing/turns_generator.cpp b/routing/turns_generator.cpp
index 3f4693677e..87d266ea10 100644
--- a/routing/turns_generator.cpp
+++ b/routing/turns_generator.cpp
@@ -254,9 +254,11 @@ bool TurnInfo::IsSegmentsValid() const
 }
 
 IRouter::ResultCode MakeTurnAnnotation(turns::IRoutingResult const & result,
-                                       RouterDelegate const & delegate, vector<Junction> & junctions,
+                                       RouterDelegate const & delegate,
+                                       vector<Junction> & junctions,
                                        Route::TTurns & turnsDir, Route::TTimes & times,
-                                       Route::TStreets & streets)
+                                       Route::TStreets & streets,
+                                       vector<traffic::TrafficInfo::RoadSegmentId> & routeSegs)
 {
   double estimatedTime = 0;
 
@@ -271,6 +273,7 @@ IRouter::ResultCode MakeTurnAnnotation(turns::IRoutingResult const & result,
   // Annotate turns.
   size_t skipTurnSegments = 0;
   auto const & loadedSegments = result.GetSegments();
+  routeSegs.reserve(loadedSegments.size());
   for (auto loadedSegmentIt = loadedSegments.cbegin(); loadedSegmentIt != loadedSegments.cend();
        ++loadedSegmentIt)
   {
@@ -320,6 +323,8 @@ IRouter::ResultCode MakeTurnAnnotation(turns::IRoutingResult const & result,
 
     // Path geometry.
     junctions.insert(junctions.end(), loadedSegmentIt->m_path.begin(), loadedSegmentIt->m_path.end());
+    routeSegs.insert(routeSegs.end(), loadedSegmentIt->m_routeSegs.cbegin(),
+                      loadedSegmentIt->m_routeSegs.cend());
   }
 
   // Path found. Points will be replaced by start and end edges junctions.
diff --git a/routing/turns_generator.hpp b/routing/turns_generator.hpp
index c2b1c7226e..c867be1cbb 100644
--- a/routing/turns_generator.hpp
+++ b/routing/turns_generator.hpp
@@ -9,7 +9,10 @@
 #include "routing/turns.hpp"
 #include "routing/turn_candidate.hpp"
 
+#include "traffic/traffic_info.hpp"
+
 #include "std/function.hpp"
+#include "std/shared_ptr.hpp"
 #include "std/utility.hpp"
 #include "std/vector.hpp"
 
@@ -40,12 +43,15 @@ using TGetIndexFunction = function<size_t(pair<size_t, size_t>)>;
  * \param turnsDir output turns annotation storage.
  * \param times output times annotation storage.
  * \param streets output street names along the path.
+ * \param traffic road traffic information.
  * \return routing operation result code.
  */
 IRouter::ResultCode MakeTurnAnnotation(turns::IRoutingResult const & result,
-                                       RouterDelegate const & delegate, vector<Junction> & points,
+                                       RouterDelegate const & delegate,
+                                       vector<Junction> & points,
                                        Route::TTurns & turnsDir, Route::TTimes & times,
-                                       Route::TStreets & streets);
+                                       Route::TStreets & streets,
+                                       vector<traffic::TrafficInfo::RoadSegmentId> & routeSegs);
 
 /*!
  * \brief The TurnInfo struct is a representation of a junction.
diff --git a/tools/kothic b/tools/kothic
-Subproject c32d9c5e22d6f42c582c2234e9881cda5f6db4f
+Subproject 1ffa4306fe949c6345414823946ee7b1bbf8a07