From 448e9fb4c6ab5beb7125db29a7ec5b9bfcc73503 Mon Sep 17 00:00:00 2001
From: Mikhail Gorbushin <m.gorbushin@corp.mail.ru>
Date: Mon, 13 May 2019 23:28:51 +0300
Subject: [PATCH] [routing] push info about fake segments to routing manager

---
 openlr/decoded_path.hpp                       |  4 +-
 openlr/graph.cpp                              |  2 +-
 openlr/graph.hpp                              |  2 +-
 openlr/openlr_decoder.cpp                     |  2 +-
 .../openlr_assessment_tool/mainwindow.cpp     |  2 +-
 openlr/router.cpp                             | 10 ++--
 openlr/router.hpp                             | 14 ++---
 openlr/score_types.hpp                        |  2 +-
 routing/bicycle_directions.cpp                | 25 ++++----
 routing/bicycle_directions.hpp                | 11 ++--
 routing/index_graph_starter.cpp               | 12 ++++
 routing/index_graph_starter.hpp               |  3 +
 routing/index_road_graph.cpp                  |  9 +--
 routing/index_road_graph.hpp                  |  8 +--
 routing/index_router.cpp                      | 10 +++-
 routing/road_graph.cpp                        | 35 ++++++-----
 routing/road_graph.hpp                        | 59 +++++++++++--------
 routing/route.hpp                             |  1 +
 routing/routing_helpers.cpp                   |  9 +++
 .../road_graph_nearest_edges_test.cpp         |  8 +--
 routing/routing_tests/routing_algorithm.cpp   |  4 +-
 routing/turns_generator.cpp                   |  6 +-
 22 files changed, 143 insertions(+), 95 deletions(-)

diff --git a/openlr/decoded_path.hpp b/openlr/decoded_path.hpp
index d41c80852e..8f361ff202 100644
--- a/openlr/decoded_path.hpp
+++ b/openlr/decoded_path.hpp
@@ -16,7 +16,7 @@ class DataSource;
 
 namespace openlr
 {
-using Path = routing::RoadGraphBase::TEdgeVector;
+using Path = routing::RoadGraphBase::EdgeVector;
 using routing::Edge;
 
 NEWTYPE(uint32_t, PartnerSegmentId);
@@ -45,5 +45,5 @@ namespace routing
 inline m2::PointD GetStart(Edge const & e) { return e.GetStartJunction().GetPoint(); }
 inline m2::PointD GetEnd(Edge const & e) { return e.GetEndJunction().GetPoint(); }
 
-std::vector<m2::PointD> GetPoints(routing::RoadGraphBase::TEdgeVector const & p);
+std::vector<m2::PointD> GetPoints(routing::RoadGraphBase::EdgeVector const & p);
 }  // namespace routing
