Merge pull request #5468 from dobriy-eeh/cross-mwm-routingbeta-657

[routing] Enable cross mwm index router

20 files changed, 175 insertions, 98 deletions

diff --git a/data/minsk-pass.mwm b/data/minsk-pass.mwm
index 95cda6768b..4fd4c0e547 100644
--- a/data/minsk-pass.mwm
+++ b/data/minsk-pass.mwm
diff --git a/generator/centers_table_builder.cpp b/generator/centers_table_builder.cpp
index b58608b1aa..3a44717e17 100644
--- a/generator/centers_table_builder.cpp
+++ b/generator/centers_table_builder.cpp
@@ -28,9 +28,14 @@ bool BuildCentersTableFromDataFile(string const & filename, bool forceRebuild)
       if (!forceRebuild && rcont.IsExist(CENTERS_FILE_TAG))
         return true;
 
-      feature::DataHeader header(rcont);
+      version::MwmVersion version;
+      if (!ReadVersion(rcont, version))
+      {
+        LOG(LERROR, ("Can't read version from", filename));
+        return false;
+      }
 
-      version::MwmTraits const traits(header.GetFormat());
+      version::MwmTraits const traits(version);
       if (!traits.HasOffsetsTable())
       {
         LOG(LERROR, (filename, "does not have an offsets table!"));
@@ -44,6 +49,7 @@ bool BuildCentersTableFromDataFile(string const & filename, bool forceRebuild)
         return false;
       }
 
+      feature::DataHeader const header(rcont);
       FeaturesVector const features(rcont, header, table.get());
 
       builder.SetCodingParams(header.GetDefCodingParams());
diff --git a/map/framework.cpp b/map/framework.cpp
index b639fdd88a..b1a1533150 100644
--- a/map/framework.cpp
+++ b/map/framework.cpp
@@ -10,13 +10,13 @@
 #include "private.h"
 
 #include "routing/car_router.hpp"
+#include "routing/index_router.hpp"
 #include "routing/num_mwm_id.hpp"
 #include "routing/online_absent_fetcher.hpp"
 #include "routing/road_graph_router.hpp"
 #include "routing/route.hpp"
 #include "routing/routing_algorithm.hpp"
 #include "routing/routing_helpers.hpp"
-#include "routing/single_mwm_router.hpp"
 
 #include "search/downloader_search_callback.hpp"
 #include "search/editor_delegate.hpp"
@@ -2498,7 +2498,7 @@ void Framework::SetRouterImpl(RouterType type)
 
     router.reset(
         new CarRouter(m_model.GetIndex(), countryFileGetter,
-                      SingleMwmRouter::CreateCarRouter(countryFileGetter, numMwmIds, m_routingSession, m_model.GetIndex())));
+                      IndexRouter::CreateCarRouter(countryFileGetter, numMwmIds, m_routingSession, m_model.GetIndex())));
     fetcher.reset(new OnlineAbsentCountriesFetcher(countryFileGetter, localFileChecker));
     m_routingSession.SetRoutingSettings(routing::GetCarRoutingSettings());
   }
