diff --git a/geometry/polyline2d.hpp b/geometry/polyline2d.hpp
index 62b15863cb..a5da9877ed 100644
--- a/geometry/polyline2d.hpp
+++ b/geometry/polyline2d.hpp
@@ -3,6 +3,8 @@
 #include "point2d.hpp"
 #include "rect2d.hpp"
 
+#include "../base/internal/message.hpp"
+
 #include "../std/vector.hpp"
 
 
@@ -51,6 +53,11 @@ public:
   typedef typename vector<Point<T> >::const_iterator IterT;
   IterT Begin() const { return m_points.begin(); }
   IterT End() const { return m_points.end(); }
+
+  friend string DebugPrint(PolylineT<T> const & p)
+  {
+    return ::DebugPrint(p.m_points);
+  }
 };
 
 typedef PolylineT<double> PolylineD;
diff --git a/indexer/feature.cpp b/indexer/feature.cpp
index bd61df43f2..dbefd0dee8 100644
--- a/indexer/feature.cpp
+++ b/indexer/feature.cpp
@@ -389,3 +389,15 @@ double FeatureType::GetDistance(m2::PointD const & pt, int scale) const
 
   return calc.m_dist;
 }
+
+void FeatureType::SwapGeometry(FeatureType & r)
+{
+  ASSERT_EQUAL(m_bPointsParsed, r.m_bPointsParsed, ());
+  ASSERT_EQUAL(m_bTrianglesParsed, r.m_bTrianglesParsed, ());
+
+  if (m_bPointsParsed)
+    m_Points.swap(r.m_Points);
+
+  if (m_bTrianglesParsed)
+    m_Triangles.swap(r.m_Triangles);
+}
diff --git a/indexer/feature.hpp b/indexer/feature.hpp
index 88d66b1db2..7d8dce79c2 100644
--- a/indexer/feature.hpp
+++ b/indexer/feature.hpp
@@ -288,6 +288,8 @@ public:
   geom_stat_t GetTrianglesSize(int scale) const;
   //@}
 
+  void SwapGeometry(FeatureType & r);
+
 private:
   void ParseAll(int scale) const;
 
diff --git a/routing/features_road_graph.cpp b/routing/features_road_graph.cpp
index a449f77930..06094333f9 100644
--- a/routing/features_road_graph.cpp
+++ b/routing/features_road_graph.cpp
@@ -1,4 +1,5 @@
 #include "features_road_graph.hpp"
+#include "route.hpp"
 
 #include "../indexer/index.hpp"
 #include "../indexer/classificator.hpp"
@@ -99,14 +100,18 @@ double CalcDistanceMeters(m2::PointD const & p1, m2::PointD const & p2)
                              MercatorBounds::YToLat(p2.y), MercatorBounds::XToLon(p2.x));
 }
 
-void FeatureRoadGraph::GetPossibleTurns(RoadPos const & pos, vector<PossibleTurn> & turns)
+void FeatureRoadGraph::LoadFeature(uint32_t id, FeatureType & ft)
 {
   Index::FeaturesLoaderGuard loader(*m_pIndex, m_mwmID);
+  loader.GetFeature(id, ft);
+  ft.ParseGeometry(FeatureType::BEST_GEOMETRY);
+}
 