diff --git a/openlr/graph.cpp b/openlr/graph.cpp
index 6b76b6e418..033f567c8a 100644
--- a/openlr/graph.cpp
+++ b/openlr/graph.cpp
@@ -12,7 +12,7 @@ namespace openlr
 {
 namespace
 {
-using EdgeGetter = void (IRoadGraph::*)(Junction const &, RoadGraphBase::TEdgeVector &) const;
+using EdgeGetter = void (IRoadGraph::*)(Junction const &, RoadGraphBase::EdgeVector &) const;
 
 void GetRegularEdges(Junction const & junction, IRoadGraph const & graph,
                      EdgeGetter const edgeGetter,
diff --git a/openlr/graph.hpp b/openlr/graph.hpp
index 483ead2921..1c6cf8f7c9 100644
--- a/openlr/graph.hpp
+++ b/openlr/graph.hpp
@@ -25,7 +25,7 @@ class Graph
 {
 public:
   using Edge = routing::Edge;
-  using EdgeVector = routing::FeaturesRoadGraph::TEdgeVector;
+  using EdgeVector = routing::FeaturesRoadGraph::EdgeVector;
   using Junction = routing::Junction;
 
   Graph(DataSource const & dataSource, std::shared_ptr<routing::CarModelFactory> carModelFactory);
diff --git a/openlr/openlr_decoder.cpp b/openlr/openlr_decoder.cpp
index db6ab13fe3..ebb1d96ddb 100644
--- a/openlr/openlr_decoder.cpp
+++ b/openlr/openlr_decoder.cpp
@@ -469,7 +469,7 @@ size_t constexpr GetOptimalBatchSize()
   // occupancy) batch size.
   size_t constexpr a = base::LCM(sizeof(LinearSegment), kCacheLineSize) / sizeof(LinearSegment);
   size_t constexpr b =
-      base::LCM(sizeof(IRoadGraph::TEdgeVector), kCacheLineSize) / sizeof(IRoadGraph::TEdgeVector);
+      base::LCM(sizeof(IRoadGraph::EdgeVector), kCacheLineSize) / sizeof(IRoadGraph::EdgeVector);
   return base::LCM(a, b);
 }
 }  // namespace
diff --git a/openlr/openlr_match_quality/openlr_assessment_tool/mainwindow.cpp b/openlr/openlr_match_quality/openlr_assessment_tool/mainwindow.cpp
index 6e222a6199..e9c56ffcd0 100644
--- a/openlr/openlr_match_quality/openlr_assessment_tool/mainwindow.cpp
+++ b/openlr/openlr_match_quality/openlr_assessment_tool/mainwindow.cpp
@@ -200,7 +200,7 @@ public:
 
   std::vector<m2::PointD> GetReachablePoints(m2::PointD const & p) const override
   {
-    routing::FeaturesRoadGraph::TEdgeVector edges;
+    routing::FeaturesRoadGraph::EdgeVector edges;
     m_roadGraph.GetOutgoingEdges(
         routing::Junction(p, feature::kDefaultAltitudeMeters),
         edges);
diff --git a/openlr/router.cpp b/openlr/router.cpp
index 3fbe51aa8b..11f8a39913 100644
--- a/openlr/router.cpp
+++ b/openlr/router.cpp
@@ -427,7 +427,7 @@ uint32_t Router::GetReverseBearing(Vertex const & u, Links const & links) const
 template <typename Fn>
 void Router::ForEachEdge(Vertex const & u, bool outgoing, FunctionalRoadClass restriction, Fn && fn)
 {
-  routing::IRoadGraph::TEdgeVector edges;
+  routing::IRoadGraph::EdgeVector edges;
   if (outgoing)
     GetOutgoingEdges(u.m_junction, edges);
   else
@@ -440,13 +440,13 @@ void Router::ForEachEdge(Vertex const & u, bool outgoing, FunctionalRoadClass re
   }
 }
 
-void Router::GetOutgoingEdges(routing::Junction const & u, routing::IRoadGraph::TEdgeVector & edges)
+void Router::GetOutgoingEdges(routing::Junction const & u, routing::IRoadGraph::EdgeVector & edges)
 {
   GetEdges(u, &routing::IRoadGraph::GetRegularOutgoingEdges,
            &routing::IRoadGraph::GetFakeOutgoingEdges, m_outgoingCache, edges);
 }
 
-void Router::GetIngoingEdges(routing::Junction const & u, routing::IRoadGraph::TEdgeVector & edges)
+void Router::GetIngoingEdges(routing::Junction const & u, routing::IRoadGraph::EdgeVector & edges)
 {
   GetEdges(u, &routing::IRoadGraph::GetRegularIngoingEdges,
            &routing::IRoadGraph::GetFakeIngoingEdges, m_ingoingCache, edges);
@@ -454,8 +454,8 @@ void Router::GetIngoingEdges(routing::Junction const & u, routing::IRoadGraph::T
 
 void Router::GetEdges(routing::Junction const & u, RoadGraphEdgesGetter getRegular,
                       RoadGraphEdgesGetter getFake,
-                      std::map<routing::Junction, routing::IRoadGraph::TEdgeVector> & cache,
-                      routing::IRoadGraph::TEdgeVector & edges)
+                      std::map<routing::Junction, routing::IRoadGraph::EdgeVector> & cache,
+                      routing::IRoadGraph::EdgeVector & edges)
 {
   auto const it = cache.find(u);
   if (it == cache.end())
diff --git a/openlr/router.hpp b/openlr/router.hpp
index 67f864f2fc..1c34d9f6d1 100644
--- a/openlr/router.hpp
+++ b/openlr/router.hpp
@@ -137,7 +137,7 @@ private:
   using Links = map<Vertex, pair<Vertex, Edge>>;
 
   using RoadGraphEdgesGetter = void (routing::IRoadGraph::*)(
-      routing::Junction const & junction, routing::IRoadGraph::TEdgeVector & edges) const;
+      routing::Junction const & junction, routing::IRoadGraph::EdgeVector & edges) const;
 
   bool Init(vector<WayPoint> const & points, double positiveOffsetM, double negativeOffsetM);
   bool FindPath(vector<routing::Edge> & path);
@@ -172,12 +172,12 @@ private:
   template <typename Fn>
   void ForEachEdge(Vertex const & u, bool outgoing, FunctionalRoadClass restriction, Fn && fn);
 
-  void GetOutgoingEdges(routing::Junction const & u, routing::IRoadGraph::TEdgeVector & edges);
-  void GetIngoingEdges(routing::Junction const & u, routing::IRoadGraph::TEdgeVector & edges);
+  void GetOutgoingEdges(routing::Junction const & u, routing::IRoadGraph::EdgeVector & edges);
+  void GetIngoingEdges(routing::Junction const & u, routing::IRoadGraph::EdgeVector & edges);
   void GetEdges(routing::Junction const & u, RoadGraphEdgesGetter getRegular,
                 RoadGraphEdgesGetter getFake,
-                map<routing::Junction, routing::IRoadGraph::TEdgeVector> & cache,
-                routing::IRoadGraph::TEdgeVector & edges);
+                map<routing::Junction, routing::IRoadGraph::EdgeVector> & cache,
+                routing::IRoadGraph::EdgeVector & edges);
 
   template <typename Fn>
   void ForEachNonFakeEdge(Vertex const & u, bool outgoing, FunctionalRoadClass restriction,
@@ -211,8 +211,8 @@ private:
   void FindSingleEdgeApproximation(vector<Edge> const & edges, vector<routing::Edge> & path);
 
   routing::FeaturesRoadGraph & m_graph;
-  map<routing::Junction, routing::IRoadGraph::TEdgeVector> m_outgoingCache;
-  map<routing::Junction, routing::IRoadGraph::TEdgeVector> m_ingoingCache;
+  map<routing::Junction, routing::IRoadGraph::EdgeVector> m_outgoingCache;
+  map<routing::Junction, routing::IRoadGraph::EdgeVector> m_ingoingCache;
   RoadInfoGetter & m_roadInfoGetter;
 
   vector<WayPoint> m_points;
diff --git a/openlr/score_types.hpp b/openlr/score_types.hpp
index 128dbdef3d..5059bacd94 100644
--- a/openlr/score_types.hpp
+++ b/openlr/score_types.hpp
@@ -11,7 +11,7 @@
 namespace openlr
 {
 using Edge = routing::Edge;
-using EdgeVector = routing::RoadGraphBase::TEdgeVector;
+using EdgeVector = routing::RoadGraphBase::EdgeVector;
 
 using Score = uint32_t;
 
diff --git a/routing/bicycle_directions.cpp b/routing/bicycle_directions.cpp
index 5a7deccd5b..b07a4d2064 100644
--- a/routing/bicycle_directions.cpp
+++ b/routing/bicycle_directions.cpp
@@ -35,7 +35,7 @@ using namespace traffic;
 class RoutingResult : public IRoutingResult
 {
 public:
-  RoutingResult(IRoadGraph::TEdgeVector const & routeEdges,
+  RoutingResult(IRoadGraph::EdgeVector const & routeEdges,
                 BicycleDirectionsEngine::AdjacentEdgesMap const & adjacentEdges,
                 TUnpackedPathSegments const & pathSegments)
     : m_routeEdges(routeEdges)
@@ -88,7 +88,7 @@ public:
   }
 
 private:
-  IRoadGraph::TEdgeVector const & m_routeEdges;
+  IRoadGraph::EdgeVector const & m_routeEdges;
   BicycleDirectionsEngine::AdjacentEdgesMap const & m_adjacentEdges;
   TUnpackedPathSegments const & m_pathSegments;
   double m_routeLength;
@@ -99,8 +99,8 @@ private:
 /// \returns false if the junction is an internal point of feature segment and can be considered as
 /// a part of LoadedPathSegment and returns true if the junction should be considered as a beginning
 /// of a new LoadedPathSegment.
-bool IsJoint(IRoadGraph::TEdgeVector const & ingoingEdges,
-             IRoadGraph::TEdgeVector const & outgoingEdges,
+bool IsJoint(IRoadGraph::EdgeVector const & ingoingEdges,
+             IRoadGraph::EdgeVector const & outgoingEdges,
              Edge const & ingoingRouteEdge,
              Edge const & outgoingRouteEdge,
              bool isCurrJunctionFinish,
@@ -184,7 +184,7 @@ bool BicycleDirectionsEngine::Generate(IndexRoadGraph const & graph, vector<Junc
   if (pathSize <= 1)
     return false;
 
-  IRoadGraph::TEdgeVector routeEdges;
+  IRoadGraph::EdgeVector routeEdges;
   graph.GetRouteEdges(routeEdges);
 
   if (routeEdges.empty())
@@ -245,7 +245,7 @@ void BicycleDirectionsEngine::LoadPathAttributes(FeatureID const & featureId, Lo
 }
 
 void BicycleDirectionsEngine::GetSegmentRangeAndAdjacentEdges(
-    IRoadGraph::TEdgeVector const & outgoingEdges, Edge const & inEdge, uint32_t startSegId,
+    IRoadGraph::EdgeVector const & outgoingEdges, Edge const & inEdge, uint32_t startSegId,
     uint32_t endSegId, SegmentRange & segmentRange, TurnCandidates & outgoingTurns)
 {
   outgoingTurns.isCandidatesAngleValid = true;
@@ -298,20 +298,21 @@ void BicycleDirectionsEngine::GetSegmentRangeAndAdjacentEdges(
     sort(outgoingTurns.candidates.begin(), outgoingTurns.candidates.end(), base::LessBy(&TurnCandidate::m_angle));
 }
 
-void BicycleDirectionsEngine::GetEdges(RoadGraphBase const & graph, Junction const & currJunction,
-                                       bool isCurrJunctionFinish, IRoadGraph::TEdgeVector & outgoing,
-                                       IRoadGraph::TEdgeVector & ingoing)
+void BicycleDirectionsEngine::GetEdges(IndexRoadGraph const & graph, Junction const & currJunction,
+                                       bool isCurrJunctionFinish, IRoadGraph::EdgeVector & outgoing,
+                                       IRoadGraph::EdgeVector & ingoing)
 {
   // Note. If |currJunction| is a finish the outgoing edges
   // from finish are not important for turn generation.
   if (!isCurrJunctionFinish)
     graph.GetOutgoingEdges(currJunction, outgoing);
+
   graph.GetIngoingEdges(currJunction, ingoing);
 }
 
 void BicycleDirectionsEngine::FillPathSegmentsAndAdjacentEdgesMap(
     IndexRoadGraph const & graph, vector<Junction> const & path,
-    IRoadGraph::TEdgeVector const & routeEdges, base::Cancellable const & cancellable)
+    IRoadGraph::EdgeVector const & routeEdges, base::Cancellable const & cancellable)
 {
   size_t const pathSize = path.size();
   CHECK_GREATER(pathSize, 1, ());
@@ -330,8 +331,8 @@ void BicycleDirectionsEngine::FillPathSegmentsAndAdjacentEdgesMap(
     Junction const & prevJunction = path[i - 1];
     Junction const & currJunction = path[i];
 
-    IRoadGraph::TEdgeVector outgoingEdges;
-    IRoadGraph::TEdgeVector ingoingEdges;
+    IRoadGraph::EdgeVector outgoingEdges;
+    IRoadGraph::EdgeVector ingoingEdges;
     bool const isCurrJunctionFinish = (i + 1 == pathSize);
     GetEdges(graph, currJunction, isCurrJunctionFinish, outgoingEdges, ingoingEdges);
 
diff --git a/routing/bicycle_directions.hpp b/routing/bicycle_directions.hpp
index 06c8d12cb0..a8571585ca 100644
--- a/routing/bicycle_directions.hpp
+++ b/routing/bicycle_directions.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "routing/directions_engine.hpp"
+#include "routing/index_road_graph.hpp"
 #include "routing/loaded_path_segment.hpp"
 #include "routing/segment.hpp"
 #include "routing/turn_candidate.hpp"
@@ -40,7 +41,7 @@ public:
 private:
   FeaturesLoaderGuard & GetLoader(MwmSet::MwmId const & id);
   void LoadPathAttributes(FeatureID const & featureId, LoadedPathSegment & pathSegment);
-  void GetSegmentRangeAndAdjacentEdges(IRoadGraph::TEdgeVector const & outgoingEdges,
+  void GetSegmentRangeAndAdjacentEdges(IRoadGraph::EdgeVector const & outgoingEdges,
                                        Edge const & inEdge, uint32_t startSegId, uint32_t endSegId,
                                        SegmentRange & segmentRange,
                                        turns::TurnCandidates & outgoingTurns);
@@ -48,12 +49,12 @@ private:
   /// and fills |m_adjacentEdges| and |m_pathSegments|.
   void FillPathSegmentsAndAdjacentEdgesMap(IndexRoadGraph const & graph,
                                            std::vector<Junction> const & path,
-                                           IRoadGraph::TEdgeVector const & routeEdges,
+                                           IRoadGraph::EdgeVector const & routeEdges,
                                            base::Cancellable const & cancellable);
 
-  void GetEdges(RoadGraphBase const & graph, Junction const & currJunction,
-                bool isCurrJunctionFinish, IRoadGraph::TEdgeVector & outgoing,
-                IRoadGraph::TEdgeVector & ingoing);
+  void GetEdges(IndexRoadGraph const & graph, Junction const & currJunction,
+                bool isCurrJunctionFinish, IRoadGraph::EdgeVector & outgoing,
+                IRoadGraph::EdgeVector & ingoing);
 
   AdjacentEdgesMap m_adjacentEdges;
   TUnpackedPathSegments m_pathSegments;
diff --git a/routing/index_graph_starter.cpp b/routing/index_graph_starter.cpp
index 2716f71afd..ce22a270c0 100644
--- a/routing/index_graph_starter.cpp
+++ b/routing/index_graph_starter.cpp
@@ -130,6 +130,18 @@ bool IndexGraphStarter::IsRoutingOptionsGood(Segment const & segment) const
   return m_graph.IsRoutingOptionsGood(segment);
 }
 
+RoutingOptions IndexGraphStarter::GetRoutingOptions(Segment const & segment) const
+{
+  if (segment.IsRealSegment())
+    return m_graph.GetRoutingOptions(segment);
+
+  Segment real;
+  if (!m_fake.FindReal(segment, real))
+    return {};
+
+  return m_graph.GetRoutingOptions(real);
+}
+
 set<NumMwmId> IndexGraphStarter::GetMwms() const
 {
   set<NumMwmId> mwms;
diff --git a/routing/index_graph_starter.hpp b/routing/index_graph_starter.hpp
index 8dc261033f..2b54ca2b30 100644
--- a/routing/index_graph_starter.hpp
+++ b/routing/index_graph_starter.hpp
@@ -65,7 +65,10 @@ public:
   Junction const & GetJunction(Segment const & segment, bool front) const;
   Junction const & GetRouteJunction(std::vector<Segment> const & route, size_t pointIndex) const;
   m2::PointD const & GetPoint(Segment const & segment, bool front) const;
+
   bool IsRoutingOptionsGood(Segment const & segment) const;
+  RoutingOptions GetRoutingOptions(Segment const & segment) const;
+
   uint32_t GetNumFakeSegments() const
   {
     // Maximal number of fake segments in fake graph is numeric_limits<uint32_t>::max()
diff --git a/routing/index_road_graph.cpp b/routing/index_road_graph.cpp
index 9ba9600535..5ef2129e2a 100644
--- a/routing/index_road_graph.cpp
+++ b/routing/index_road_graph.cpp
@@ -30,12 +30,12 @@ IndexRoadGraph::IndexRoadGraph(shared_ptr<NumMwmIds> numMwmIds, IndexGraphStarte
   }
 }
 
-void IndexRoadGraph::GetOutgoingEdges(Junction const & junction, TEdgeVector & edges) const
+void IndexRoadGraph::GetOutgoingEdges(Junction const & junction, EdgeVector & edges) const
 {
   GetEdges(junction, true, edges);
 }
 
-void IndexRoadGraph::GetIngoingEdges(Junction const & junction, TEdgeVector & edges) const
+void IndexRoadGraph::GetIngoingEdges(Junction const & junction, EdgeVector & edges) const
 {
   GetEdges(junction, false, edges);
 }
@@ -77,7 +77,7 @@ void IndexRoadGraph::GetJunctionTypes(Junction const & junction, feature::TypesH
   types = feature::TypesHolder();
 }
 
-void IndexRoadGraph::GetRouteEdges(TEdgeVector & edges) const
+void IndexRoadGraph::GetRouteEdges(EdgeVector & edges) const
 {
   edges.clear();
   edges.reserve(m_segments.size());
@@ -94,6 +94,7 @@ void IndexRoadGraph::GetRouteEdges(TEdgeVector & edges) const
         platform::CountryFile const & file = m_numMwmIds->GetFile(real.GetMwmId());
         MwmSet::MwmId const mwmId = m_dataSource.GetMwmIdByCountryFile(file);
         edges.push_back(Edge::MakeFakeWithRealPart(FeatureID(mwmId, real.GetFeatureId()),
+                                                   segment.GetSegmentIdx(),
                                                    real.IsForward(), real.GetSegmentIdx(),
                                                    junctionFrom, junctionTo));
       }
@@ -117,7 +118,7 @@ void IndexRoadGraph::GetRouteSegments(std::vector<Segment> & segments) const
   segments = m_segments;
 }
 
-void IndexRoadGraph::GetEdges(Junction const & junction, bool isOutgoing, TEdgeVector & edges) const
+void IndexRoadGraph::GetEdges(Junction const & junction, bool isOutgoing, EdgeVector & edges) const
 {
   edges.clear();
 
diff --git a/routing/index_road_graph.hpp b/routing/index_road_graph.hpp
index 41a9225a06..2b9179764a 100644
--- a/routing/index_road_graph.hpp
+++ b/routing/index_road_graph.hpp
@@ -22,17 +22,17 @@ public:
                  DataSource & dataSource);
 
   // IRoadGraphBase overrides:
-  virtual void GetOutgoingEdges(Junction const & junction, TEdgeVector & edges) const override;
-  virtual void GetIngoingEdges(Junction const & junction, TEdgeVector & edges) const override;
+  virtual void GetOutgoingEdges(Junction const & junction, EdgeVector & edges) const override;
+  virtual void GetIngoingEdges(Junction const & junction, EdgeVector & edges) const override;
   virtual double GetMaxSpeedKMpH() const override;
   virtual void GetEdgeTypes(Edge const & edge, feature::TypesHolder & types) const override;
   virtual void GetJunctionTypes(Junction const & junction,
                                 feature::TypesHolder & types) const override;
-  virtual void GetRouteEdges(TEdgeVector & edges) const override;
+  virtual void GetRouteEdges(EdgeVector & edges) const override;
   virtual void GetRouteSegments(std::vector<Segment> & segments) const override;
 
 private:
-  void GetEdges(Junction const & junction, bool isOutgoing, TEdgeVector & edges) const;
+  void GetEdges(Junction const & junction, bool isOutgoing, EdgeVector & edges) const;
   std::vector<Segment> const & GetSegments(Junction const & junction, bool isOutgoing) const;
 
   DataSource & m_dataSource;
diff --git a/routing/index_router.cpp b/routing/index_router.cpp
index a0ad8573c2..3524c7a5af 100644
--- a/routing/index_router.cpp
+++ b/routing/index_router.cpp
@@ -1113,13 +1113,17 @@ RouterResultCode IndexRouter::RedressRoute(vector<Segment> const & segments,
     // to use them.
     if (m_vehicleType == VehicleType::Car)
     {
-      auto const & segment = routeSegment.GetSegment();
+      auto & segment = routeSegment.GetSegment();
+      routeSegment.SetRoadTypes(starter.GetRoutingOptions(segment));
+
       if (segment.IsRealSegment())
       {
         if (!AreSpeedCamerasProhibited(m_numMwmIds->GetFile(segment.GetMwmId())))
           routeSegment.SetSpeedCameraInfo(worldGraph.GetSpeedCamInfo(segment));
-
-        routeSegment.SetRoadTypes(worldGraph.GetRoutingOptions(segment));
+      }
+      else
+      {
+        starter.ConvertToReal(segment);
       }
     }
   }
diff --git a/routing/road_graph.cpp b/routing/road_graph.cpp
index 3aefaffcfb..74d8272de2 100644
--- a/routing/road_graph.cpp
+++ b/routing/road_graph.cpp
@@ -61,21 +61,24 @@ string DebugPrint(Junction const & r)
 Edge Edge::MakeReal(FeatureID const & featureId, bool forward, uint32_t segId,
                     Junction const & startJunction, Junction const & endJunction)
 {
-  return {Type::Real, featureId, forward, segId, startJunction, endJunction};
+  return {Type::Real, featureId, kInvalidFakeSegmentId, forward, segId, startJunction, endJunction};
 }
 
 // static
-Edge Edge::MakeFakeWithRealPart(FeatureID const & featureId, bool forward, uint32_t segId,
+Edge Edge::MakeFakeWithRealPart(FeatureID const & featureId, uint32_t fakeSegmentId,
+                                bool forward, uint32_t segId,
                                 Junction const & startJunction, Junction const & endJunction)
 {
-  return {Type::FakeWithRealPart, featureId, forward, segId, startJunction, endJunction};
+  return {Type::FakeWithRealPart, featureId, fakeSegmentId, forward,
+          segId, startJunction, endJunction};
 }
 
 // static
-Edge Edge::MakeFake(Junction const & startJunction, Junction const & endJunction)
+Edge Edge::MakeFake(Junction const & startJunction,
+                    Junction const & endJunction)
 {
-  return {Type::FakeWithoutRealPart, FeatureID(), true /* forward */, 0 /* segmentId */,
-          startJunction, endJunction};
+  return {Type::FakeWithoutRealPart, FeatureID(), kInvalidFakeSegmentId, true /* forward */,
+          0 /* segmentId */, startJunction, endJunction};
 }
 
 // static
@@ -89,7 +92,8 @@ Edge Edge::MakeFake(Junction const & startJunction, Junction const & endJunction
   return e;
 }
 
-Edge::Edge(Type type, FeatureID const & featureId, bool forward, uint32_t segId,
+Edge::Edge(Type type, FeatureID const & featureId, uint32_t fakeSegmentId,
+           bool forward, uint32_t segId,
            Junction const & startJunction, Junction const & endJunction)
   : m_type(type)
   , m_featureId(featureId)
@@ -97,6 +101,7 @@ Edge::Edge(Type type, FeatureID const & featureId, bool forward, uint32_t segId,
   , m_segId(segId)
   , m_startJunction(startJunction)
   , m_endJunction(endJunction)
+  , m_fakeSegmentId(fakeSegmentId)
 {
   ASSERT_LESS(segId, numeric_limits<uint32_t>::max(), ());
   ASSERT((m_featureId.IsValid() && HasRealPart()) || (!m_featureId.IsValid() && !HasRealPart()),
@@ -197,38 +202,38 @@ void IRoadGraph::CrossIngoingLoader::LoadEdges(FeatureID const & featureId,
 }
 
 // IRoadGraph ------------------------------------------------------------------
-void IRoadGraph::GetOutgoingEdges(Junction const & junction, TEdgeVector & edges) const
+void IRoadGraph::GetOutgoingEdges(Junction const & junction, EdgeVector & edges) const
 {
   GetFakeOutgoingEdges(junction, edges);
   GetRegularOutgoingEdges(junction, edges);
 }
 
-void IRoadGraph::GetIngoingEdges(Junction const & junction, TEdgeVector & edges) const
+void IRoadGraph::GetIngoingEdges(Junction const & junction, EdgeVector & edges) const
 {
   GetFakeIngoingEdges(junction, edges);
   GetRegularIngoingEdges(junction, edges);
 }
 
-void IRoadGraph::GetRegularOutgoingEdges(Junction const & junction, TEdgeVector & edges) const
+void IRoadGraph::GetRegularOutgoingEdges(Junction const & junction, EdgeVector & edges) const
 {
   CrossOutgoingLoader loader(junction, GetMode(), edges);
   ForEachFeatureClosestToCross(junction.GetPoint(), loader);
 }
 
-void IRoadGraph::GetRegularIngoingEdges(Junction const & junction, TEdgeVector & edges) const
+void IRoadGraph::GetRegularIngoingEdges(Junction const & junction, EdgeVector & edges) const
 {
   CrossIngoingLoader loader(junction, GetMode(), edges);
   ForEachFeatureClosestToCross(junction.GetPoint(), loader);
 }
 
-void IRoadGraph::GetFakeOutgoingEdges(Junction const & junction, TEdgeVector & edges) const
+void IRoadGraph::GetFakeOutgoingEdges(Junction const & junction, EdgeVector & edges) const
 {
   auto const it = m_fakeOutgoingEdges.find(junction);
   if (it != m_fakeOutgoingEdges.cend())
     edges.insert(edges.end(), it->second.cbegin(), it->second.cend());
 }
 
-void IRoadGraph::GetFakeIngoingEdges(Junction const & junction, TEdgeVector & edges) const
+void IRoadGraph::GetFakeIngoingEdges(Junction const & junction, EdgeVector & edges) const
 {
   auto const it = m_fakeIngoingEdges.find(junction);
   if (it != m_fakeIngoingEdges.cend())
@@ -241,7 +246,7 @@ void IRoadGraph::ResetFakes()
   m_fakeIngoingEdges.clear();
 }
 
-void IRoadGraph::AddEdge(Junction const & j, Edge const & e, map<Junction, TEdgeVector> & edges)
+void IRoadGraph::AddEdge(Junction const & j, Edge const & e, map<Junction, EdgeVector> & edges)
 {
   auto & cont = edges[j];
   ASSERT(is_sorted(cont.cbegin(), cont.cend()), ());
@@ -327,7 +332,7 @@ IRoadGraph::RoadInfo MakeRoadInfoForTesting(bool bidirectional, double speedKMPH
   return ri;
 }
 // RoadGraphBase ------------------------------------------------------------------
-void RoadGraphBase::GetRouteEdges(TEdgeVector & routeEdges) const
+void RoadGraphBase::GetRouteEdges(EdgeVector & routeEdges) const
 {
   NOTIMPLEMENTED()
 }
diff --git a/routing/road_graph.hpp b/routing/road_graph.hpp
index ad9b9d64c3..ee3c0c7ac5 100644
--- a/routing/road_graph.hpp
+++ b/routing/road_graph.hpp
@@ -5,13 +5,13 @@
 #include "routing_common/maxspeed_conversion.hpp"
 #include "routing_common/vehicle_model.hpp"
 
+#include "indexer/feature_altitude.hpp"
+#include "indexer/feature_data.hpp"
+
 #include "geometry/point2d.hpp"
 
 #include "base/string_utils.hpp"
 
-#include "indexer/feature_altitude.hpp"
-#include "indexer/feature_data.hpp"
-
 #include <initializer_list>
 #include <map>
 #include <vector>
@@ -71,8 +71,9 @@ public:
 
   static Edge MakeReal(FeatureID const & featureId, bool forward, uint32_t segId,
                        Junction const & startJunction, Junction const & endJunction);
-  static Edge MakeFakeWithRealPart(FeatureID const & featureId, bool forward, uint32_t segId,
-                                   Junction const & startJunction, Junction const & endJunctio);
+  static Edge MakeFakeWithRealPart(FeatureID const & featureId, uint32_t fakeSegmentId,
+                                   bool forward, uint32_t segId,
+                                   Junction const & startJunction, Junction const & endJunction);
   static Edge MakeFake(Junction const & startJunction, Junction const & endJunction);
   static Edge MakeFake(Junction const & startJunction, Junction const & endJunction,
                        Edge const & prototype);
@@ -80,12 +81,17 @@ public:
   inline FeatureID GetFeatureId() const { return m_featureId; }
   inline bool IsForward() const { return m_forward; }
   inline uint32_t GetSegId() const { return m_segId; }
+  inline uint32_t GetFakeSegmentId() const { return m_fakeSegmentId; }
+
   inline Junction const & GetStartJunction() const { return m_startJunction; }
   inline Junction const & GetEndJunction() const { return m_endJunction; }
+
   inline m2::PointD const & GetStartPoint() const { return m_startJunction.GetPoint(); }
   inline m2::PointD const & GetEndPoint() const { return m_endJunction.GetPoint(); }
+
   inline bool IsFake() const { return  m_type != Type::Real; }
   inline bool HasRealPart() const { return m_type != Type::FakeWithoutRealPart; }
+
   inline m2::PointD GetDirection() const
   {
     return GetEndJunction().GetPoint() - GetStartJunction().GetPoint();
@@ -100,8 +106,9 @@ public:
   bool operator<(Edge const & r) const;
 
 private:
-  Edge(Type type, FeatureID const & featureId, bool forward, uint32_t segId,
-       Junction const & startJunction, Junction const & endJunction);
+  Edge(Type type, FeatureID const & featureId, uint32_t fakeSegmentId,
+       bool forward, uint32_t segId, Junction const & startJunction,
+       Junction const & endJunction);
 
   friend string DebugPrint(Edge const & r);
 
@@ -126,18 +133,22 @@ private:
   // is less than index |m_endJunction|.
   // If |m_forward| == false index of |m_startJunction| point at the feature |m_featureId|
   // is more than index |m_endJunction|.
+
+  static auto constexpr kInvalidFakeSegmentId = std::numeric_limits<uint32_t>::max();
+  // In case of |m_type| == Type::FakeWithRealPart, save it's segmentId from IndexGraphStarter.
+  uint32_t m_fakeSegmentId;
 };
 
 class RoadGraphBase
 {
 public:
-  typedef vector<Edge> TEdgeVector;
+  using EdgeVector = std::vector<Edge>;
 
   /// Finds all nearest outgoing edges, that route to the junction.
-  virtual void GetOutgoingEdges(Junction const & junction, TEdgeVector & edges) const = 0;
+  virtual void GetOutgoingEdges(Junction const & junction, EdgeVector & edges) const = 0;
 
   /// Finds all nearest ingoing edges, that route to the junction.
-  virtual void GetIngoingEdges(Junction const & junction, TEdgeVector & edges) const = 0;
+  virtual void GetIngoingEdges(Junction const & junction, EdgeVector & edges) const = 0;
 
   /// Returns max speed in KM/H
   virtual double GetMaxSpeedKMpH() const = 0;
@@ -148,7 +159,7 @@ public:
   /// @return Types for specified junction
   virtual void GetJunctionTypes(Junction const & junction, feature::TypesHolder & types) const = 0;
 
-  virtual void GetRouteEdges(TEdgeVector & routeEdges) const;
+  virtual void GetRouteEdges(EdgeVector & routeEdges) const;
   virtual void GetRouteSegments(std::vector<Segment> & segments) const;
 };
 
@@ -186,7 +197,7 @@ public:
   class ICrossEdgesLoader
   {
   public:
-    ICrossEdgesLoader(Junction const & cross, IRoadGraph::Mode mode, TEdgeVector & edges)
+    ICrossEdgesLoader(Junction const & cross, IRoadGraph::Mode mode, EdgeVector & edges)
       : m_cross(cross), m_mode(mode), m_edges(edges)
     {
     }
@@ -231,13 +242,13 @@ public:
 
     Junction const m_cross;
     IRoadGraph::Mode const m_mode;
-    TEdgeVector & m_edges;
+    EdgeVector & m_edges;
   };
 
   class CrossOutgoingLoader : public ICrossEdgesLoader
   {
   public:
-    CrossOutgoingLoader(Junction const & cross, IRoadGraph::Mode mode, TEdgeVector & edges)
+    CrossOutgoingLoader(Junction const & cross, IRoadGraph::Mode mode, EdgeVector & edges)
       : ICrossEdgesLoader(cross, mode, edges)
     {
     }
@@ -251,7 +262,7 @@ public:
   class CrossIngoingLoader : public ICrossEdgesLoader
   {
   public:
-    CrossIngoingLoader(Junction const & cross, IRoadGraph::Mode mode, TEdgeVector & edges)
+    CrossIngoingLoader(Junction const & cross, IRoadGraph::Mode mode, EdgeVector & edges)
       : ICrossEdgesLoader(cross, mode, edges)
     {
     }
@@ -264,9 +275,9 @@ public:
 
   virtual ~IRoadGraph() = default;
 
-  void GetOutgoingEdges(Junction const & junction, TEdgeVector & edges) const override;
+  void GetOutgoingEdges(Junction const & junction, EdgeVector & edges) const override;
 
-  void GetIngoingEdges(Junction const & junction, TEdgeVector & edges) const override;
+  void GetIngoingEdges(Junction const & junction, EdgeVector & edges) const override;
 
   /// Removes all fake turns and vertices from the graph.
   void ResetFakes();
@@ -309,16 +320,16 @@ public:
   virtual void ClearState() {}
 
   /// \brief Finds all outgoing regular (non-fake) edges for junction.
-  void GetRegularOutgoingEdges(Junction const & junction, TEdgeVector & edges) const;
+  void GetRegularOutgoingEdges(Junction const & junction, EdgeVector & edges) const;
   /// \brief Finds all ingoing regular (non-fake) edges for junction.
-  void GetRegularIngoingEdges(Junction const & junction, TEdgeVector & edges) const;
+  void GetRegularIngoingEdges(Junction const & junction, EdgeVector & edges) const;
   /// \brief Finds all outgoing fake edges for junction.
-  void GetFakeOutgoingEdges(Junction const & junction, TEdgeVector & edges) const;
+  void GetFakeOutgoingEdges(Junction const & junction, EdgeVector & edges) const;
   /// \brief Finds all ingoing fake edges for junction.
-  void GetFakeIngoingEdges(Junction const & junction, TEdgeVector & edges) const;
+  void GetFakeIngoingEdges(Junction const & junction, EdgeVector & edges) const;
 
 private:
-  void AddEdge(Junction const & j, Edge const & e, std::map<Junction, TEdgeVector> & edges);
+  void AddEdge(Junction const & j, Edge const & e, std::map<Junction, EdgeVector> & edges);
 
   template <typename Fn>
   void ForEachFakeEdge(Fn && fn)
@@ -338,8 +349,8 @@ private:
 
   /// \note |m_fakeIngoingEdges| and |m_fakeOutgoingEdges| map junctions to sorted vectors.
   /// Items to these maps should be inserted with AddEdge() method only.
-  std::map<Junction, TEdgeVector> m_fakeIngoingEdges;
-  std::map<Junction, TEdgeVector> m_fakeOutgoingEdges;
+  std::map<Junction, EdgeVector> m_fakeIngoingEdges;
+  std::map<Junction, EdgeVector> m_fakeOutgoingEdges;
 };
 
 string DebugPrint(IRoadGraph::Mode mode);
diff --git a/routing/route.hpp b/routing/route.hpp
index f16b2b7b8e..eae1194fd4 100644
--- a/routing/route.hpp
+++ b/routing/route.hpp
@@ -87,6 +87,7 @@ public:
   }
 
   Segment const & GetSegment() const { return m_segment; }
+  Segment & GetSegment() { return m_segment; }
   Junction const & GetJunction() const { return m_junction; }
   std::string const & GetStreet() const { return m_street; }
   traffic::SpeedGroup GetTraffic() const { return m_traffic; }
diff --git a/routing/routing_helpers.cpp b/routing/routing_helpers.cpp
index b532ac8011..309b01d523 100644
--- a/routing/routing_helpers.cpp
+++ b/routing/routing_helpers.cpp
@@ -145,10 +145,19 @@ void ReconstructRoute(IDirectionsEngine & engine, IndexRoadGraph const & graph,
 Segment ConvertEdgeToSegment(NumMwmIds const & numMwmIds, Edge const & edge)
 {
   if (edge.IsFake())
+  {
+    if (edge.HasRealPart())
+    {
+      return Segment(kFakeNumMwmId, FakeFeatureIds::kIndexGraphStarterId, edge.GetFakeSegmentId(),
+                     true /* forward */);
+    }
+
     return Segment();
+  }
 
   NumMwmId const numMwmId =
       numMwmIds.GetId(edge.GetFeatureId().m_mwmId.GetInfo()->GetLocalFile().GetCountryFile());
+
   return Segment(numMwmId, edge.GetFeatureId().m_index, edge.GetSegId(), edge.IsForward());
 }
 }  // namespace routing
diff --git a/routing/routing_tests/road_graph_nearest_edges_test.cpp b/routing/routing_tests/road_graph_nearest_edges_test.cpp
index 09b8048594..86f7f6c3a4 100644
--- a/routing/routing_tests/road_graph_nearest_edges_test.cpp
+++ b/routing/routing_tests/road_graph_nearest_edges_test.cpp
@@ -58,7 +58,7 @@ UNIT_TEST(RoadGraph_NearestEdges)
   Junction const crossPos = MakeJunctionForTesting(m2::PointD(0, 0));
 
   // Expected outgoing edges.
-  IRoadGraph::TEdgeVector expectedOutgoing = {
+  IRoadGraph::EdgeVector expectedOutgoing = {
       Edge::MakeReal(MakeTestFeatureID(0) /* first road */, false /* forward */, 1 /* segId */,
                      MakeJunctionForTesting(m2::PointD(0, 0)),
                      MakeJunctionForTesting(m2::PointD(-1, 0))),
@@ -75,7 +75,7 @@ UNIT_TEST(RoadGraph_NearestEdges)
   sort(expectedOutgoing.begin(), expectedOutgoing.end());
 
   // Expected ingoing edges.
-  IRoadGraph::TEdgeVector expectedIngoing = {
+  IRoadGraph::EdgeVector expectedIngoing = {
       Edge::MakeReal(MakeTestFeatureID(0) /* first road */, true /* forward */, 1 /* segId */,
                      MakeJunctionForTesting(m2::PointD(-1, 0)),
                      MakeJunctionForTesting(m2::PointD(0, 0))),
@@ -92,13 +92,13 @@ UNIT_TEST(RoadGraph_NearestEdges)
   sort(expectedIngoing.begin(), expectedIngoing.end());
 
   // Check outgoing edges.
-  IRoadGraph::TEdgeVector actualOutgoing;
+  IRoadGraph::EdgeVector actualOutgoing;
   graph.GetOutgoingEdges(crossPos, actualOutgoing);
   sort(actualOutgoing.begin(), actualOutgoing.end());
   TEST_EQUAL(expectedOutgoing, actualOutgoing, ());
 
   // Check ingoing edges.
-  IRoadGraph::TEdgeVector actualIngoing;
+  IRoadGraph::EdgeVector actualIngoing;
   graph.GetIngoingEdges(crossPos, actualIngoing);
   sort(actualIngoing.begin(), actualIngoing.end());
   TEST_EQUAL(expectedIngoing, actualIngoing, ());
diff --git a/routing/routing_tests/routing_algorithm.cpp b/routing/routing_tests/routing_algorithm.cpp
index 53a8e7c547..2b89beb314 100644
--- a/routing/routing_tests/routing_algorithm.cpp
+++ b/routing/routing_tests/routing_algorithm.cpp
@@ -59,7 +59,7 @@ public:
 
   void GetOutgoingEdgesList(Vertex const & v, vector<Edge> & adj) override
   {
-    IRoadGraph::TEdgeVector edges;
+    IRoadGraph::EdgeVector edges;
     m_roadGraph.GetOutgoingEdges(v, edges);
 
     adj.clear();
@@ -77,7 +77,7 @@ public:
 
   void GetIngoingEdgesList(Vertex const & v, vector<Edge> & adj) override
   {
-    IRoadGraph::TEdgeVector edges;
+    IRoadGraph::EdgeVector edges;
     m_roadGraph.GetIngoingEdges(v, edges);
 
     adj.clear();
diff --git a/routing/turns_generator.cpp b/routing/turns_generator.cpp
index 130e2288b0..4466f47430 100644
--- a/routing/turns_generator.cpp
+++ b/routing/turns_generator.cpp
@@ -569,9 +569,9 @@ bool GetNextRoutePointIndex(IRoutingResult const & result, RoutePointIndex const
 }
 
 RouterResultCode MakeTurnAnnotation(IRoutingResult const & result, NumMwmIds const & numMwmIds,
-                                       RouterDelegate const & delegate,
-                                       vector<Junction> & junctions, Route::TTurns & turnsDir,
-                                       Route::TStreets & streets, vector<Segment> & segments)
+                                    RouterDelegate const & delegate,
+                                    vector<Junction> & junctions, Route::TTurns & turnsDir,
+                                    Route::TStreets & streets, vector<Segment> & segments)
 {
   LOG(LDEBUG, ("Shortest th length:", result.GetPathLength()));