diff --git a/map/map_tests/feature_getters_tests.cpp b/map/map_tests/feature_getters_tests.cpp
index 58b84a165d..bf58d74bae 100644
--- a/map/map_tests/feature_getters_tests.cpp
+++ b/map/map_tests/feature_getters_tests.cpp
@@ -21,6 +21,7 @@ UNIT_TEST(Framework_ForEachFeatureAtPoint_And_Others)
   {
     "highway|footway|",
     "hwtag|yesfoot|",
+    "hwtag|yesbicycle|",
     "highway|service|parking_aisle|",
     "amenity|parking|",
     "barrier|lift_gate|"
diff --git a/platform/mwm_traits.cpp b/platform/mwm_traits.cpp
index 2da0c25746..f066ffa03a 100644
--- a/platform/mwm_traits.cpp
+++ b/platform/mwm_traits.cpp
@@ -4,23 +4,29 @@
 
 namespace version
 {
-MwmTraits::MwmTraits(version::Format versionFormat) : m_versionFormat(versionFormat) {}
+MwmTraits::MwmTraits(MwmVersion const & version) : m_version(version) {}
 
 MwmTraits::SearchIndexFormat MwmTraits::GetSearchIndexFormat() const
 {
-  if (m_versionFormat < version::Format::v7)
+  if (m_version.GetFormat() < version::Format::v7)
     return SearchIndexFormat::FeaturesWithRankAndCenter;
   return SearchIndexFormat::CompressedBitVector;
 }
 
 MwmTraits::HouseToStreetTableFormat MwmTraits::GetHouseToStreetTableFormat() const
 {
-  if (m_versionFormat < version::Format::v7)
+  if (m_version.GetFormat() < version::Format::v7)
     return HouseToStreetTableFormat::Unknown;
   return HouseToStreetTableFormat::Fixed3BitsDDVector;
 }
 
-bool MwmTraits::HasOffsetsTable() const { return m_versionFormat >= version::Format::v6; }
+bool MwmTraits::HasOffsetsTable() const { return m_version.GetFormat() >= version::Format::v6; }
+
+bool MwmTraits::HasRoutingIndex() const
+{
+  uint32_t constexpr kFirstVersionWithRoutingIndex = 161206;
+  return m_version.GetVersion() >= kFirstVersionWithRoutingIndex;
+}
 
 string DebugPrint(MwmTraits::SearchIndexFormat format)
 {
diff --git a/platform/mwm_traits.hpp b/platform/mwm_traits.hpp
index 2c0a1c9c08..3b74ebdb78 100644
--- a/platform/mwm_traits.hpp
+++ b/platform/mwm_traits.hpp
@@ -38,7 +38,7 @@ public:
     Unknown
   };
 
-  MwmTraits(version::Format versionFormat);
+  MwmTraits(MwmVersion const & version);
 
   SearchIndexFormat GetSearchIndexFormat() const;
 
@@ -46,8 +46,12 @@ public:
 
   bool HasOffsetsTable() const;
 
+  // The new routing section with IndexGraph was added in december 2016.
+  // Check whether mwm has routing index section.
+  bool HasRoutingIndex() const;
+
 private:
-  version::Format m_versionFormat;
+  MwmVersion m_version;
 };
 
 string DebugPrint(MwmTraits::SearchIndexFormat format);
diff --git a/routing/CMakeLists.txt b/routing/CMakeLists.txt
index d0feaee435..76d127bd05 100644
--- a/routing/CMakeLists.txt
+++ b/routing/CMakeLists.txt
@@ -48,6 +48,8 @@ set(
   index_graph_starter.hpp
   index_road_graph.cpp
   index_road_graph.hpp
+  index_router.cpp
+  index_router.hpp
   joint.cpp
   joint.hpp
   joint_index.cpp
@@ -103,8 +105,6 @@ set(
   routing_session.hpp
   routing_settings.hpp
   segment.hpp
-  single_mwm_router.cpp
-  single_mwm_router.hpp
   speed_camera.cpp
   speed_camera.hpp
   traffic_stash.hpp
diff --git a/routing/car_router.cpp b/routing/car_router.cpp
index fc29851422..4b92293e28 100644
--- a/routing/car_router.cpp
+++ b/routing/car_router.cpp
@@ -13,6 +13,7 @@
 #include "traffic/traffic_info.hpp"
 
 #include "platform/country_file.hpp"
+#include "platform/mwm_traits.hpp"
 #include "platform/platform.hpp"
 
 #include "geometry/angles.hpp"
@@ -250,7 +251,7 @@ bool CarRouter::CheckRoutingAbility(m2::PointD const & startPoint, m2::PointD co
 }
 
 CarRouter::CarRouter(Index & index, TCountryFileFn const & countryFileFn,
-                     unique_ptr<SingleMwmRouter> localRouter)
+                     unique_ptr<IndexRouter> localRouter)
   : m_index(index), m_indexManager(countryFileFn, index), m_router(move(localRouter))
 {
 }
@@ -400,6 +401,10 @@ CarRouter::ResultCode CarRouter::CalculateRoute(m2::PointD const & startPoint,
                                                 m2::PointD const & finalPoint,
                                                 RouterDelegate const & delegate, Route & route)
 {
+// TODO uncomment this to activate cross mwm index router.
+//  if (AllMwmsHaveRoutingIndex())
+//    return m_router->CalculateRoute(startPoint, startDirection, finalPoint, delegate, route);
+
   my::HighResTimer timer(true);
 
   TRoutingMappingPtr startMapping = m_indexManager.GetMappingByPoint(startPoint);
@@ -578,6 +583,22 @@ bool CarRouter::DoesEdgeIndexExist(Index::MwmId const & mwmId)
   return true;
 }
 
+bool CarRouter::AllMwmsHaveRoutingIndex() const
+{
+  vector<shared_ptr<MwmInfo>> infos;
+  m_index.GetMwmsInfo(infos);
+  for (auto const & info : infos)
+  {
+    if (info->GetType() != MwmInfo::COUNTRY)
+      continue;
+
+    if (!version::MwmTraits(info->m_version).HasRoutingIndex())
+      return false;
+  }
+
+  return true;
+}
+
 IRouter::ResultCode CarRouter::FindSingleRouteDispatcher(FeatureGraphNode const & source,
                                                          FeatureGraphNode const & target,
                                                          RouterDelegate const & delegate,
@@ -599,10 +620,9 @@ IRouter::ResultCode CarRouter::FindSingleRouteDispatcher(FeatureGraphNode const
     }
     LOG(LINFO, (m_router->GetName(), "route from", MercatorBounds::ToLatLon(source.segmentPoint),
                 "to", MercatorBounds::ToLatLon(target.segmentPoint)));
-    m_router->SetCountry(source.mwmId.GetInfo()->GetCountryName());
-    result = m_router->CalculateRoute(source.segmentPoint,
-                                      m2::PointD(0, 0) /* direction */, target.segmentPoint,
-                                      delegate, mwmRoute);
+    result = m_router->CalculateRouteForSingleMwm(
+        source.mwmId.GetInfo()->GetCountryName(), source.segmentPoint,
+        m2::PointD(0, 0) /* direction */, target.segmentPoint, delegate, mwmRoute);
   }
   else
   {
diff --git a/routing/car_router.hpp b/routing/car_router.hpp
index 4a62046391..d32fc9252a 100644
--- a/routing/car_router.hpp
+++ b/routing/car_router.hpp
@@ -1,11 +1,11 @@
 #pragma once
 
+#include "routing/index_router.hpp"
 #include "routing/osrm_data_facade.hpp"
 #include "routing/osrm_engine.hpp"
 #include "routing/route.hpp"
 #include "routing/router.hpp"
 #include "routing/routing_mapping.hpp"
-#include "routing/single_mwm_router.hpp"
 
 #include "std/unique_ptr.hpp"
 #include "std/vector.hpp"
@@ -35,7 +35,7 @@ public:
   typedef vector<double> GeomTurnCandidateT;
 
   CarRouter(Index & index, TCountryFileFn const & countryFileFn,
-            unique_ptr<SingleMwmRouter> localRouter);
+            unique_ptr<IndexRouter> localRouter);
 
   virtual string GetName() const override;
 
@@ -85,6 +85,7 @@ private:
   // @TODO(bykoianko) When routing section implementation is merged to master
   // this method should be moved to routing loader.
   bool DoesEdgeIndexExist(Index::MwmId const & mwmId);
+  bool AllMwmsHaveRoutingIndex() const;
 
   /*!
    * \brief Builds a route within one mwm using A* if edge index section is available and osrm
@@ -115,6 +116,6 @@ private:
 
   RoutingIndexManager m_indexManager;
 
-  unique_ptr<SingleMwmRouter> m_router;
+  unique_ptr<IndexRouter> m_router;
 };
 }  // namespace routing
diff --git a/routing/index_graph_starter.cpp b/routing/index_graph_starter.cpp
index 8fa511e2dd..064d96bb5b 100644
--- a/routing/index_graph_starter.cpp
+++ b/routing/index_graph_starter.cpp
@@ -22,8 +22,7 @@ m2::PointD const & IndexGraphStarter::GetPoint(Segment const & segment, bool fro
   if (segment == kFinishFakeSegment || (front && m_finish.Fits(segment)))
     return m_finish.GetPoint();
 
-  return m_graph.GetRoadGeometry(segment.GetMwmId(), segment.GetFeatureId())
-      .GetPoint(segment.GetPointId(front));
+  return m_graph.GetPoint(segment, front);
 }
 
 // static
diff --git a/routing/single_mwm_router.cpp b/routing/index_router.cpp
index afcab0dd2e..cc202f7b53 100644
--- a/routing/single_mwm_router.cpp
+++ b/routing/index_router.cpp
@@ -1,4 +1,4 @@
-#include "routing/single_mwm_router.hpp"
+#include "routing/index_router.hpp"
 
 #include "routing/base/astar_algorithm.hpp"
 #include "routing/base/astar_progress.hpp"
@@ -38,12 +38,11 @@ uint32_t constexpr kDrawPointsPeriod = 10;
 
 namespace routing
 {
-SingleMwmRouter::SingleMwmRouter(string const & name, TCountryFileFn const & countryFileFn,
-                                 shared_ptr<NumMwmIds> numMwmIds,
-                                 shared_ptr<TrafficStash> trafficStash,
-                                 shared_ptr<VehicleModelFactory> vehicleModelFactory,
-                                 shared_ptr<EdgeEstimator> estimator,
-                                 unique_ptr<IDirectionsEngine> directionsEngine, Index & index)
+IndexRouter::IndexRouter(string const & name, TCountryFileFn const & countryFileFn,
+                         shared_ptr<NumMwmIds> numMwmIds, shared_ptr<TrafficStash> trafficStash,
+                         shared_ptr<VehicleModelFactory> vehicleModelFactory,
+                         shared_ptr<EdgeEstimator> estimator,
+                         unique_ptr<IDirectionsEngine> directionsEngine, Index & index)
   : m_name(name)
   , m_index(index)
   , m_countryFileFn(countryFileFn)
@@ -63,14 +62,36 @@ SingleMwmRouter::SingleMwmRouter(string const & name, TCountryFileFn const & cou
   CHECK(m_directionsEngine, ());
 }
 
-IRouter::ResultCode SingleMwmRouter::CalculateRoute(m2::PointD const & startPoint,
-                                                    m2::PointD const & startDirection,
-                                                    m2::PointD const & finalPoint,
-                                                    RouterDelegate const & delegate, Route & route)
+IRouter::ResultCode IndexRouter::CalculateRoute(m2::PointD const & startPoint,
+                                                m2::PointD const & startDirection,
+                                                m2::PointD const & finalPoint,
+                                                RouterDelegate const & delegate, Route & route)
+{
+  string const startCountry = m_countryFileFn(startPoint);
+  string const finishCountry = m_countryFileFn(finalPoint);
+  return CalculateRoute(startCountry, finishCountry, false /* blockMwmBorders */, startPoint,
+                        startDirection, finalPoint, delegate, route);
+}
+
+IRouter::ResultCode IndexRouter::CalculateRouteForSingleMwm(
+    string const & country, m2::PointD const & startPoint, m2::PointD const & startDirection,
+    m2::PointD const & finalPoint, RouterDelegate const & delegate, Route & route)
+{
+  return CalculateRoute(country, country, true /* blockMwmBorders */, startPoint, startDirection,
+                        finalPoint, delegate, route);
+}
+
+IRouter::ResultCode IndexRouter::CalculateRoute(string const & startCountry,
+                                                string const & finishCountry, bool blockMwmBorders,
+                                                m2::PointD const & startPoint,
+                                                m2::PointD const & startDirection,
+                                                m2::PointD const & finalPoint,
+                                                RouterDelegate const & delegate, Route & route)
 {
   try
   {
-    return DoCalculateRoute(startPoint, startDirection, finalPoint, delegate, route);
+    return DoCalculateRoute(startCountry, finishCountry, blockMwmBorders, startPoint,
+                            startDirection, finalPoint, delegate, route);
   }
   catch (RootException const & e)
   {
@@ -80,29 +101,26 @@ IRouter::ResultCode SingleMwmRouter::CalculateRoute(m2::PointD const & startPoin
   }
 }
 
-IRouter::ResultCode SingleMwmRouter::DoCalculateRoute(m2::PointD const & startPoint,
-                                                      m2::PointD const & /* startDirection */,
-                                                      m2::PointD const & finalPoint,
-                                                      RouterDelegate const & delegate,
-                                                      Route & route)
+IRouter::ResultCode IndexRouter::DoCalculateRoute(
+    string const & startCountry, string const & finishCountry, bool blockMwmBorders,
+    m2::PointD const & startPoint, m2::PointD const & /* startDirection */,
+    m2::PointD const & finalPoint, RouterDelegate const & delegate, Route & route)
 {
-  // TODO: remove field m_country.
-  // Use m_countryFileFn(startPoint), m_countryFileFn(finalPoint) here.
-  auto const startCountry = platform::CountryFile(m_country);
-  auto const finishCountry = platform::CountryFile(m_country);
+  auto const startFile = platform::CountryFile(startCountry);
+  auto const finishFile = platform::CountryFile(finishCountry);
 
   Edge startEdge;
-  if (!FindClosestEdge(startCountry, startPoint, startEdge))
+  if (!FindClosestEdge(startFile, startPoint, startEdge))
     return IRouter::StartPointNotFound;
 
   Edge finishEdge;
-  if (!FindClosestEdge(finishCountry, finalPoint, finishEdge))
+  if (!FindClosestEdge(finishFile, finalPoint, finishEdge))
     return IRouter::EndPointNotFound;
 
-  IndexGraphStarter::FakeVertex const start(m_numMwmIds->GetId(startCountry),
+  IndexGraphStarter::FakeVertex const start(m_numMwmIds->GetId(startFile),
                                             startEdge.GetFeatureId().m_index, startEdge.GetSegId(),
                                             startPoint);
-  IndexGraphStarter::FakeVertex const finish(m_numMwmIds->GetId(finishCountry),
+  IndexGraphStarter::FakeVertex const finish(m_numMwmIds->GetId(finishFile),
                                              finishEdge.GetFeatureId().m_index,
                                              finishEdge.GetSegId(), finalPoint);
 
@@ -112,8 +130,8 @@ IRouter::ResultCode SingleMwmRouter::DoCalculateRoute(m2::PointD const & startPo
       IndexGraphLoader::Create(m_numMwmIds, m_vehicleModelFactory, m_estimator, m_index),
       m_estimator);
 
-  // TODO remove to activate CrossMwmGraph.
-  graph.BlockMwmBorders();
+  if (blockMwmBorders)
+    graph.CloseBorders();
 
   IndexGraphStarter starter(start, finish, graph);
 
@@ -160,8 +178,8 @@ IRouter::ResultCode SingleMwmRouter::DoCalculateRoute(m2::PointD const & startPo
   }
 }
 
-bool SingleMwmRouter::FindClosestEdge(platform::CountryFile const & file, m2::PointD const & point,
-                                      Edge & closestEdge) const
+bool IndexRouter::FindClosestEdge(platform::CountryFile const & file, m2::PointD const & point,
+                                  Edge & closestEdge) const
 {
   MwmSet::MwmHandle handle = m_index.GetMwmHandleByCountryFile(file);
   if (!handle.IsAlive())
@@ -198,15 +216,14 @@ bool SingleMwmRouter::FindClosestEdge(platform::CountryFile const & file, m2::Po
   return true;
 }
 
-IRouter::ResultCode SingleMwmRouter::ProcessLeaps(vector<Segment> const & input,
-                                                  RouterDelegate const & delegate,
-                                                  IndexGraphStarter & starter,
-                                                  vector<Segment> & output)
+IRouter::ResultCode IndexRouter::ProcessLeaps(vector<Segment> const & input,
+                                              RouterDelegate const & delegate,
+                                              IndexGraphStarter & starter, vector<Segment> & output)
 {
   output.reserve(input.size());
 
   WorldGraph & worldGraph = starter.GetGraph();
-  worldGraph.BlockMwmBorders();
+  worldGraph.CloseBorders();
 
   for (size_t i = 0; i < input.size(); ++i)
   {
@@ -252,9 +269,8 @@ IRouter::ResultCode SingleMwmRouter::ProcessLeaps(vector<Segment> const & input,
   return IRouter::NoError;
 }
 
-bool SingleMwmRouter::RedressRoute(vector<Segment> const & segments,
-                                   RouterDelegate const & delegate, IndexGraphStarter & starter,
-                                   Route & route) const
+bool IndexRouter::RedressRoute(vector<Segment> const & segments, RouterDelegate const & delegate,
+                               IndexGraphStarter & starter, Route & route) const
 {
   vector<Junction> junctions;
   size_t const numPoints = IndexGraphStarter::GetRouteNumPoints(segments);
@@ -267,6 +283,7 @@ bool SingleMwmRouter::RedressRoute(vector<Segment> const & segments,
   }
 
   IndexRoadGraph roadGraph(m_numMwmIds, starter, segments, junctions, m_index);
+  starter.GetGraph().OpenBorders();
 
   CHECK(m_directionsEngine, ());
   ReconstructRoute(*m_directionsEngine, roadGraph, m_trafficStash, delegate, junctions, route);
@@ -293,9 +310,10 @@ bool SingleMwmRouter::RedressRoute(vector<Segment> const & segments,
 }
 
 // static
-unique_ptr<SingleMwmRouter> SingleMwmRouter::CreateCarRouter(
-    TCountryFileFn const & countryFileFn, shared_ptr<NumMwmIds> numMwmIds,
-    traffic::TrafficCache const & trafficCache, Index & index)
+unique_ptr<IndexRouter> IndexRouter::CreateCarRouter(TCountryFileFn const & countryFileFn,
+                                                     shared_ptr<NumMwmIds> numMwmIds,
+                                                     traffic::TrafficCache const & trafficCache,
+                                                     Index & index)
 {
   CHECK(numMwmIds, ());
   auto vehicleModelFactory = make_shared<CarModelFactory>();
@@ -314,9 +332,9 @@ unique_ptr<SingleMwmRouter> SingleMwmRouter::CreateCarRouter(
   auto trafficStash = make_shared<TrafficStash>(trafficCache, numMwmIds);
 
   auto estimator = EdgeEstimator::CreateForCar(trafficStash, maxSpeed);
-  auto router = make_unique<SingleMwmRouter>("astar-bidirectional-car", countryFileFn, numMwmIds,
-                                             trafficStash, vehicleModelFactory, estimator,
-                                             move(directionsEngine), index);
+  auto router =
+      make_unique<IndexRouter>("astar-bidirectional-car", countryFileFn, numMwmIds, trafficStash,
+                               vehicleModelFactory, estimator, move(directionsEngine), index);
   return router;
 }
 }  // namespace routing
diff --git a/routing/single_mwm_router.hpp b/routing/index_router.hpp
index e815d4e0bc..63dc2c193a 100644
--- a/routing/single_mwm_router.hpp
+++ b/routing/index_router.hpp
@@ -22,14 +22,14 @@ namespace routing
 class IndexGraph;
 class IndexGraphStarter;
 
-class SingleMwmRouter : public IRouter
+class IndexRouter : public IRouter
 {
 public:
-  SingleMwmRouter(string const & name, TCountryFileFn const & countryFileFn,
-                  shared_ptr<NumMwmIds> numMwmIds, shared_ptr<TrafficStash> trafficStash,
-                  shared_ptr<VehicleModelFactory> vehicleModelFactory,
-                  shared_ptr<EdgeEstimator> estimator,
-                  unique_ptr<IDirectionsEngine> directionsEngine, Index & index);
+  IndexRouter(string const & name, TCountryFileFn const & countryFileFn,
+              shared_ptr<NumMwmIds> numMwmIds, shared_ptr<TrafficStash> trafficStash,
+              shared_ptr<VehicleModelFactory> vehicleModelFactory,
+              shared_ptr<EdgeEstimator> estimator, unique_ptr<IDirectionsEngine> directionsEngine,
+              Index & index);
 
   // IRouter overrides:
   virtual string GetName() const override { return m_name; }
@@ -39,16 +39,26 @@ public:
                                              RouterDelegate const & delegate,
                                              Route & route) override;
 
-  void SetCountry(string const & country) { m_country = country; }
+  IRouter::ResultCode CalculateRouteForSingleMwm(string const & country,
+                                                 m2::PointD const & startPoint,
+                                                 m2::PointD const & startDirection,
+                                                 m2::PointD const & finalPoint,
+                                                 RouterDelegate const & delegate, Route & route);
 
   /// \note |numMwmIds| should not be null.
-  static unique_ptr<SingleMwmRouter> CreateCarRouter(TCountryFileFn const & countryFileFn,
-                                                     shared_ptr<NumMwmIds> numMwmIds,
-                                                     traffic::TrafficCache const & trafficCache,
-                                                     Index & index);
+  static unique_ptr<IndexRouter> CreateCarRouter(TCountryFileFn const & countryFileFn,
+                                                 shared_ptr<NumMwmIds> numMwmIds,
+                                                 traffic::TrafficCache const & trafficCache,
+                                                 Index & index);
 
 private:
-  IRouter::ResultCode DoCalculateRoute(m2::PointD const & startPoint,
+  IRouter::ResultCode CalculateRoute(string const & startCountry, string const & finishCountry,
+                                     bool blockMwmBorders, m2::PointD const & startPoint,
+                                     m2::PointD const & startDirection,
+                                     m2::PointD const & finalPoint, RouterDelegate const & delegate,
+                                     Route & route);
+  IRouter::ResultCode DoCalculateRoute(string const & startCountry, string const & finishCountry,
+                                       bool blockMwmBorders, m2::PointD const & startPoint,
                                        m2::PointD const & startDirection,
                                        m2::PointD const & finalPoint,
                                        RouterDelegate const & delegate, Route & route);
@@ -62,7 +72,6 @@ private:
                     IndexGraphStarter & starter, Route & route) const;
 
   string const m_name;
-  string m_country;
   Index & m_index;
   TCountryFileFn const m_countryFileFn;
   shared_ptr<NumMwmIds> m_numMwmIds;
diff --git a/routing/road_graph_router.cpp b/routing/road_graph_router.cpp
index a93d33177a..95b7fa4a64 100644
--- a/routing/road_graph_router.cpp
+++ b/routing/road_graph_router.cpp
@@ -9,7 +9,6 @@
 #include "routing/pedestrian_model.hpp"
 #include "routing/route.hpp"
 #include "routing/routing_helpers.hpp"
-#include "routing/single_mwm_router.hpp"
 
 #include "coding/reader_wrapper.hpp"
 
diff --git a/routing/routing.pro b/routing/routing.pro
index 46a7f5a1cb..ce480092d2 100644
--- a/routing/routing.pro
+++ b/routing/routing.pro
@@ -32,6 +32,7 @@ SOURCES += \
     index_graph_serialization.cpp \
     index_graph_starter.cpp \
     index_road_graph.cpp \
+    index_router.cpp \
     joint.cpp \
     joint_index.cpp \
     nearest_edge_finder.cpp \
@@ -55,7 +56,6 @@ SOURCES += \
     routing_helpers.cpp \
     routing_mapping.cpp \
     routing_session.cpp \
-    single_mwm_router.cpp \
     speed_camera.cpp \
     turns.cpp \
     turns_generator.cpp \
@@ -87,6 +87,7 @@ HEADERS += \
     index_graph_serialization.hpp \
     index_graph_starter.hpp \
     index_road_graph.hpp \
+    index_router.hpp \
     joint.hpp \
     joint_index.hpp \
     loaded_path_segment.hpp \
@@ -119,7 +120,6 @@ HEADERS += \
     routing_session.hpp \
     routing_settings.hpp \
     segment.hpp \
-    single_mwm_router.hpp \
     speed_camera.hpp \
     traffic_stash.hpp \
     turn_candidate.hpp \
diff --git a/routing/routing_integration_tests/routing_test_tools.cpp b/routing/routing_integration_tests/routing_test_tools.cpp
index 52c8495604..45c7ec0fa6 100644
--- a/routing/routing_integration_tests/routing_test_tools.cpp
+++ b/routing/routing_integration_tests/routing_test_tools.cpp
@@ -9,12 +9,12 @@
 #include "geometry/distance_on_sphere.hpp"
 #include "geometry/latlon.hpp"
 
+#include "routing/index_router.hpp"
 #include "routing/online_absent_fetcher.hpp"
 #include "routing/online_cross_fetcher.hpp"
 #include "routing/road_graph_router.hpp"
 #include "routing/route.hpp"
 #include "routing/router_delegate.hpp"
-#include "routing/single_mwm_router.hpp"
 
 #include "indexer/index.hpp"
 
@@ -91,7 +91,7 @@ namespace integration
       numMwmIds->RegisterFile(f.GetCountryFile());
 
     auto carRouter = make_unique<CarRouter>(index, countryFileGetter,
-                                            SingleMwmRouter::CreateCarRouter(countryFileGetter, numMwmIds,
+                                            IndexRouter::CreateCarRouter(countryFileGetter, numMwmIds,
                                                                              trafficCache, index));
     return carRouter;
   }
diff --git a/routing/world_graph.cpp b/routing/world_graph.cpp
index 2d38d49e8c..0546699eb6 100644
--- a/routing/world_graph.cpp
+++ b/routing/world_graph.cpp
@@ -15,7 +15,7 @@ WorldGraph::WorldGraph(unique_ptr<CrossMwmIndexGraph> crossMwmGraph,
 void WorldGraph::GetEdgeList(Segment const & segment, bool isOutgoing, bool isLeap,
                              vector<SegmentEdge> & edges)
 {
-  if (m_crossMwmGraph && isLeap)
+  if (m_crossMwmGraph && m_bordersAreOpened && isLeap)
   {
     if (m_crossMwmGraph->IsTransition(segment, isOutgoing))
       GetTwins(segment, isOutgoing, edges);
@@ -27,10 +27,16 @@ void WorldGraph::GetEdgeList(Segment const & segment, bool isOutgoing, bool isLe
   IndexGraph & indexGraph = GetIndexGraph(segment.GetMwmId());
   indexGraph.GetEdgeList(segment, isOutgoing, edges);
 
-  if (m_crossMwmGraph && m_crossMwmGraph->IsTransition(segment, isOutgoing))
+  if (m_crossMwmGraph && m_bordersAreOpened && m_crossMwmGraph->IsTransition(segment, isOutgoing))
     GetTwins(segment, isOutgoing, edges);
 }
 
+m2::PointD const & WorldGraph::GetPoint(Segment const & segment, bool front)
+{
+  return GetRoadGeometry(segment.GetMwmId(), segment.GetFeatureId())
+      .GetPoint(segment.GetPointId(front));
+}
+
 RoadGeometry const & WorldGraph::GetRoadGeometry(NumMwmId mwmId, uint32_t featureId)
 {
   return GetIndexGraph(mwmId).GetGeometry().GetRoad(featureId);
@@ -41,6 +47,11 @@ void WorldGraph::GetTwins(Segment const & segment, bool isOutgoing, vector<Segme
   m_twins.clear();
   m_crossMwmGraph->GetTwins(segment, isOutgoing, m_twins);
   for (Segment const & twin : m_twins)
-    edges.emplace_back(twin, 0.0 /* weight */);
+  {
+    m2::PointD const & from = GetPoint(segment, true /* front */);
+    m2::PointD const & to = GetPoint(twin, true /* front */);
+    double const weight = m_estimator->CalcHeuristic(from, to);
+    edges.emplace_back(twin, weight);
+  }
 }
 }  // namespace routing
diff --git a/routing/world_graph.hpp b/routing/world_graph.hpp
index ef40180b9e..9ff880111b 100644
--- a/routing/world_graph.hpp
+++ b/routing/world_graph.hpp
@@ -25,11 +25,13 @@ public:
   IndexGraph & GetIndexGraph(NumMwmId numMwmId) { return m_loader->GetIndexGraph(numMwmId); }
   EdgeEstimator const & GetEstimator() const { return *m_estimator; }
 
+  m2::PointD const & GetPoint(Segment const & segment, bool front);
   RoadGeometry const & GetRoadGeometry(NumMwmId mwmId, uint32_t featureId);
 
   // Disable edges between mwms.
-  // Unblocking is not implemented due to YAGNI principle.
-  void BlockMwmBorders() { m_crossMwmGraph = nullptr; }
+  void CloseBorders() { m_bordersAreOpened = false; }
+  // Enable edges between mwms.
+  void OpenBorders() { m_bordersAreOpened = true; }
   // Clear memory used by loaded index graphs.
   void ClearIndexGraphs() { m_loader->Clear(); }
 
@@ -40,5 +42,6 @@ private:
   std::unique_ptr<IndexGraphLoader> m_loader;
   std::shared_ptr<EdgeEstimator> m_estimator;
   std::vector<Segment> m_twins;
+  bool m_bordersAreOpened = true;
 };
 }  // namespace routing
diff --git a/search/house_to_street_table.cpp b/search/house_to_street_table.cpp
index 6321b0c636..5b86015300 100644
--- a/search/house_to_street_table.cpp
+++ b/search/house_to_street_table.cpp
@@ -46,7 +46,7 @@ public:
 
 unique_ptr<HouseToStreetTable> HouseToStreetTable::Load(MwmValue & value)
 {
-  version::MwmTraits traits(value.GetMwmVersion().GetFormat());
+  version::MwmTraits traits(value.GetMwmVersion());
   auto const format = traits.GetHouseToStreetTableFormat();
 
   unique_ptr<HouseToStreetTable> result;
diff --git a/search/retrieval.cpp b/search/retrieval.cpp
index 69f736beac..60354f721b 100644
--- a/search/retrieval.cpp
+++ b/search/retrieval.cpp
@@ -308,7 +308,7 @@ struct Selector
   template <typename... Args>
   unique_ptr<coding::CompressedBitVector> operator()(MwmContext const & context, Args &&... args)
   {
-    version::MwmTraits mwmTraits(context.m_value.GetMwmVersion().GetFormat());
+    version::MwmTraits mwmTraits(context.m_value.GetMwmVersion());
 
     if (mwmTraits.GetSearchIndexFormat() ==
         version::MwmTraits::SearchIndexFormat::FeaturesWithRankAndCenter)
diff --git a/xcode/routing/routing.xcodeproj/project.pbxproj b/xcode/routing/routing.xcodeproj/project.pbxproj
index 8b225f42fd..0750442b90 100644
--- a/xcode/routing/routing.xcodeproj/project.pbxproj
+++ b/xcode/routing/routing.xcodeproj/project.pbxproj
@@ -18,9 +18,9 @@
 		0C090C881E4E276700D52AFD /* world_graph.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 0C090C861E4E276700D52AFD /* world_graph.hpp */; };
 		0C0DF9211DE898B70055A22F /* index_graph_starter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0C0DF91F1DE898B70055A22F /* index_graph_starter.cpp */; };
 		0C0DF9221DE898B70055A22F /* index_graph_starter.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 0C0DF9201DE898B70055A22F /* index_graph_starter.hpp */; };
-		0C0DF9251DE898CF0055A22F /* single_mwm_router.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0C0DF9231DE898CF0055A22F /* single_mwm_router.cpp */; };
-		0C0DF9261DE898CF0055A22F /* single_mwm_router.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 0C0DF9241DE898CF0055A22F /* single_mwm_router.hpp */; };
 		0C0DF92A1DE898FF0055A22F /* routing_helpers.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0C0DF9281DE898FF0055A22F /* routing_helpers.cpp */; };
+		0C12ED231E5C822A0080D0F4 /* index_router.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0C12ED211E5C822A0080D0F4 /* index_router.cpp */; };
+		0C12ED241E5C822A0080D0F4 /* index_router.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 0C12ED221E5C822A0080D0F4 /* index_router.hpp */; };
 		0C470E701E0D4EB1005B824D /* segment.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 0C470E6F1E0D4EB1005B824D /* segment.hpp */; };
 		0C5992E21E433BE600203653 /* num_mwm_id.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 0C5992E11E433BE600203653 /* num_mwm_id.hpp */; };
 		0C5BC9D11E28FD4E0071BFDD /* index_road_graph.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0C5BC9CF1E28FD4E0071BFDD /* index_road_graph.cpp */; };
