routing fixes and style improvements

5 files changed, 98 insertions, 183 deletions

diff --git a/generator/routing_generator.cpp b/generator/routing_generator.cpp
index 69a02882d3..7bbcd67dc8 100644
--- a/generator/routing_generator.cpp
+++ b/generator/routing_generator.cpp
@@ -28,26 +28,11 @@
 #include "../routing/osrm_router.hpp"
 #include "../routing/cross_routing_context.hpp"
 
-#define BORDERS_DIR "borders/"
-#define BORDERS_EXTENSION ".borders"
 
 namespace routing
 {
 
-//Int bacause shortest_path_length has same type =(
-/*int CalculateCrossLength(size_t start, size_t stop, RawDataFacadeT & facade)
-{
-  FeatureGraphNodeVecT taskNode(2), ftaskNode(2);
-  OsrmRouter::GenerateRoutingTaskFromNodeId(start, taskNode);
-  OsrmRouter::GenerateRoutingTaskFromNodeId(stop, ftaskNode);
-  RawRoutingResultT routingResult;
-  if (OsrmRouter::FindSingleRoute(taskNode, ftaskNode, facade, routingResult))
-  {
-    return routingResult.m_routePath.shortest_path_length;
-  }
-  return std::numeric_limits<int>::max();
-}*/
-
+//Routines to get borders from tree
 class GetCountriesBordersByName
 {
 
@@ -103,16 +88,10 @@ public:
     CheckPointInBorder getter(m_point, inside);
     c.m_regions.ForEachInRect(m2::RectD(m_point, m_point), getter);
     if (inside)
-    {
       m_name = c.m_name;
-      LOG(LINFO, ("FROM INSIDE 0_0 ", m_name));
-    }
-    else
-      LOG(LINFO, ("NOT INSIDE ", c.m_name));
   }
 };
 
-
 static double const EQUAL_POINT_RADIUS_M = 2.0;
 
 void BuildRoutingIndex(string const & baseDir, string const & countryName, string const & osrmFile)
@@ -143,23 +122,9 @@ void BuildRoutingIndex(string const & baseDir, string const & countryName, strin
       m2::RegionD finalBorder;
       finalBorder.Data().reserve(border.Data().size());
       for (auto p = tmpRegionBorders.data()->Begin(); p<tmpRegionBorders.data()->End(); ++p)
-        finalBorder.AddPoint(m2::PointD(MercatorBounds::XToLon(p->x), MercatorBounds::YToLat(p->y)));
+        finalBorder.AddPoint({MercatorBounds::XToLon(p->x), MercatorBounds::YToLat(p->y)});
       regionBorders.push_back(finalBorder);
     }
-    /*
-    vector<m2::RegionD> tmpRegionBorders;
-    if (osm::LoadBorders(baseDir + BORDERS_DIR + countryName + BORDERS_EXTENSION, tmpRegionBorders))
-    {
-      LOG(LINFO, ("Found",tmpRegionBorders.size(),"region borders"));
-      for (m2::RegionD const& border: tmpRegionBorders)
-      {
-        m2::RegionD finalBorder;
-        finalBorder.Data().reserve(border.Data().size());
-        for (auto p = tmpRegionBorders.data()->Begin(); p<tmpRegionBorders.data()->End(); ++p)
-          finalBorder.AddPoint(m2::PointD(MercatorBounds::XToLon(p->x), MercatorBounds::YToLat(p->y)));
-        regionBorders.push_back(finalBorder);
-      }
-    }*/
   }
 
   gen::OsmID2FeatureID osm2ft;
@@ -197,10 +162,6 @@ void BuildRoutingIndex(string const & baseDir, string const & countryName, strin
         // check nearest to goverment borders
         for (m2::RegionD const& border: regionBorders)
         {
-          //if ( (border.Contains(pts[0]) ^ border.Contains(pts[1]))) // || border.atBorder(pts[0], 0.005) || border.atBorder(pts[1], 0.005))
-          //{
-          //  outgoingNodes.push_back(nodeId);
-          //}
           bool outStart = border.Contains(pts[0]), outEnd = border.Contains(pts[1]);
           if (outStart == true && outEnd == false)
           {
@@ -210,8 +171,9 @@ void BuildRoutingIndex(string const & baseDir, string const & countryName, strin
             m_countries.ForEachInRect(m2::RectD(mercatorPoint, mercatorPoint), getter);
             crossContext.addOutgoingNode(nodeId, mwmName);
           }
-          if (outStart == false && outEnd == true)
-            crossContext.addIngoingNode(nodeId);
+          else
+            if (outStart == false && outEnd == true)
+              crossContext.addIngoingNode(nodeId);
         }
       }
     }
