diff --git a/routing/cross_mwm_road_graph.cpp b/routing/cross_mwm_road_graph.cpp index 05a090ac74..936b60d949 100644 --- a/routing/cross_mwm_road_graph.cpp +++ b/routing/cross_mwm_road_graph.cpp @@ -23,20 +23,19 @@ IRouter::ResultCode CrossMwmGraph::SetStartNode(CrossNode const & startNode) // Load source data. auto const mwmOutsIter = startMapping->m_crossContext.GetOutgoingIterators(); - // Generate routing task from one source to several targets. - TRoutingNodes sources(1), targets; size_t const outSize = distance(mwmOutsIter.first, mwmOutsIter.second); - targets.reserve(outSize); - - // If there is no routes outside source map. + // Can't find the route if there is no routes outside source map. if (!outSize) return IRouter::RouteNotFound; + // Generate routing task from one source to several targets. + TRoutingNodes sources(1), targets; + targets.reserve(outSize); for (auto j = mwmOutsIter.first; j < mwmOutsIter.second; ++j) targets.emplace_back(j->m_nodeId, false /* isStartNode */, startNode.mwmName); - vector weights; - sources[0] = FeatureGraphNode(startNode.node, true /* isStartNode */, startNode.mwmName); + + vector weights; FindWeightsMatrix(sources, targets, startMapping->m_dataFacade, weights); if (find_if(weights.begin(), weights.end(), &IsValidEdgeWeight) == weights.end()) return IRouter::StartPointNotFound; @@ -45,8 +44,8 @@ IRouter::ResultCode CrossMwmGraph::SetStartNode(CrossNode const & startNode) { if (IsValidEdgeWeight(weights[i])) { - TCrossPair nextNode = FindNextMwmNode(*(mwmOutsIter.first + i), startMapping); - if (nextNode.second.IsValid()) + BorderCross nextNode = FindNextMwmNode(*(mwmOutsIter.first + i), startMapping); + if (nextNode.toNode.IsValid()) dummyEdges.emplace_back(nextNode, weights[i]); } } @@ -90,14 +89,14 @@ IRouter::ResultCode CrossMwmGraph::SetFinalNode(CrossNode const & finalNode) CrossNode start(iNode.m_nodeId, finalNode.mwmName, MercatorBounds::FromLatLon(iNode.m_point.y, iNode.m_point.x)); vector dummyEdges; - dummyEdges.emplace_back(make_pair(finalNode, finalNode), weights[i]); + dummyEdges.emplace_back(BorderCross(finalNode, finalNode), weights[i]); m_virtualEdges.insert(make_pair(start, dummyEdges)); } } return IRouter::NoError; } -TCrossPair CrossMwmGraph::FindNextMwmNode(OutgoingCrossNode const & startNode, +BorderCross CrossMwmGraph::FindNextMwmNode(OutgoingCrossNode const & startNode, TRoutingMappingPtr const & currentMapping) const { m2::PointD const & startPoint = startNode.m_point; @@ -107,37 +106,39 @@ TCrossPair CrossMwmGraph::FindNextMwmNode(OutgoingCrossNode const & startNode, nextMapping = m_indexManager.GetMappingByName(nextMwm); // If we haven't this routing file, we skip this path. if (!nextMapping->IsValid()) - return TCrossPair(); + return BorderCross(); nextMapping->LoadCrossContext(); - auto income_iters = nextMapping->m_crossContext.GetIngoingIterators(); - for (auto i = income_iters.first; i < income_iters.second; ++i) + auto incomeIters = nextMapping->m_crossContext.GetIngoingIterators(); + for (auto i = incomeIters.first; i < incomeIters.second; ++i) { m2::PointD const & targetPoint = i->m_point; if (ms::DistanceOnEarth(startPoint.y, startPoint.x, targetPoint.y, targetPoint.x) < kMwmCrossingNodeEqualityRadiusMeters) - return make_pair(CrossNode(startNode.m_nodeId, currentMapping->GetName(), - MercatorBounds::FromLatLon(targetPoint.y, targetPoint.x)), - CrossNode(i->m_nodeId, nextMwm, - MercatorBounds::FromLatLon(targetPoint.y, targetPoint.x))); + { + return BorderCross(CrossNode(startNode.m_nodeId, currentMapping->GetName(), + MercatorBounds::FromLatLon(targetPoint.y, targetPoint.x)), + CrossNode(i->m_nodeId, nextMwm, + MercatorBounds::FromLatLon(targetPoint.y, targetPoint.x))); + } } - return TCrossPair(); + return BorderCross(); } -void CrossMwmGraph::GetOutgoingEdgesListImpl(TCrossPair const & v, +void CrossMwmGraph::GetOutgoingEdgesListImpl(BorderCross const & v, vector & adj) const { // Check for virtual edges. adj.clear(); - auto const it = m_virtualEdges.find(v.second); + auto const it = m_virtualEdges.find(v.toNode); if (it != m_virtualEdges.end()) { adj.insert(adj.end(), it->second.begin(), it->second.end()); return; } - // Loading cross roating section. - TRoutingMappingPtr currentMapping = m_indexManager.GetMappingByName(v.second.mwmName); + // Loading cross routing section. + TRoutingMappingPtr currentMapping = m_indexManager.GetMappingByName(v.toNode.mwmName); ASSERT(currentMapping->IsValid(), ()); currentMapping->LoadCrossContext(); @@ -146,31 +147,31 @@ void CrossMwmGraph::GetOutgoingEdgesListImpl(TCrossPair const & v, auto outRange = currentContext.GetOutgoingIterators(); // Find income node. - auto iit = inRange.first; - while (iit != inRange.second) + auto inIt = inRange.first; + while (inIt != inRange.second) { - if (iit->m_nodeId == v.second.node) + if (inIt->m_nodeId == v.toNode.node) break; - ++iit; + ++inIt; } - CHECK(iit != inRange.second, ()); + CHECK(inIt != inRange.second, ()); // Find outs. Generate adjacency list. - for (auto oit = outRange.first; oit != outRange.second; ++oit) + for (auto oitIt = outRange.first; oitIt != outRange.second; ++oitIt) { - EdgeWeight const outWeight = currentContext.GetAdjacencyCost(iit, oit); + EdgeWeight const outWeight = currentContext.GetAdjacencyCost(inIt, oitIt); if (outWeight != INVALID_CONTEXT_EDGE_WEIGHT && outWeight != 0) { - TCrossPair target = FindNextMwmNode(*oit, currentMapping); - if (target.second.IsValid()) + BorderCross target = FindNextMwmNode(*oitIt, currentMapping); + if (target.toNode.IsValid()) adj.emplace_back(target, outWeight); } } } -double CrossMwmGraph::HeuristicCostEstimateImpl(TCrossPair const & v, TCrossPair const & w) const +double CrossMwmGraph::HeuristicCostEstimateImpl(BorderCross const & v, BorderCross const & w) const { - return ms::DistanceOnEarth(v.second.point.y, v.second.point.x, - w.second.point.y, w.second.point.x) / kMediumSpeedMPS; + return ms::DistanceOnEarth(v.toNode.point.y, v.toNode.point.x, + w.toNode.point.y, w.toNode.point.x) / kMediumSpeedMPS; } } // namespace routing diff --git a/routing/cross_mwm_road_graph.hpp b/routing/cross_mwm_road_graph.hpp index e1ad47a000..e83c92dec1 100644 --- a/routing/cross_mwm_road_graph.hpp +++ b/routing/cross_mwm_road_graph.hpp @@ -4,10 +4,10 @@ #include "osrm_router.hpp" #include "router.hpp" -#include "base/graph.hpp" - #include "indexer/index.hpp" +#include "base/graph.hpp" + namespace routing { /// OSRM graph node representation with graph mwm name and border crossing point. @@ -21,6 +21,7 @@ struct CrossNode : node(node), mwmName(mwmName), point(point) { } + CrossNode() : node(INVALID_NODE_ID), point(m2::PointD::Zero()) {} inline bool IsValid() const { return node != INVALID_NODE_ID; } @@ -33,11 +34,9 @@ inline bool operator==(CrossNode const & a, CrossNode const & b) inline bool operator<(CrossNode const & a, CrossNode const & b) { - if (a.node < b.node) - return true; - else if (a.node == b.node) - return a.mwmName < b.mwmName; - return false; + if (a.node != b.node) + return a.node < b.node; + return a.mwmName < b.mwmName; } inline string DebugPrint(CrossNode const & t) @@ -48,16 +47,23 @@ inline string DebugPrint(CrossNode const & t) } /// Representation of border crossing. Contains node on previous map and node on next map. -using TCrossPair = pair; +struct BorderCross +{ + CrossNode fromNode; + CrossNode toNode; -inline bool operator==(TCrossPair const & a, TCrossPair const & b) { return a.first == b.first; } + BorderCross(CrossNode const & from, CrossNode const & to) : fromNode(from), toNode(to) {} + BorderCross() : fromNode(), toNode() {} +}; -inline bool operator<(TCrossPair const & a, TCrossPair const & b) { return a.first < b.first; } +inline bool operator==(BorderCross const & a, BorderCross const & b) { return a.toNode == b.toNode; } -inline string DebugPrint(TCrossPair const & t) +inline bool operator<(BorderCross const & a, BorderCross const & b) { return a.toNode < b.toNode; } + +inline string DebugPrint(BorderCross const & t) { ostringstream out; - out << "Border cross form: " << DebugPrint(t.first) << " to: " << DebugPrint(t.second) << "\n"; + out << "Border cross from: " << DebugPrint(t.fromNode) << " to: " << DebugPrint(t.toNode) << "\n"; return out.str(); } @@ -65,18 +71,18 @@ inline string DebugPrint(TCrossPair const & t) class CrossWeightedEdge { public: - explicit CrossWeightedEdge(TCrossPair const & target, double weight) : target(target), weight(weight) {} + CrossWeightedEdge(BorderCross const & target, double weight) : target(target), weight(weight) {} - inline TCrossPair const & GetTarget() const { return target; } + inline BorderCross const & GetTarget() const { return target; } inline double GetWeight() const { return weight; } private: - TCrossPair target; + BorderCross target; double weight; }; /// A graph used for cross mwm routing. -class CrossMwmGraph : public Graph +class CrossMwmGraph : public Graph { public: explicit CrossMwmGraph(RoutingIndexManager & indexManager) : m_indexManager(indexManager) {} @@ -85,19 +91,19 @@ public: IRouter::ResultCode SetFinalNode(CrossNode const & finalNode); private: - friend class Graph; + friend class Graph; - TCrossPair FindNextMwmNode(OutgoingCrossNode const & startNode, + BorderCross FindNextMwmNode(OutgoingCrossNode const & startNode, TRoutingMappingPtr const & currentMapping) const; - // Graph implementation: - void GetOutgoingEdgesListImpl(TCrossPair const & v, vector & adj) const; - void GetIngoingEdgesListImpl(TCrossPair const & v, vector & adj) const + // Graph implementation: + void GetOutgoingEdgesListImpl(BorderCross const & v, vector & adj) const; + void GetIngoingEdgesListImpl(BorderCross const & v, vector & adj) const { ASSERT(!"IMPL", ()); } - double HeuristicCostEstimateImpl(TCrossPair const & v, TCrossPair const & w) const; + double HeuristicCostEstimateImpl(BorderCross const & v, BorderCross const & w) const; map > m_virtualEdges; mutable RoutingIndexManager m_indexManager; diff --git a/routing/cross_mwm_router.cpp b/routing/cross_mwm_router.cpp index 48ec8e3691..592c6bfc1c 100644 --- a/routing/cross_mwm_router.cpp +++ b/routing/cross_mwm_router.cpp @@ -7,8 +7,8 @@ namespace routing using TAlgorithm = AStarAlgorithm; /// Function to run AStar Algorithm from the base. -IRouter::ResultCode CalculateRoute(TCrossPair const & startPos, TCrossPair const & finalPos, - CrossMwmGraph const & roadGraph, vector & route, +IRouter::ResultCode CalculateRoute(BorderCross const & startPos, BorderCross const & finalPos, + CrossMwmGraph const & roadGraph, vector & route, RoutingVisualizerFn const & routingVisualizer) { TAlgorithm m_algo; @@ -17,9 +17,9 @@ IRouter::ResultCode CalculateRoute(TCrossPair const & startPos, TCrossPair const TAlgorithm::OnVisitedVertexCallback onVisitedVertex = nullptr; if (routingVisualizer) { - onVisitedVertex = [&routingVisualizer](TCrossPair const & cross) + onVisitedVertex = [&routingVisualizer](BorderCross const & cross) { - routingVisualizer(cross.first.point); + routingVisualizer(cross.fromNode.point); }; } @@ -79,7 +79,7 @@ IRouter::ResultCode CalculateCrossMwmPath(TRoutingNodes const & startGraphNodes, return IRouter::EndPointNotFound; // Finding path through maps. - vector tempRoad; + vector tempRoad; code = CalculateRoute({startNode, startNode}, {finalNode, finalNode}, roadGraph, tempRoad, routingVisualizer); if (code != IRouter::NoError) @@ -88,8 +88,8 @@ IRouter::ResultCode CalculateCrossMwmPath(TRoutingNodes const & startGraphNodes, // Final path conversion to output type. for (size_t i = 0; i < tempRoad.size() - 1; ++i) { - route.emplace_back(tempRoad[i].second.node, tempRoad[i + 1].first.node, - tempRoad[i].second.mwmName); + route.emplace_back(tempRoad[i].toNode.node, tempRoad[i + 1].fromNode.node, + tempRoad[i].toNode.mwmName); } if (!route.empty())