@@ -273,9 +273,9 @@
 		0C090C861E4E276700D52AFD /* world_graph.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = world_graph.hpp; sourceTree = "<group>"; };
 		0C0DF91F1DE898B70055A22F /* index_graph_starter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = index_graph_starter.cpp; sourceTree = "<group>"; };
 		0C0DF9201DE898B70055A22F /* index_graph_starter.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = index_graph_starter.hpp; sourceTree = "<group>"; };
-		0C0DF9231DE898CF0055A22F /* single_mwm_router.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = single_mwm_router.cpp; sourceTree = "<group>"; };
-		0C0DF9241DE898CF0055A22F /* single_mwm_router.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = single_mwm_router.hpp; sourceTree = "<group>"; };
 		0C0DF9281DE898FF0055A22F /* routing_helpers.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = routing_helpers.cpp; sourceTree = "<group>"; };
+		0C12ED211E5C822A0080D0F4 /* index_router.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = index_router.cpp; sourceTree = "<group>"; };
+		0C12ED221E5C822A0080D0F4 /* index_router.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = index_router.hpp; sourceTree = "<group>"; };
 		0C470E6F1E0D4EB1005B824D /* segment.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = segment.hpp; sourceTree = "<group>"; };
 		0C5992E11E433BE600203653 /* num_mwm_id.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = num_mwm_id.hpp; sourceTree = "<group>"; };
 		0C5BC9CF1E28FD4E0071BFDD /* index_road_graph.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = index_road_graph.cpp; sourceTree = "<group>"; };
@@ -752,6 +752,8 @@
 				0C5FEC591DDE192A0017688C /* index_graph.hpp */,
 				0C5BC9CF1E28FD4E0071BFDD /* index_road_graph.cpp */,
 				0C5BC9D01E28FD4E0071BFDD /* index_road_graph.hpp */,