@@ -381,22 +343,6 @@ void BuildRoutingIndex(string const & baseDir, string const & countryName, strin
     matrixSource.Read(&matrixBuffer[0], matrixSource.Size());
     facade.LoadRawData(edgeBuffer.data(), edgeIdsBuffer.data(), shortcutsBuffer.data(), matrixBuffer.data());
 
-
-    map<size_t, size_t> incomeEdgeCountMap;
-    size_t const nodeDataSize = nodeData.size();
-    for (size_t nodeId = 0; nodeId < nodeDataSize; ++nodeId)
-    {
-      for(auto e: facade.GetAdjacentEdgeRange(nodeId))
-      {
-        const size_t target_node = facade.GetTarget(e);
-        auto const it = incomeEdgeCountMap.find(target_node);
-        if (it==incomeEdgeCountMap.end())
-          incomeEdgeCountMap.insert(make_pair(target_node, 1));
-        else
-          incomeEdgeCountMap[target_node] += 1;
-      }
-    }
-
     LOG(LINFO, ("Calculating weight map between outgoing nodes"));
     crossContext.reserveAdjacencyMatrix();
     auto in = crossContext.GetIngoingIterators();
@@ -418,10 +364,8 @@ void BuildRoutingIndex(string const & baseDir, string const & countryName, strin
       for (auto j=out.first; j<out.second; ++j )
       {
         crossContext.setAdjacencyCost(i, j, *res);
-        LOG(LINFO, ("Have weight", *res));
         ++res;
       }
-
     LOG(LINFO, ("Calculating weight map between outgoing nodes DONE"));
   }
 
@@ -436,31 +380,4 @@ void BuildRoutingIndex(string const & baseDir, string const & countryName, strin
   VERIFY(my::GetFileSize(fPath, sz), ());
   LOG(LINFO, ("Nodes stored:", stored, "Routing index file size:", sz));
 }
-
-
-void BuildCrossesRoutingIndex(string const & baseDir)
-{
-/*
-  vector<size_t> outgoingNodes1;
-  vector<size_t> outgoingNodes2;
-  vector<size_t> result;
-  const string file1_path = baseDir+"Russia_central.mwm.routing";
-  const string file2_path = baseDir+"Belarus.mwm.routing";
-  FilesMappingContainer f1Cont(file1_path);
-  FilesMappingContainer f2Cont(file2_path);
-  ReaderSource<FileReader> r1(f1Cont.GetReader(ROUTING_OUTGOING_FILE_TAG));
-  ReaderSource<FileReader> r2(f2Cont.GetReader(ROUTING_OUTGOING_FILE_TAG));
-
-  LOG(LINFO, ("Loading mwms"));
-  rw::ReadVectorOfPOD(r1,outgoingNodes1);
-  rw::ReadVectorOfPOD(r2,outgoingNodes2);
-
-  LOG(LINFO, ("Have outgoing lengthes", outgoingNodes1.size(), outgoingNodes2.size()));
-  sort(outgoingNodes1.begin(), outgoingNodes1.end());
-  sort(outgoingNodes2.begin(), outgoingNodes2.end());
-  set_intersection(outgoingNodes1.begin(),outgoingNodes1.end(),outgoingNodes2.begin(),outgoingNodes2.end(),back_inserter(result));
-  LOG(LINFO, ("Have nodes after intersection", result.size()));
-*/
-}
-
 }
diff --git a/generator/routing_generator.hpp b/generator/routing_generator.hpp
index 827fada573..b5cfe575a8 100644
--- a/generator/routing_generator.hpp
+++ b/generator/routing_generator.hpp
@@ -11,11 +11,6 @@ namespace routing
 /*!
  * \brief The OutgoungNodeT struct. Contains node identifier and it's coordinate to calculate same nodes at different mwm's
  */