+void FeatureRoadGraph::GetPossibleTurns(RoadPos const & pos, vector<PossibleTurn> & turns)
+{
   uint32_t const ftId = pos.GetFeatureId();
   FeatureType ft;
-  loader.GetFeature(ftId, ft);
-  ft.ParseGeometry(FeatureType::BEST_GEOMETRY);
+  LoadFeature(ftId, ft);
 
   int const count = static_cast<int>(ft.GetPointsCount());
   bool const isForward = pos.IsForward();
@@ -126,11 +131,11 @@ void FeatureRoadGraph::GetPossibleTurns(RoadPos const & pos, vector<PossibleTurn
   double time = 0.0;
   for (int i = startID; i >= 0 && i < count; i += inc)
   {
-    if (i != startID)
-    {
-      distance += CalcDistanceMeters(ft.GetPoint(i), ft.GetPoint(i - inc));
-      time += distance / DEFAULT_SPEED_MS;
-    }
+    ASSERT_GREATER(i - inc, -1, ());
+    ASSERT_LESS(i - inc, count, ());
+
+    distance += CalcDistanceMeters(ft.GetPoint(i), ft.GetPoint(i - inc));
+    time += distance / DEFAULT_SPEED_MS;
 
     m2::PointD const & pt = ft.GetPoint(i);
 
@@ -201,15 +206,75 @@ void FeatureRoadGraph::GetPossibleTurns(RoadPos const & pos, vector<PossibleTurn
   }
 }
 
-double FeatureRoadGraph::GetFeatureDistance(RoadPos const & p1, RoadPos const & p2)
+void FeatureRoadGraph::ReconstructPath(RoadPosVectorT const & positions, Route & route)
 {
-  /// @todo Implement distance calculation
-  return 0.0;
-}
+  size_t count = positions.size();
+  if (count < 2)
+    return;
 
-void FeatureRoadGraph::ReconstructPath(RoadPosVectorT const & positions, PointsVectorT & poly)
-{
-  /// @todo Implement path reconstruction
+  FeatureType ft1;
+  vector<m2::PointD> poly;
+
+  // Initialize starting point.
+  RoadPos pos1 = positions[0];
+  LoadFeature(pos1.GetFeatureId(), ft1);
+
+  size_t i = 0;
+  while (i < count-1)
+  {
+    RoadPos const & pos2 = positions[i+1];
+
+    FeatureType ft2;
+
+    // Find next connection point
+    m2::PointD lastPt;
+    bool const diffIDs = pos1.GetFeatureId() != pos2.GetFeatureId();
+    if (diffIDs)
+    {
+      LoadFeature(pos2.GetFeatureId(), ft2);
+      lastPt = ft2.GetPoint(pos2.GetPointId() + (pos2.IsForward() ? 0 : 1));
+    }
+    else
+      lastPt = ft1.GetPoint(pos2.GetPointId() + (pos1.IsForward() ? 0 : 1));
+
+    // Accumulate points from start point id to pt.
+    int const inc = pos1.IsForward() ? 1 : -1;
+    int ptID = pos1.GetPointId() + (pos1.IsForward() ? 1 : 0);
+    m2::PointD pt;
+    bool notEnd, notEqualPoints;
+    do
+    {
+      pt = ft1.GetPoint(ptID);
+      poly.push_back(pt);
+
+      LOG(LDEBUG, (pt, pos1.GetFeatureId(), ptID));
+
+      ptID += inc;
+
+      notEqualPoints = !m2::AlmostEqual(pt, lastPt);
+      notEnd = (ptID >= 0 && ptID < ft1.GetPointsCount());
+    } while (notEnd && notEqualPoints);
+
+    // If we reached the end of feature, start with the begining
+    // (end - for backward direction) of the next feauture, until reach pos2.
+    if (!notEnd && notEqualPoints)
+    {
+      pos1 = RoadPos(pos2.GetFeatureId(), pos2.IsForward(),
+                     pos2.IsForward() ? 0 : ft2.GetPointsCount() - 2);
+
+    }
+    else
+    {
+      pos1 = pos2;
+      ++i;
+    }
+
+    // Assign current processing feature.
+    if (diffIDs)
+      ft1.SwapGeometry(ft2);
+  }
+
+  route = Route("", poly, "");
 }
 
 bool FeatureRoadGraph::IsStreet(feature::TypesHolder const & types) const
diff --git a/routing/features_road_graph.hpp b/routing/features_road_graph.hpp
index ba6dd749ab..9d2c1c4123 100644
--- a/routing/features_road_graph.hpp
+++ b/routing/features_road_graph.hpp
@@ -2,8 +2,8 @@
 
 #include "road_graph.hpp"
 
-
 class Index;
+class FeatureType;
 
 namespace feature
 {
@@ -19,8 +19,7 @@ public:
   FeatureRoadGraph(Index * pIndex, size_t mwmID);
 
   virtual void GetPossibleTurns(RoadPos const & pos, vector<PossibleTurn> & turns);
-  virtual double GetFeatureDistance(RoadPos const & p1, RoadPos const & p2);
-  virtual void ReconstructPath(RoadPosVectorT const & positions, PointsVectorT & poly);
+  virtual void ReconstructPath(RoadPosVectorT const & positions, Route & route);
 
   static uint32_t GetStreetReadScale();
 
@@ -30,6 +29,8 @@ private:
   bool IsStreet(feature::TypesHolder const & types) const;
   bool IsOneway(feature::TypesHolder const & types) const;
 
+  void LoadFeature(uint32_t id, FeatureType & ft);
+
 private:
   uint32_t m_onewayType;
 
diff --git a/routing/road_graph.hpp b/routing/road_graph.hpp
index 41738a3524..3bbfb177c6 100644
--- a/routing/road_graph.hpp
+++ b/routing/road_graph.hpp
@@ -10,6 +10,8 @@
 namespace routing
 {
 
+class Route;
+
 /// Defines position on a feature with direction.
 class RoadPos
 {
@@ -69,12 +71,12 @@ public:
   typedef vector<RoadPos> RoadPosVectorT;
   typedef vector<m2::PointD> PointsVectorT;
 
-  /// Find all line feature sections, that follow the to pos section.
+  virtual ~IRoadGraph() {}
+
+  /// Find all feature sections (turns), that route to the "pos" section.
   virtual void GetPossibleTurns(RoadPos const & pos, TurnsVectorT & turns) = 0;
-  /// Calculate distance in meters between two RoadPos that placed on the same feature
-  virtual double GetFeatureDistance(RoadPos const & p1, RoadPos const & p2) = 0;
-  /// Construct full path by road positions
-  virtual void ReconstructPath(RoadPosVectorT const & positions, PointsVectorT & poly) = 0;
+  /// Construct route by road positions (doesn't include first and last section).
+  virtual void ReconstructPath(RoadPosVectorT const & positions, Route & route) = 0;
 };
 
 } // namespace routing
diff --git a/routing/route.cpp b/routing/route.cpp
index 02b900def1..e4b7a17f24 100644
--- a/routing/route.cpp
+++ b/routing/route.cpp
@@ -8,4 +8,9 @@ Route::Route(string const & router, vector<m2::PointD> const & points, string co
 {
 }
 
+string DebugPrint(Route const & r)
+{
+  return DebugPrint(r.m_poly);
+}
+
 } // namespace routing
diff --git a/routing/route.hpp b/routing/route.hpp
index 5f3bb0bd54..eb9d9848c6 100644
--- a/routing/route.hpp
+++ b/routing/route.hpp
@@ -12,15 +12,18 @@ namespace routing
 class Route
 {
 public:
+  Route() {}
   Route(string const & router, vector<m2::PointD> const & points, string const & name = "");
 
   string const & GetRouterId() const { return m_router; }
   m2::PolylineD const & GetPoly() const { return m_poly; }
   string const & GetName() const { return m_name; }
 
-  bool IsValid() const { return m_poly.GetSize(); }
+  bool IsValid() const { return m_poly.GetSize() > 0; }
 
 private:
+  friend string DebugPrint(Route const & r);
+
   /// The source which created the route
   string m_router;
   m2::PolylineD m_poly;
diff --git a/routing/routing_tests/road_graph_builder.cpp b/routing/routing_tests/road_graph_builder.cpp
index 4a1032ce80..8d1f2c2514 100644
--- a/routing/routing_tests/road_graph_builder.cpp
+++ b/routing/routing_tests/road_graph_builder.cpp
@@ -94,14 +94,8 @@ void RoadGraphMockSource::GetPossibleTurns(RoadPos const & pos, TurnsVectorT & t
   }
 }
 
-double RoadGraphMockSource::GetFeatureDistance(RoadPos const & p1, RoadPos const & p2)
+void RoadGraphMockSource::ReconstructPath(RoadPosVectorT const &, routing::Route &)
 {
-  return 0.0;
-}
-
-void RoadGraphMockSource::ReconstructPath(RoadPosVectorT const & positions, PointsVectorT & poly)
-{
-
 }
 
 void InitRoadGraphMockSourceWithTest1(RoadGraphMockSource & src)
diff --git a/routing/routing_tests/road_graph_builder.hpp b/routing/routing_tests/road_graph_builder.hpp
index d78aa09001..e34bd5fd63 100644
--- a/routing/routing_tests/road_graph_builder.hpp
+++ b/routing/routing_tests/road_graph_builder.hpp
@@ -47,8 +47,7 @@ public:
   void AddRoad(RoadInfo & rd);
 
   virtual void GetPossibleTurns(routing::RoadPos const & pos, TurnsVectorT & turns);
-  virtual double GetFeatureDistance(routing::RoadPos const & p1, routing::RoadPos const & p2);
-  virtual void ReconstructPath(RoadPosVectorT const & positions, PointsVectorT & poly);
+  virtual void ReconstructPath(RoadPosVectorT const & positions, routing::Route & route);
 };
 
 void InitRoadGraphMockSourceWithTest1(RoadGraphMockSource & graphMock);