+				0C12ED211E5C822A0080D0F4 /* index_router.cpp */,
+				0C12ED221E5C822A0080D0F4 /* index_router.hpp */,
 				0C5FEC5A1DDE192A0017688C /* joint_index.cpp */,
 				0C5FEC5B1DDE192A0017688C /* joint_index.hpp */,
 				0C5FEC5C1DDE192A0017688C /* joint.cpp */,
@@ -807,8 +809,6 @@
 				670EE55B1B6001E7001E8064 /* routing_session.hpp */,
 				670EE55C1B6001E7001E8064 /* routing_settings.hpp */,
 				0C470E6F1E0D4EB1005B824D /* segment.hpp */,
-				0C0DF9231DE898CF0055A22F /* single_mwm_router.cpp */,
-				0C0DF9241DE898CF0055A22F /* single_mwm_router.hpp */,
 				A1876BC41BB19C4300C9C743 /* speed_camera.cpp */,
 				A1876BC51BB19C4300C9C743 /* speed_camera.hpp */,
 				0C090C831E4E275E00D52AFD /* traffic_stash.hpp */,
@@ -878,7 +878,6 @@
 				6753441A1A3F644F00A0A8C3 /* osrm2feature_map.hpp in Headers */,
 				6741AA9D1BF35331002C974C /* turns_notification_manager.hpp in Headers */,
 				674F9BD71B0A580E00704FFA /* turns_generator.hpp in Headers */,