-/*struct OutgoungNodeT {
-  size_t node_id;
-  double x;
-  double y;
-};*/
 typedef size_t OutgoingNodeT;
 
 typedef std::vector<OutgoingNodeT> OutgoingVectorT;
diff --git a/routing/cross_routing_context.hpp b/routing/cross_routing_context.hpp
index b5f53c7039..07d53ae63e 100644
--- a/routing/cross_routing_context.hpp
+++ b/routing/cross_routing_context.hpp
@@ -46,6 +46,8 @@ public:
 
   void Load(Reader const & r)
   {
+    if (m_adjacencyMatrix.size())
+      return; //Already loaded
     size_t size, pos=0;
     r.Read(pos, &size, sizeof(size_t));
     pos += sizeof(size_t);
@@ -82,7 +84,7 @@ public:
   //Writing part
   void Save(Writer & w)
   {
-    //LOG(LINFO, ("Have ingoing", m_ingoingNodes.size(), "outgoing", m_outgoingNodes.size, "neighbors", m_neighborMwmList.size()));
+    sort(m_ingoingNodes.begin(), m_ingoingNodes.end());
     size_t size = m_ingoingNodes.size();
     w.Write(&size, sizeof(size_t));
     w.Write(&(m_ingoingNodes[0]), sizeof(size_t) * size);
diff --git a/routing/osrm_router.cpp b/routing/osrm_router.cpp
index a796932cbc..61ed7ab455 100644
--- a/routing/osrm_router.cpp
+++ b/routing/osrm_router.cpp
@@ -499,26 +499,28 @@ bool IsRouteExist(RawRouteData const & r)
 
 }
 
-FeatureGraphNode const & OsrmRouter::FilterWeightsMatrix(MultiroutingTaskPointT const & sources, MultiroutingTaskPointT const & targets,
+MultiroutingTaskPointT::const_iterator OsrmRouter::FilterWeightsMatrix(MultiroutingTaskPointT const & sources, MultiroutingTaskPointT const & targets,
                                     std::vector<EdgeWeight> &weightMatrix, bool const filterSource)
 {
   if (filterSource)
   {
     for (size_t i=0; i<sources.size(); ++i)
       for (size_t j=0; j<targets.size(); ++j)
-        if (weightMatrix[ i*sources.size() + j] < numeric_limits<EdgeWeight>::max())
+        if (weightMatrix[ i*sources.size() + j] < INVALID_EDGE_WEIGHT)
         {
           weightMatrix.erase(weightMatrix.begin(), weightMatrix.begin()+i*targets.size());
           weightMatrix.erase(weightMatrix.begin()+targets.size(), weightMatrix.end());
           ASSERT(weightMatrix.size()==targets.size(), ());
-          return sources[i];
+          return sources.cbegin()+i;
         }
+
+    return sources.cend();
   }
   else
   {
     for (size_t i=0; i<targets.size(); ++i)
       for (size_t j=0; j<sources.size(); ++j)
-        if (weightMatrix[ j*sources.size() + i] < numeric_limits<EdgeWeight>::max())
+        if (weightMatrix[ j*sources.size() + i] < INVALID_EDGE_WEIGHT)
         {
           for (int k=sources.size()-1; k>-1; --k)
           {
@@ -526,10 +528,10 @@ FeatureGraphNode const & OsrmRouter::FilterWeightsMatrix(MultiroutingTaskPointT
             weightMatrix.erase(weightMatrix.begin()+k*targets.size()+i+1, weightMatrix.begin()+(k+1)*targets.size());
           }
           ASSERT(weightMatrix.size()==sources.size(), ());
-          return targets[i];
+          return targets.cbegin() + i;
         }
+    return targets.cend();
   }
-  return FeatureGraphNode();
 }
 
 void OsrmRouter::FindWeightsMatrix(MultiroutingTaskPointT const & sources, MultiroutingTaskPointT const & targets,
@@ -642,41 +644,28 @@ void OsrmRouter::GenerateRoutingTaskFromNodeId(const size_t nodeId, FeatureGraph
   taskNode.m_node.reverse_offset = 0;
   taskNode.m_node.name_id = 1;
   taskNode.m_seg.m_fid = OsrmFtSegMapping::FtSeg::INVALID_FID;
-  /*
-  taskNode.resize(2);
-  taskNode[0].m_node.forward_node_id = nodeId;
-  taskNode[0].m_node.reverse_node_id = INVALID_NODE_ID;
-  taskNode[0].m_node.forward_weight = 0;
-  taskNode[0].m_node.reverse_weight = 0;
-  taskNode[0].m_seg.m_fid = OsrmFtSegMapping::FtSeg::INVALID_FID;
-  taskNode[1].m_node.forward_node_id = INVALID_NODE_ID;
-  taskNode[1].m_node.reverse_node_id = nodeId;
-  taskNode[1].m_node.forward_weight = 0;
-  taskNode[1].m_node.reverse_weight = 0;
-  taskNode[1].m_seg.m_fid = OsrmFtSegMapping::FtSeg::INVALID_FID;
-  */
 }
 
 size_t OsrmRouter::FindNextMwmNode(RoutingMappingPtrT const & startMapping, size_t startId, RoutingMappingPtrT const & targetMapping)
 {
-  m2::PointD startPoint = GetPointByNodeId(startId, startMapping, false);
-  m2::PointD startPointTmp = GetPointByNodeId(startId, startMapping, true);
-  startPoint = m2::PointD(MercatorBounds::XToLon(startPoint.x), MercatorBounds::YToLat(startPoint.y));
-  startPointTmp = m2::PointD(MercatorBounds::XToLon(startPointTmp.x), MercatorBounds::YToLat(startPointTmp.y));
+  m2::PointD startPointStart = GetPointByNodeId(startId, startMapping, true);
+  m2::PointD startPointEnd = GetPointByNodeId(startId, startMapping, false);
+  startPointStart = {MercatorBounds::XToLon(startPointStart.x), MercatorBounds::YToLat(startPointStart.y)};
+  startPointEnd = {MercatorBounds::XToLon(startPointEnd.x), MercatorBounds::YToLat(startPointEnd.y)};
   CrossRoutingContext const & targetContext = targetMapping->dataFacade.getRoutingContext();
   auto income_iters = targetContext.GetIngoingIterators();
   for (auto i=income_iters.first; i<income_iters.second; ++i)
   {
     m2::PointD targetPoint = GetPointByNodeId(*i, targetMapping, true);
-    m2::PointD targetPointTmp = GetPointByNodeId(*i, targetMapping, false);
+    m2::PointD targetPointEnd = GetPointByNodeId(*i, targetMapping, false);
     targetPoint = m2::PointD(MercatorBounds::XToLon(targetPoint.x), MercatorBounds::YToLat(targetPoint.y));
-    targetPointTmp = m2::PointD(MercatorBounds::XToLon(targetPointTmp.x), MercatorBounds::YToLat(targetPointTmp.y));
+    targetPointEnd = m2::PointD(MercatorBounds::XToLon(targetPointEnd.x), MercatorBounds::YToLat(targetPointEnd.y));
 
-    double const dist = min(min(ms::DistanceOnEarth((startPoint.y), (startPoint.x), (targetPoint.y), (targetPoint.x)),
-                            ms::DistanceOnEarth((startPointTmp.y), (startPointTmp.x), (targetPoint.y), (targetPoint.x))),
-                            min(ms::DistanceOnEarth((startPoint.y), (startPoint.x), (targetPointTmp.y), (targetPointTmp.x)),
-                            ms::DistanceOnEarth((startPointTmp.y), (startPointTmp.x), (targetPointTmp.y), (targetPointTmp.x))));
-    if (dist<10)
+    double const dist = min(min(ms::DistanceOnEarth(startPointEnd.y, startPointEnd.x, targetPoint.y, targetPoint.x),
+                            ms::DistanceOnEarth(startPointStart.y, startPointStart.x, targetPoint.y, targetPoint.x)),
+                            min(ms::DistanceOnEarth(startPointEnd.y, startPointEnd.x, targetPointEnd.y, targetPointEnd.x),
+                            ms::DistanceOnEarth(startPointStart.y, startPointStart.x, targetPointEnd.y, targetPointEnd.x)));
+    if (dist < FEATURE_BY_POINT_RADIUS_M)
       return *i;
   }
   return INVALID_NODE_ID;
@@ -710,7 +699,6 @@ OsrmRouter::ResultCode OsrmRouter::MakeRouteFromCrossesPath(CheckedPathT const &
     RoutingMappingPtrT mwmMapping;
     mwmMapping = m_indexManager.GetMappingByName(cross.mwmName, m_pIndex);
     mwmMapping->LoadFacade();
-    LOG(LINFO, ("mwmFacade data", mwmMapping->dataFacade.GetNumberOfNodes()));
     if (!FindSingleRoute(startTask, targetTask, mwmMapping->dataFacade, routingResult))
     {
       mwmMapping->FreeFacade();
@@ -744,6 +732,8 @@ OsrmRouter::ResultCode OsrmRouter::MakeRouteFromCrossesPath(CheckedPathT const &
       Points.pop_back(); //You at the end point
     Points.insert(Points.end(), ++mwmPoints.begin(), mwmPoints.end());
     TurnsGeom.insert(TurnsGeom.end(), mwmTurnsGeom.begin(), mwmTurnsGeom.end());
+    mwmMapping->FreeFacade();
+    mwmMapping->Unmap();
   }
 
   route.SetGeometry(Points.begin(), Points.end());
@@ -767,25 +757,26 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
       return e;
   }
 
+  MappingGuard startMappingGuard(startMapping);
+  MappingGuard finalMappingGuard(finalMapping);
+  UNUSED_VALUE(startMappingGuard);
+  UNUSED_VALUE(finalMappingGuard);
+
   // 3. Find start/end nodes.
   FeatureGraphNodeVecT startTask;
 
   {
-    startMapping->Map();
     ResultCode const code = FindPhantomNodes(startMapping->GetName(), startPt, startDr, startTask, MAX_NODE_CANDIDATES, startMapping);
     if (code != NoError)
       return code;
-    startMapping->Unmap();
   }
   {
     if (finalPt != m_CachedTargetPoint)
     {
-      finalMapping->Map();
       ResultCode const code = FindPhantomNodes(finalMapping->GetName(), finalPt, m2::PointD::Zero(), m_CachedTargetTask, MAX_NODE_CANDIDATES, finalMapping);
       if (code != NoError)
         return code;
       m_CachedTargetPoint = finalPt;
-      finalMapping->Unmap();
     }
   }
   if (m_requestCancel)
@@ -797,20 +788,16 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
   if (startMapping->GetName() == finalMapping->GetName())
   {
     LOG(LINFO, ("Single mwm routing case"));
-    startMapping->LoadFacade();
     if (!FindSingleRoute(startTask, m_CachedTargetTask, startMapping->dataFacade, routingResult))
     {
-      startMapping->FreeFacade();
       return RouteNotFound;
     }
     if (m_requestCancel)
     {
-      startMapping->FreeFacade();
       return Cancelled;
     }
 
     // 5. Restore route.
-    startMapping->Map();
 
     Route::TurnsT turnsDir;
     Route::TimesT times;
@@ -824,19 +811,11 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
     route.SetSectionTimes(times);
     route.SetTurnInstructionsGeometry(turnsGeom);
 
-    startMapping->FreeFacade();
-    startMapping->Unmap();
     return NoError;
   }
   else
   {
     LOG(LINFO, ("Different mwm routing case"));
-    //NodeIdVectorT startBorderNodes;
-    //NodeIdVectorT finalBorderNodes;
-    startMapping->Map();
-    finalMapping->Map();
-    startMapping->LoadFacade();
-    finalMapping->LoadFacade();
 
     CrossRoutingContext const & startContext = startMapping->dataFacade.getRoutingContext();
     auto out_iterators = startContext.GetOutgoingIterators();
@@ -857,15 +836,15 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
     FindWeightsMatrix(sources, targets, startMapping->dataFacade, weights);
     FindWeightsMatrix(income_sources, income_targets, finalMapping->dataFacade, target_weights);
 
-    FeatureGraphNode const & sourceNode = FilterWeightsMatrix(sources, targets,weights, true);
-    FeatureGraphNode const & targetNode = FilterWeightsMatrix(income_sources, income_targets, target_weights, false);
+    auto sourceNodeIter = FilterWeightsMatrix(sources, targets,weights, true);
+    auto targetNodeIter = FilterWeightsMatrix(income_sources, income_targets, target_weights, false);
 
-    if (!sourceNode.m_seg.IsValid())
+    if (sourceNodeIter == sources.cend())
       return StartPointNotFound;
-    if (!targetNode.m_seg.IsValid())
+    if (targetNodeIter == targets.cend())
       return EndPointNotFound;
 
-    EdgeWeight finalWeight = numeric_limits<EdgeWeight>::max();
+    EdgeWeight finalWeight = INVALID_EDGE_WEIGHT;
     CheckedPathT finalPath;
 
     struct pathChecker{
@@ -879,7 +858,7 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
 
       for (size_t j=0; j<targets.size(); ++j)
       {
-        if (weights[j] < numeric_limits<EdgeWeight>::max())
+        if (weights[j] < INVALID_EDGE_WEIGHT)
         {
           string const & nextMwm = startContext.getOutgoingMwmName((out_iterators.first+j)->second);
           RoutingMappingPtrT nextMapping;
@@ -891,7 +870,8 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
           {
               continue; //There is no outgoing mwm
           }
-
+          MappingGuard nextMappingGuard(nextMapping);
+          UNUSED_VALUE(nextMappingGuard);
           size_t tNodeId = (out_iterators.first+j)->first;
           size_t nextNodeId = FindNextMwmNode(startMapping, tNodeId, nextMapping);
           if(nextNodeId == INVALID_NODE_ID)
@@ -902,7 +882,7 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
             CheckedPathT tmpPath;
             FeatureGraphNode tmpNode;
             OsrmRouter::GenerateRoutingTaskFromNodeId(nextNodeId, tmpNode);
-            tmpPath.push_back({startMapping->GetName(), sourceNode, targets[j], weights[j]});
+            tmpPath.push_back({startMapping->GetName(), *sourceNodeIter, targets[j], weights[j]});
             tmpPath.push_back({nextMapping->GetName(), tmpNode, tmpNode, 0});
             crossTasks.push(tmpPath);
           }
@@ -912,15 +892,15 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
             ASSERT(it != income_iterators.second, ());
             const size_t targetNumber = distance(income_iterators.first, it);
             const EdgeWeight targetWeight = target_weights[targetNumber];
-            if (targetWeight == numeric_limits<EdgeWeight>::max())
+            if (targetWeight == INVALID_EDGE_WEIGHT)
               continue;
             const EdgeWeight newWeight = weights[j] + targetWeight;
             if (newWeight<finalWeight)
             {
               finalWeight = newWeight;
               finalPath.clear();
-              finalPath.push_back({startMapping->GetName(), sourceNode, targets[j], weights[j]});
-              finalPath.push_back({finalMapping->GetName(), income_sources[targetNumber], targetNode, targetWeight});
+              finalPath.push_back({startMapping->GetName(), *sourceNodeIter, targets[j], weights[j]});
+              finalPath.push_back({finalMapping->GetName(), income_sources[targetNumber], *targetNodeIter, targetWeight});
             }
           }
         }
@@ -930,8 +910,9 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
       {
         while (getPathWeight(crossTasks.top())<finalWeight)
         {
-          CheckedPathT const & topTask = crossTasks.top();
-          RoutePathCross const & cross = topTask.back();
+          CheckedPathT const topTask = crossTasks.top();
+          crossTasks.pop();
+          RoutePathCross const cross = topTask.back();
           RoutingMappingPtrT currentMapping;
           try
           {
@@ -939,31 +920,23 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
           }
           catch (OsrmRouter::ResultCode e)
           {
-            crossTasks.pop();
             continue; //There is no outgoing mwm
           }
-          currentMapping->LoadFacade();
-          currentMapping->Map();
+          MappingGuard currentMappingGuard(currentMapping);
+          UNUSED_VALUE(currentMappingGuard);
           CrossRoutingContext const & currentContext = currentMapping->dataFacade.getRoutingContext();
           auto current_in_iterators = currentContext.GetIngoingIterators();
           auto current_out_iterators = currentContext.GetOutgoingIterators();
 
           //find income number
-          //auto const iit = find(current_in_iterators.first, current_in_iterators.second, cross.startNode.m_node.forward_node_id);
-          auto iit = current_in_iterators.second;
-          for (auto q = current_in_iterators.first; q<current_in_iterators.second; ++q)
-            if (*q==cross.startNode.m_node.forward_node_id)
-            {
-              iit = q;
-              break;
-            }
+          auto const iit = find(current_in_iterators.first, current_in_iterators.second, cross.startNode.m_node.forward_node_id);
           ASSERT(iit != current_in_iterators.second, ());
 
           //find outs
           for (auto oit=current_out_iterators.first; oit!= current_out_iterators.second; ++oit)
           {
             const EdgeWeight outWeight = currentContext.getAdjacencyCost(iit, oit);
-            if (outWeight != numeric_limits<EdgeWeight>::max())
+            if (outWeight != INVALID_EDGE_WEIGHT)
             {
               if (getPathWeight(topTask)+outWeight < finalWeight)
               {
@@ -978,10 +951,10 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
                   continue; //There is no outgoing mwm
                 }
 
-                nextMapping->Map();
-                nextMapping->LoadFacade();
-                size_t tNodeId = oit->first;
-                auto const outNode = make_pair(tNodeId, startMapping->GetName());
+                MappingGuard nextMappingGuard(nextMapping);
+                UNUSED_VALUE(nextMappingGuard);
+                size_t const tNodeId = oit->first;
+                auto const outNode = make_pair(tNodeId, currentMapping->GetName());
                 if (checkedOuts.find(outNode)!=checkedOuts.end())
                   continue;
                 checkedOuts.insert(outNode);
@@ -990,12 +963,12 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
                   continue;
                 if (nextMwm != finalMapping->GetName())
                 {
-                  CheckedPathT tmpPath(crossTasks.top());
-                  crossTasks.pop();
+                  CheckedPathT tmpPath(topTask);
                   FeatureGraphNode startNode, stopNode, tmpNode;
                   OsrmRouter::GenerateRoutingTaskFromNodeId(nextNodeId, tmpNode);
                   OsrmRouter::GenerateRoutingTaskFromNodeId(*iit, startNode);
-                  OsrmRouter::GenerateRoutingTaskFromNodeId(oit->first, stopNode);
+                  OsrmRouter::GenerateRoutingTaskFromNodeId(tNodeId, stopNode);
+                  tmpPath.pop_back();
                   tmpPath.push_back({currentMapping->GetName(), startNode, stopNode, outWeight});
                   tmpPath.push_back({nextMapping->GetName(), tmpNode, tmpNode, 0});
                   crossTasks.push(tmpPath);
@@ -1006,32 +979,30 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
                   ASSERT(it != income_iterators.second, ());
                   const size_t targetNumber = distance(income_iterators.first, it);
                   const EdgeWeight targetWeight = target_weights[targetNumber];
-                  if (targetWeight == numeric_limits<EdgeWeight>::max())
+                  if (targetWeight == INVALID_EDGE_WEIGHT)
                     continue;
                   const EdgeWeight newWeight = getPathWeight(topTask) + outWeight + targetWeight;
                   if (newWeight<finalWeight)
                   {
                     finalWeight = newWeight;
-                    finalPath = CheckedPathT(crossTasks.top());
+                    finalPath = CheckedPathT(topTask);
                     finalPath.pop_back();
                     FeatureGraphNode startNode, stopNode;
                     OsrmRouter::GenerateRoutingTaskFromNodeId(*iit, startNode);
-                    OsrmRouter::GenerateRoutingTaskFromNodeId(oit->first, stopNode);
+                    OsrmRouter::GenerateRoutingTaskFromNodeId(tNodeId, stopNode);
                     finalPath.push_back({currentMapping->GetName(), startNode, stopNode, outWeight});
-                    finalPath.push_back({finalMapping->GetName(), income_sources[targetNumber], targetNode, targetWeight});
+                    finalPath.push_back({nextMwm, income_sources[targetNumber], *targetNodeIter, targetWeight});
                   }
                 }
               }
             }
           }
-          crossTasks.pop();
           if (!crossTasks.size())
             break;
         }
       }
 
-    LOG(LINFO, ("Facade data", startMapping->dataFacade.GetNumberOfNodes()));
-    if (finalWeight< numeric_limits<EdgeWeight>::max())
+    if (finalWeight < INVALID_EDGE_WEIGHT)
       return MakeRouteFromCrossesPath(finalPath, route);
     else
       return OsrmRouter::RouteNotFound;
@@ -1070,8 +1041,6 @@ OsrmRouter::ResultCode OsrmRouter::MakeTurnAnnotation(RawRoutingResultT const &
   SegT const & segBegin = routingResult.m_sourceEdge.m_seg;
   SegT const & segEnd = routingResult.m_targetEdge.m_seg;
 
-  //ASSERT(segBegin.IsValid(), ());
-  //ASSERT(segEnd.IsValid(), ());
   double estimateTime = 0;
 
   LOG(LDEBUG, ("Length:", routingResult.m_routePath.shortest_path_length));
@@ -1477,6 +1446,13 @@ void OsrmRouter::GetTurnDirection(PathData const & node1,
   Index::FeaturesLoaderGuard loader1(*m_pIndex, routingMapping->GetMwmId());
   Index::FeaturesLoaderGuard loader2(*m_pIndex, routingMapping->GetMwmId());
 
+  if (!(seg1.IsValid() && seg2.IsValid()))
+  {
+    LOG(LWARNING, ("Some turns can't load geometry"));
+    turn.m_turn = turns::NoTurn;
+    return;
+  }
+
   loader1.GetFeature(seg1.m_fid, ft1);
   loader2.GetFeature(seg2.m_fid, ft2);
 
diff --git a/routing/osrm_router.hpp b/routing/osrm_router.hpp
index c73708861b..ad8b51254f 100644
--- a/routing/osrm_router.hpp
+++ b/routing/osrm_router.hpp
@@ -115,6 +115,25 @@ private:
 
 typedef shared_ptr<RoutingMapping> RoutingMappingPtrT;
 
+//! \brief The MappingGuard struct. Asks mapping to load all data on construction and free it on destruction
+class MappingGuard
+{
+  RoutingMappingPtrT const m_mapping;
+
+public:
+  MappingGuard(RoutingMappingPtrT const mapping): m_mapping(mapping)
+  {
+    m_mapping->Map();
+    m_mapping->LoadFacade();
+  }
+
+  ~MappingGuard()
+  {
+    m_mapping->Unmap();
+    m_mapping->FreeFacade();
+  }
+};
+
 /*! Manager for loading, cashing and building routing indexes.
  * Builds and shares special routing contexts.
 */
@@ -255,9 +274,15 @@ private:
     return accumulate(path.begin(), path.end(), 0, [](EdgeWeight sum, RoutePathCross const & elem){return sum+elem.weight;});
   }
 
-  FeatureGraphNode const & FilterWeightsMatrix(MultiroutingTaskPointT const & sources, MultiroutingTaskPointT const & targets,
+  MultiroutingTaskPointT::const_iterator FilterWeightsMatrix(MultiroutingTaskPointT const & sources, MultiroutingTaskPointT const & targets,
                                       std::vector<EdgeWeight> &weightMatrix, bool const filterSource);
 
+  /*!
+   * \brief Makes route (points turns and other annotations) and submits it to @route class
+   * \param path vector of pathes through mwms
+   * \param route class to render final route
+   * \return NoError or error code
+   */
   ResultCode MakeRouteFromCrossesPath(CheckedPathT const & path, Route & route);
   NodeID GetTurnTargetNode(NodeID src, NodeID trg, QueryEdge::EdgeData const & edgeData, RoutingMappingPtrT const & routingMapping);
   void GetPossibleTurns(NodeID node,