-				0C0DF9261DE898CF0055A22F /* single_mwm_router.hpp in Headers */,
 				A120B3461B4A7BE5002F3808 /* cross_mwm_road_graph.hpp in Headers */,
 				6753441C1A3F644F00A0A8C3 /* route.hpp in Headers */,
 				A1616E2C1B6B60AB003F078E /* router_delegate.hpp in Headers */,
@@ -920,6 +919,7 @@
 				0C5FEC551DDE191E0017688C /* edge_estimator.hpp in Headers */,
 				670B84C11A9381D900CE4492 /* cross_routing_context.hpp in Headers */,
 				563B91C61CC4F1DC00222BC1 /* bicycle_model.hpp in Headers */,
+				0C12ED241E5C822A0080D0F4 /* index_router.hpp in Headers */,
 				0C5FEC651DDE192A0017688C /* joint.hpp in Headers */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
@@ -1149,7 +1149,6 @@
 				A1616E2B1B6B60AB003F078E /* router_delegate.cpp in Sources */,
 				6741AA9C1BF35331002C974C /* turns_notification_manager.cpp in Sources */,
 				67C7D42B1B4EB48F00FE41AA /* pedestrian_model.cpp in Sources */,
-				0C0DF9251DE898CF0055A22F /* single_mwm_router.cpp in Sources */,
 				56D637D61E4B12AA00B86D7B /* cross_mwm_index_graph.cpp in Sources */,
 				0C0DF9211DE898B70055A22F /* index_graph_starter.cpp in Sources */,
 				A120B3471B4A7BE5002F3808 /* cross_mwm_router.cpp in Sources */,
@@ -1178,6 +1177,7 @@
 				0C5FEC601DDE192A0017688C /* index_graph.cpp in Sources */,
 				0C5FEC6D1DDE19A40017688C /* index_graph_test.cpp in Sources */,
 				56CA09E41E30E73B00D05C9A /* cumulative_restriction_test.cpp in Sources */,
+				0C12ED231E5C822A0080D0F4 /* index_router.cpp in Sources */,
 				6753441E1A3F644F00A0A8C3 /* turns.cpp in Sources */,
 				670B84C01A9381D900CE4492 /* cross_routing_context.cpp in Sources */,
 				A120B3501B4A7C0A002F3808 /* routing_algorithm.cpp in Sources */,