From a827d46b92ce535da1aa54854daa0d5deefb2185 Mon Sep 17 00:00:00 2001 From: tatiana-kondakova Date: Mon, 18 Sep 2017 13:31:01 +0300 Subject: [PATCH] Review fixes. Do not use non-transit features for transit --- routing/base/astar_algorithm.hpp | 22 ++++++------ routing/base/routing_result.hpp | 16 +++++---- routing/cross_mwm_router.cpp | 8 ++--- routing/index_graph.cpp | 11 +++--- routing/index_graph_starter.cpp | 20 ++++++----- routing/index_graph_starter.hpp | 4 +-- routing/index_router.cpp | 34 +++++++++---------- routing/road_graph_router.cpp | 14 ++++---- routing/route_weight.hpp | 24 ++++++++----- .../routing_tests/astar_algorithm_test.cpp | 18 +++++----- routing/routing_tests/astar_router_test.cpp | 30 ++++++++-------- routing/routing_tests/index_graph_tools.cpp | 19 +++++++---- routing/routing_tests/index_graph_tools.hpp | 4 ++- routing/routing_tests/restriction_test.cpp | 18 +++++----- routing/world_graph.cpp | 4 +-- 15 files changed, 134 insertions(+), 112 deletions(-) diff --git a/routing/base/astar_algorithm.hpp b/routing/base/astar_algorithm.hpp index 6fd675db9d..0926fde12a 100644 --- a/routing/base/astar_algorithm.hpp +++ b/routing/base/astar_algorithm.hpp @@ -357,8 +357,8 @@ typename AStarAlgorithm::Result AStarAlgorithm::FindPath( if (resultCode == Result::OK) { - context.ReconstructPath(finalVertex, result.path); - result.distance = + context.ReconstructPath(finalVertex, result.m_path); + result.m_distance = context.GetDistance(finalVertex) - graph.HeuristicCostEstimate(startVertex, finalVertex); } @@ -433,11 +433,11 @@ typename AStarAlgorithm::Result AStarAlgorithm::FindPathBidirect if (curTop + nxtTop >= bestPathReducedLength - kEpsilon) { ReconstructPathBidirectional(cur->bestVertex, nxt->bestVertex, cur->parent, nxt->parent, - result.path); - result.distance = bestPathRealLength; - CHECK(!result.path.empty(), ()); + result.m_path); + result.m_distance = bestPathRealLength; + CHECK(!result.m_path.empty(), ()); if (!cur->forward) - reverse(result.path.begin(), result.path.end()); + reverse(result.m_path.begin(), result.m_path.end()); return Result::OK; } } @@ -564,7 +564,7 @@ typename AStarAlgorithm::Result AStarAlgorithm::AdjustRoute( if (minDistance == kInfiniteDistance) return Result::NoPath; - context.ReconstructPath(returnVertex, result.path); + context.ReconstructPath(returnVertex, result.m_path); // Append remaining route. bool found = false; @@ -573,19 +573,19 @@ typename AStarAlgorithm::Result AStarAlgorithm::AdjustRoute( if (prevRoute[i].GetTarget() == returnVertex) { for (size_t j = i + 1; j < prevRoute.size(); ++j) - result.path.push_back(prevRoute[j].GetTarget()); + result.m_path.push_back(prevRoute[j].GetTarget()); found = true; break; } } - CHECK(found, - ("Can't find", returnVertex, ", prev:", prevRoute.size(), ", adjust:", result.path.size())); + CHECK(found, ("Can't find", returnVertex, ", prev:", prevRoute.size(), + ", adjust:", result.m_path.size())); auto const & it = remainingDistances.find(returnVertex); CHECK(it != remainingDistances.end(), ()); - result.distance = context.GetDistance(returnVertex) + it->second; + result.m_distance = context.GetDistance(returnVertex) + it->second; return Result::OK; } diff --git a/routing/base/routing_result.hpp b/routing/base/routing_result.hpp index ec2837ffb2..0cdcadb696 100644 --- a/routing/base/routing_result.hpp +++ b/routing/base/routing_result.hpp @@ -6,16 +6,18 @@ namespace routing { -template -struct RoutingResult +template +struct RoutingResult final { - std::vector path; - TWeightType distance; - RoutingResult() : distance(GetAStarWeightZero()) {} + RoutingResult() : m_distance(GetAStarWeightZero()) {} + void Clear() { - path.clear(); - distance = GetAStarWeightZero(); + m_path.clear(); + m_distance = GetAStarWeightZero(); } + + std::vector m_path; + WeightType m_distance; }; } // namespace routing diff --git a/routing/cross_mwm_router.cpp b/routing/cross_mwm_router.cpp index 5a04b2e314..8c012ac179 100644 --- a/routing/cross_mwm_router.cpp +++ b/routing/cross_mwm_router.cpp @@ -31,8 +31,8 @@ IRouter::ResultCode CalculateRoute(BorderCross const & startPos, BorderCross con switch (result) { case TAlgorithm::Result::OK: - ASSERT_EQUAL(route.path.front(), startPos, ()); - ASSERT_EQUAL(route.path.back(), finalPos, ()); + ASSERT_EQUAL(route.m_path.front(), startPos, ()); + ASSERT_EQUAL(route.m_path.back(), finalPos, ()); return IRouter::NoError; case TAlgorithm::Result::NoPath: return IRouter::RouteNotFound; @@ -93,14 +93,14 @@ IRouter::ResultCode CalculateCrossMwmPath(TRoutingNodes const & startGraphNodes, // Finding path through maps. RoutingResult tempRoad; code = CalculateRoute({startNode, startNode}, {finalNode, finalNode}, roadGraph, delegate, tempRoad); - cost = tempRoad.distance; + cost = tempRoad.m_distance; if (code != IRouter::NoError) return code; if (delegate.IsCancelled()) return IRouter::Cancelled; // Final path conversion to output type. - ConvertToSingleRouterTasks(tempRoad.path, startGraphNode, finalGraphNode, route); + ConvertToSingleRouterTasks(tempRoad.m_path, startGraphNode, finalGraphNode, route); return route.empty() ? IRouter::RouteNotFound : IRouter::NoError; } diff --git a/routing/index_graph.cpp b/routing/index_graph.cpp index 013576e364..9fad353c3e 100644 --- a/routing/index_graph.cpp +++ b/routing/index_graph.cpp @@ -113,13 +113,14 @@ RouteWeight IndexGraph::HeuristicCostEstimate(Segment const & from, Segment cons { return RouteWeight( m_estimator->CalcHeuristic(GetPoint(from, true /* front */), GetPoint(to, true /* front */)), - 0); + 0 /* nontransitCross */); } RouteWeight IndexGraph::CalcSegmentWeight(Segment const & segment) { return RouteWeight( - m_estimator->CalcSegmentWeight(segment, m_geometry.GetRoad(segment.GetFeatureId())), 0); + m_estimator->CalcSegmentWeight(segment, m_geometry.GetRoad(segment.GetFeatureId())), + 0 /* nontransitCross */); } void IndexGraph::GetNeighboringEdges(Segment const & from, RoadPoint const & rp, bool isOutgoing, @@ -171,10 +172,10 @@ void IndexGraph::GetNeighboringEdge(Segment const & from, Segment const & to, bo RouteWeight IndexGraph::GetPenalties(Segment const & u, Segment const & v) { - bool fromTransitAllowed = m_geometry.GetRoad(u.GetFeatureId()).IsTransitAllowed(); - bool toTransitAllowed = m_geometry.GetRoad(v.GetFeatureId()).IsTransitAllowed(); + bool const fromTransitAllowed = m_geometry.GetRoad(u.GetFeatureId()).IsTransitAllowed(); + bool const toTransitAllowed = m_geometry.GetRoad(v.GetFeatureId()).IsTransitAllowed(); - uint32_t transitPenalty = fromTransitAllowed == toTransitAllowed ? 0 : 1; + uint32_t const transitPenalty = fromTransitAllowed == toTransitAllowed ? 0 : 1; if (IsUTurn(u, v)) return RouteWeight(m_estimator->GetUTurnPenalty(), transitPenalty); diff --git a/routing/index_graph_starter.cpp b/routing/index_graph_starter.cpp index 046143dd09..574809f9e4 100644 --- a/routing/index_graph_starter.cpp +++ b/routing/index_graph_starter.cpp @@ -214,7 +214,7 @@ set IndexGraphStarter::GetMwms() const return mwms; } -bool IndexGraphStarter::CheckRoutingResultMeetsRestrictions( +bool IndexGraphStarter::DoesRouteCrossNontransit( RoutingResult const & result) const { uint32_t nontransitCrossAllowed = 0; @@ -230,20 +230,20 @@ bool IndexGraphStarter::CheckRoutingResultMeetsRestrictions( return m_graph.GetRoadGeometry(real.GetMwmId(), real.GetFeatureId()).IsTransitAllowed(); }; - auto const firstRealOrPart = find_if(result.path.begin(), result.path.end(), isRealOrPart); - if (firstRealOrPart != result.path.end() && !isTransitAllowed(*firstRealOrPart)) + auto const firstRealOrPart = find_if(result.m_path.begin(), result.m_path.end(), isRealOrPart); + if (firstRealOrPart != result.m_path.end() && !isTransitAllowed(*firstRealOrPart)) ++nontransitCrossAllowed; - auto const lastRealOrPart = find_if(result.path.rbegin(), result.path.rend(), isRealOrPart); + auto const lastRealOrPart = find_if(result.m_path.rbegin(), result.m_path.rend(), isRealOrPart); // If firstRealOrPart and lastRealOrPart point to the same segment increment // nontransitCrossAllowed once - if (lastRealOrPart != result.path.rend() && (lastRealOrPart.base() - 1) != firstRealOrPart && + if (lastRealOrPart != result.m_path.rend() && &*lastRealOrPart != &*firstRealOrPart && !isTransitAllowed(*lastRealOrPart)) { ++nontransitCrossAllowed; } - return nontransitCrossAllowed >= result.distance.GetNontransitCross(); + return nontransitCrossAllowed < result.m_distance.GetNontransitCross(); } void IndexGraphStarter::GetEdgesList(Segment const & segment, bool isOutgoing, @@ -288,7 +288,7 @@ RouteWeight IndexGraphStarter::CalcSegmentWeight(Segment const & segment) const return RouteWeight( m_graph.GetEstimator().CalcSegmentWeight( segment, m_graph.GetRoadGeometry(segment.GetMwmId(), segment.GetFeatureId())), - 0); + 0 /* nontransitCross */); } auto const fakeVertexIt = m_fake.m_segmentToVertex.find(segment); @@ -297,7 +297,7 @@ RouteWeight IndexGraphStarter::CalcSegmentWeight(Segment const & segment) const ("Requested junction for invalid fake segment.")); return RouteWeight(m_graph.GetEstimator().CalcLeapWeight(fakeVertexIt->second.GetPointFrom(), fakeVertexIt->second.GetPointTo()), - 0); + 0 /* nontransitCross */); } RouteWeight IndexGraphStarter::CalcRouteSegmentWeight(vector const & route, @@ -418,7 +418,9 @@ void IndexGraphStarter::AddStart(FakeEnding const & startEnding, FakeEnding cons // Check fake segment is connected to source segment. if (GetJunction(s, false /* front */) == GetJunction(segment, true) || GetJunction(s, true) == GetJunction(segment, false)) + { fakeEdges.emplace_back(s, edge.GetWeight()); + } } } edges.insert(edges.end(), fakeEdges.begin(), fakeEdges.end()); @@ -452,7 +454,7 @@ void IndexGraphStarter::ConnectLeapToTransitions(Segment const & segment, bool i edges.emplace_back(transition, RouteWeight(m_graph.GetEstimator().CalcLeapWeight( segmentPoint, GetPoint(transition, isOutgoing)), - 0)); + 0 /* nontransitCross */)); }); } diff --git a/routing/index_graph_starter.hpp b/routing/index_graph_starter.hpp index 2e9967809b..a0bca0963e 100644 --- a/routing/index_graph_starter.hpp +++ b/routing/index_graph_starter.hpp @@ -86,7 +86,7 @@ public: // Checks |result| meets nontransit crossing restrictions according to placement of // |result.path| start and finish in transit/nontransit area and number of nontransit crosses - bool CheckRoutingResultMeetsRestrictions( + bool DoesRouteCrossNontransit( RoutingResult const & result) const; void GetEdgesList(Segment const & segment, bool isOutgoing, @@ -106,7 +106,7 @@ public: { return RouteWeight(m_graph.GetEstimator().CalcHeuristic(GetPoint(from, true /* front */), GetPoint(to, true /* front */)), - 0); + 0 /* nontransitCross */); } RouteWeight CalcSegmentWeight(Segment const & segment) const; diff --git a/routing/index_router.cpp b/routing/index_router.cpp index 8ff50d8e64..4eee3c1aa8 100644 --- a/routing/index_router.cpp +++ b/routing/index_router.cpp @@ -533,15 +533,15 @@ IRouter::ResultCode IndexRouter::CalculateSubroute(Checkpoints const & checkpoin if (result != IRouter::NoError) return result; - if (!starter.CheckRoutingResultMeetsRestrictions(routingResult)) + if (starter.DoesRouteCrossNontransit(routingResult)) return IRouter::RouteNotFound; IRouter::ResultCode const leapsResult = - ProcessLeaps(routingResult.path, delegate, starter.GetGraph().GetMode(), starter, subroute); + ProcessLeaps(routingResult.m_path, delegate, starter.GetGraph().GetMode(), starter, subroute); if (leapsResult != IRouter::NoError) return leapsResult; - CHECK_GREATER_OR_EQUAL(subroute.size(), routingResult.path.size(), ()); + CHECK_GREATER_OR_EQUAL(subroute.size(), routingResult.m_path.size(), ()); return IRouter::NoError; } @@ -604,20 +604,20 @@ IRouter::ResultCode IndexRouter::AdjustRoute(Checkpoints const & checkpoints, AStarAlgorithm algorithm; RoutingResult result; - auto resultCode = ConvertResult( - algorithm.AdjustRoute(starter, starter.GetStartSegment(), prevEdges, - RouteWeight(kAdjustLimitSec, 0), result, delegate, onVisitJunction)); + auto resultCode = ConvertResult(algorithm.AdjustRoute( + starter, starter.GetStartSegment(), prevEdges, + RouteWeight(kAdjustLimitSec, 0 /* nontransitCross */), result, delegate, onVisitJunction)); if (resultCode != IRouter::NoError) return resultCode; - CHECK_GREATER_OR_EQUAL(result.path.size(), 2, ()); - CHECK(IndexGraphStarter::IsFakeSegment(result.path.front()), ()); - CHECK(IndexGraphStarter::IsFakeSegment(result.path.back()), ()); + CHECK_GREATER_OR_EQUAL(result.m_path.size(), 2, ()); + CHECK(IndexGraphStarter::IsFakeSegment(result.m_path.front()), ()); + CHECK(IndexGraphStarter::IsFakeSegment(result.m_path.back()), ()); vector subroutes; PushPassedSubroutes(checkpoints, subroutes); - size_t subrouteOffset = result.path.size(); + size_t subrouteOffset = result.m_path.size(); subroutes.emplace_back(starter.GetStartJunction(), starter.GetFinishJunction(), 0 /* beginSegmentIdx */, subrouteOffset); @@ -626,23 +626,23 @@ IRouter::ResultCode IndexRouter::AdjustRoute(Checkpoints const & checkpoints, auto const & subroute = lastSubroutes[i]; for (size_t j = subroute.GetBeginSegmentIdx(); j < subroute.GetEndSegmentIdx(); ++j) - result.path.push_back(steps[j].GetSegment()); + result.m_path.push_back(steps[j].GetSegment()); subroutes.emplace_back(subroute, subrouteOffset); subrouteOffset = subroutes.back().GetEndSegmentIdx(); } - CHECK_EQUAL(result.path.size(), subrouteOffset, ()); + CHECK_EQUAL(result.m_path.size(), subrouteOffset, ()); route.SetCurrentSubrouteIdx(checkpoints.GetPassedIdx()); route.SetSubroteAttrs(move(subroutes)); - auto const redressResult = RedressRoute(result.path, delegate, starter, route); + auto const redressResult = RedressRoute(result.m_path, delegate, starter, route); if (redressResult != IRouter::NoError) return redressResult; LOG(LINFO, ("Adjust route, elapsed:", timer.ElapsedSeconds(), ", prev start:", checkpoints, - ", prev route:", steps.size(), ", new route:", result.path.size())); + ", prev route:", steps.size(), ", new route:", result.m_path.size())); return IRouter::NoError; } @@ -757,10 +757,10 @@ IRouter::ResultCode IndexRouter::ProcessLeaps(vector const & input, // Start and finish segments may be changed by starter.ConvertToReal. It was necessary to use it // in worldGraph but we need to reset them to original values. - routingResult.path.front() = input[i - 1]; - routingResult.path.back() = input[i]; + routingResult.m_path.front() = input[i - 1]; + routingResult.m_path.back() = input[i]; - output.insert(output.end(), routingResult.path.cbegin(), routingResult.path.cend()); + output.insert(output.end(), routingResult.m_path.cbegin(), routingResult.m_path.cend()); } return IRouter::NoError; diff --git a/routing/road_graph_router.cpp b/routing/road_graph_router.cpp index 28366ab4fa..16b640b24d 100644 --- a/routing/road_graph_router.cpp +++ b/routing/road_graph_router.cpp @@ -199,19 +199,19 @@ IRouter::ResultCode RoadGraphRouter::CalculateRoute(Checkpoints const & checkpoi if (resultCode == IRoutingAlgorithm::Result::OK) { - ASSERT(!result.path.empty(), ()); - ASSERT_EQUAL(result.path.front(), startPos, ()); - ASSERT_EQUAL(result.path.back(), finalPos, ()); - ASSERT_GREATER(result.distance, 0., ()); + ASSERT(!result.m_path.empty(), ()); + ASSERT_EQUAL(result.m_path.front(), startPos, ()); + ASSERT_EQUAL(result.m_path.back(), finalPos, ()); + ASSERT_GREATER(result.m_distance, 0., ()); Route::TTimes times; - CalculateMaxSpeedTimes(*m_roadGraph, result.path, times); + CalculateMaxSpeedTimes(*m_roadGraph, result.m_path, times); CHECK(m_directionsEngine, ()); route.SetSubroteAttrs(vector( - {Route::SubrouteAttrs(startPos, finalPos, 0, result.path.size() - 1)})); + {Route::SubrouteAttrs(startPos, finalPos, 0, result.m_path.size() - 1)})); ReconstructRoute(*m_directionsEngine, *m_roadGraph, nullptr /* trafficStash */, delegate, - result.path, std::move(times), route); + result.m_path, std::move(times), route); } m_roadGraph->ResetFakes(); diff --git a/routing/route_weight.hpp b/routing/route_weight.hpp index 0119ae3957..e6d7dfa8d2 100644 --- a/routing/route_weight.hpp +++ b/routing/route_weight.hpp @@ -2,7 +2,6 @@ #include "routing/base/astar_weight.hpp" -#include #include #include @@ -13,15 +12,19 @@ class RouteWeight final public: RouteWeight() = default; - constexpr RouteWeight(double weight, int32_t nontransitCross) + constexpr RouteWeight(double weight, int nontransitCross) : m_weight(weight), m_nontransitCross(nontransitCross) { } - double GetWeight() const { return m_weight; } - int32_t GetNontransitCross() const { return m_nontransitCross; } - static RouteWeight FromCrossMwmWeight(double weight) { return RouteWeight(weight, 0); } + static RouteWeight FromCrossMwmWeight(double weight) + { + return RouteWeight(weight, 0 /* nontransitCross */); + } + double ToCrossMwmWeight() const; + double GetWeight() const { return m_weight; } + int GetNontransitCross() const { return m_nontransitCross; } bool operator<(RouteWeight const & rhs) const { @@ -58,8 +61,10 @@ public: RouteWeight operator-() const { return RouteWeight(-m_weight, -m_nontransitCross); } private: + // Regular weight (seconds). double m_weight = 0.0; - int32_t m_nontransitCross = 0; + // Number of transit/nontransit area border cross. + int m_nontransitCross = 0; }; std::ostream & operator<<(std::ostream & os, RouteWeight const & routeWeight); @@ -69,19 +74,20 @@ RouteWeight operator*(double lhs, RouteWeight const & rhs); template <> constexpr RouteWeight GetAStarWeightMax() { - return RouteWeight(std::numeric_limits::max(), std::numeric_limits::max()); + return RouteWeight(std::numeric_limits::max() /* weight */, + std::numeric_limits::max() /* nontransitCross */); } template <> constexpr RouteWeight GetAStarWeightZero() { - return RouteWeight(0.0, 0); + return RouteWeight(0.0 /* weight */, 0 /* nontransitCross */); } template <> constexpr RouteWeight GetAStarWeightEpsilon() { - return RouteWeight(GetAStarWeightEpsilon(), 0); + return RouteWeight(GetAStarWeightEpsilon(), 0 /* nontransitCross */); } } // namespace routing diff --git a/routing/routing_tests/astar_algorithm_test.cpp b/routing/routing_tests/astar_algorithm_test.cpp index cdcc237247..5dcb3035ee 100644 --- a/routing/routing_tests/astar_algorithm_test.cpp +++ b/routing/routing_tests/astar_algorithm_test.cpp @@ -68,13 +68,13 @@ void TestAStar(UndirectedGraph & graph, vector const & expectedRoute, RoutingResult actualRoute; TEST_EQUAL(TAlgorithm::Result::OK, algo.FindPath(graph, 0u, 4u, actualRoute), ()); - TEST_EQUAL(expectedRoute, actualRoute.path, ()); - TEST_ALMOST_EQUAL_ULPS(expectedDistance, actualRoute.distance, ()); + TEST_EQUAL(expectedRoute, actualRoute.m_path, ()); + TEST_ALMOST_EQUAL_ULPS(expectedDistance, actualRoute.m_distance, ()); - actualRoute.path.clear(); + actualRoute.m_path.clear(); TEST_EQUAL(TAlgorithm::Result::OK, algo.FindPathBidirectional(graph, 0u, 4u, actualRoute), ()); - TEST_EQUAL(expectedRoute, actualRoute.path, ()); - TEST_ALMOST_EQUAL_ULPS(expectedDistance, actualRoute.distance, ()); + TEST_EQUAL(expectedRoute, actualRoute.m_path, ()); + TEST_ALMOST_EQUAL_ULPS(expectedDistance, actualRoute.m_distance, ()); } UNIT_TEST(AStarAlgorithm_Sample) @@ -114,8 +114,8 @@ UNIT_TEST(AdjustRoute) vector const expectedRoute = {6, 2, 3, 4, 5}; TEST_EQUAL(code, TAlgorithm::Result::OK, ()); - TEST_EQUAL(result.path, expectedRoute, ()); - TEST_EQUAL(result.distance, 4.0, ()); + TEST_EQUAL(result.m_path, expectedRoute, ()); + TEST_EQUAL(result.m_distance, 4.0, ()); } UNIT_TEST(AdjustRouteNoPath) @@ -134,7 +134,7 @@ UNIT_TEST(AdjustRouteNoPath) my::Cancellable(), nullptr /* onVisitedVertexCallback */); TEST_EQUAL(code, TAlgorithm::Result::NoPath, ()); - TEST(result.path.empty(), ()); + TEST(result.m_path.empty(), ()); } UNIT_TEST(AdjustRouteOutOfLimit) @@ -155,6 +155,6 @@ UNIT_TEST(AdjustRouteOutOfLimit) my::Cancellable(), nullptr /* onVisitedVertexCallback */); TEST_EQUAL(code, TAlgorithm::Result::NoPath, ()); - TEST(result.path.empty(), ()); + TEST(result.m_path.empty(), ()); } } // namespace routing_test diff --git a/routing/routing_tests/astar_router_test.cpp b/routing/routing_tests/astar_router_test.cpp index 516e479dc0..0127a0485e 100644 --- a/routing/routing_tests/astar_router_test.cpp +++ b/routing/routing_tests/astar_router_test.cpp @@ -35,7 +35,7 @@ void TestAStarRouterMock(Junction const & startPos, Junction const & finalPos, TEST_EQUAL(TRoutingAlgorithm::Result::OK, algorithm.CalculateRoute(graph, startPos, finalPos, delegate, result), ()); - TEST_EQUAL(expected, result.path, ()); + TEST_EQUAL(expected, result.m_path, ()); } void AddRoad(RoadGraphMockSource & graph, double speedKMPH, initializer_list const & points) @@ -103,7 +103,7 @@ UNIT_TEST(AStarRouter_SimpleGraph_RouteIsFound) TEST_EQUAL(TRoutingAlgorithm::Result::OK, algorithm.CalculateRoute(graph, startPos, finalPos, delegate, result), ()); - TEST_EQUAL(expected, result.path, ()); + TEST_EQUAL(expected, result.m_path, ()); } UNIT_TEST(AStarRouter_SimpleGraph_RoutesInConnectedComponents) @@ -234,14 +234,14 @@ UNIT_TEST(AStarRouter_SimpleGraph_PickTheFasterRoad1) MakeJunctionForTesting(m2::PointD(10, 2)), delegate, result), ()); TEST_EQUAL( - result.path, + result.m_path, vector( {MakeJunctionForTesting(m2::PointD(2, 2)), MakeJunctionForTesting(m2::PointD(2, 3)), MakeJunctionForTesting(m2::PointD(4, 3)), MakeJunctionForTesting(m2::PointD(6, 3)), MakeJunctionForTesting(m2::PointD(8, 3)), MakeJunctionForTesting(m2::PointD(10, 3)), MakeJunctionForTesting(m2::PointD(10, 2))}), ()); - TEST(my::AlmostEqualAbs(result.distance, 800451., 1.), ("Distance error:", result.distance)); + TEST(my::AlmostEqualAbs(result.m_distance, 800451., 1.), ("Distance error:", result.m_distance)); } UNIT_TEST(AStarRouter_SimpleGraph_PickTheFasterRoad2) @@ -268,11 +268,12 @@ UNIT_TEST(AStarRouter_SimpleGraph_PickTheFasterRoad2) algorithm.CalculateRoute(graph, MakeJunctionForTesting(m2::PointD(2, 2)), MakeJunctionForTesting(m2::PointD(10, 2)), delegate, result), ()); - TEST_EQUAL(result.path, vector({MakeJunctionForTesting(m2::PointD(2, 2)), - MakeJunctionForTesting(m2::PointD(6, 2)), - MakeJunctionForTesting(m2::PointD(10, 2))}), + TEST_EQUAL(result.m_path, + vector({MakeJunctionForTesting(m2::PointD(2, 2)), + MakeJunctionForTesting(m2::PointD(6, 2)), + MakeJunctionForTesting(m2::PointD(10, 2))}), ()); - TEST(my::AlmostEqualAbs(result.distance, 781458., 1.), ("Distance error:", result.distance)); + TEST(my::AlmostEqualAbs(result.m_distance, 781458., 1.), ("Distance error:", result.m_distance)); } UNIT_TEST(AStarRouter_SimpleGraph_PickTheFasterRoad3) @@ -299,10 +300,11 @@ UNIT_TEST(AStarRouter_SimpleGraph_PickTheFasterRoad3) algorithm.CalculateRoute(graph, MakeJunctionForTesting(m2::PointD(2, 2)), MakeJunctionForTesting(m2::PointD(10, 2)), delegate, result), ()); - TEST_EQUAL(result.path, vector({MakeJunctionForTesting(m2::PointD(2, 2)), - MakeJunctionForTesting(m2::PointD(2, 1)), - MakeJunctionForTesting(m2::PointD(10, 1)), - MakeJunctionForTesting(m2::PointD(10, 2))}), - ()); - TEST(my::AlmostEqualAbs(result.distance, 814412., 1.), ("Distance error:", result.distance)); + TEST_EQUAL( + result.m_path, + vector( + {MakeJunctionForTesting(m2::PointD(2, 2)), MakeJunctionForTesting(m2::PointD(2, 1)), + MakeJunctionForTesting(m2::PointD(10, 1)), MakeJunctionForTesting(m2::PointD(10, 2))}), + ()); + TEST(my::AlmostEqualAbs(result.m_distance, 814412., 1.), ("Distance error:", result.m_distance)); } diff --git a/routing/routing_tests/index_graph_tools.cpp b/routing/routing_tests/index_graph_tools.cpp index 3cf02c754e..f5635442e7 100644 --- a/routing/routing_tests/index_graph_tools.cpp +++ b/routing/routing_tests/index_graph_tools.cpp @@ -23,11 +23,18 @@ void TestGeometryLoader::Load(uint32_t featureId, RoadGeometry & road) } void TestGeometryLoader::AddRoad(uint32_t featureId, bool oneWay, float speed, - RoadGeometry::Points const & points, bool transitAllowed) + RoadGeometry::Points const & points) { auto it = m_roads.find(featureId); CHECK(it == m_roads.end(), ("Already contains feature", featureId)); m_roads[featureId] = RoadGeometry(oneWay, speed, points); + m_roads[featureId].SetTransitAllowedForTests(true); +} + +void TestGeometryLoader::SetTransitAllowed(uint32_t featureId, bool transitAllowed) +{ + auto it = m_roads.find(featureId); + CHECK(it != m_roads.end(), ("No feature", featureId)); m_roads[featureId].SetTransitAllowedForTests(transitAllowed); } @@ -286,15 +293,15 @@ AStarAlgorithm::Result CalculateRoute(IndexGraphStarter & sta AStarAlgorithm algorithm; RoutingResult routingResult; - auto const resultCode = algorithm.FindPathBidirectional( + auto resultCode = algorithm.FindPathBidirectional( starter, starter.GetStartSegment(), starter.GetFinishSegment(), routingResult, {} /* cancellable */, {} /* onVisitedVertexCallback */); - if (!starter.CheckRoutingResultMeetsRestrictions(routingResult)) - resultCode == AStarAlgorithm::Result::NoPath; + if (starter.DoesRouteCrossNontransit(routingResult)) + resultCode = AStarAlgorithm::Result::NoPath; - timeSec = routingResult.distance.GetWeight(); - roadPoints = routingResult.path; + timeSec = routingResult.m_distance.GetWeight(); + roadPoints = routingResult.m_path; return resultCode; } diff --git a/routing/routing_tests/index_graph_tools.hpp b/routing/routing_tests/index_graph_tools.hpp index 520411a7df..35729233be 100644 --- a/routing/routing_tests/index_graph_tools.hpp +++ b/routing/routing_tests/index_graph_tools.hpp @@ -62,7 +62,9 @@ public: void Load(uint32_t featureId, routing::RoadGeometry & road) override; void AddRoad(uint32_t featureId, bool oneWay, float speed, - routing::RoadGeometry::Points const & points, bool transitAllowed = true); + routing::RoadGeometry::Points const & points); + + void SetTransitAllowed(uint32_t featureId, bool transitAllowed); private: unordered_map m_roads; diff --git a/routing/routing_tests/restriction_test.cpp b/routing/routing_tests/restriction_test.cpp index e1e3a12089..d9291bf95c 100644 --- a/routing/routing_tests/restriction_test.cpp +++ b/routing/routing_tests/restriction_test.cpp @@ -908,20 +908,20 @@ unique_ptr BuildNontransitGraph(bool transitStart, bool transitShort { unique_ptr loader = make_unique(); loader->AddRoad(0 /* feature id */, false /* one way */, 1.0 /* speed */, - RoadGeometry::Points({{0.0, 0.0}, {1.0, 0.0}}), - transitStart /* transitAllowed */); + RoadGeometry::Points({{0.0, 0.0}, {1.0, 0.0}})); + loader->SetTransitAllowed(0 /* feature id */, transitStart); loader->AddRoad(1 /* feature id */, false /* one way */, 1.0 /* speed */, - RoadGeometry::Points({{1.0, 0.0}, {2.0, 0.0}}), - transitShortWay /* transitAllowed */); + RoadGeometry::Points({{1.0, 0.0}, {2.0, 0.0}})); + loader->SetTransitAllowed(1 /* feature id */, transitShortWay); loader->AddRoad(2 /* feature id */, false /* one way */, 1.0 /* speed */, - RoadGeometry::Points({{2.0, 0.0}, {3.0, 0.0}}), true /* transitAllowed */); + RoadGeometry::Points({{2.0, 0.0}, {3.0, 0.0}})); loader->AddRoad(3 /* feature id */, false /* one way */, 1.0 /* speed */, - RoadGeometry::Points({{1.0, 0.0}, {1.0, 1.0}}), true /* transitAllowed */); + RoadGeometry::Points({{1.0, 0.0}, {1.0, 1.0}})); loader->AddRoad(4 /* feature id */, false /* one way */, 1.0 /* speed */, - RoadGeometry::Points({{1.0, 1.0}, {2.0, 1.0}}), - transitLongWay /* transitAllowed */); + RoadGeometry::Points({{1.0, 1.0}, {2.0, 1.0}})); + loader->SetTransitAllowed(4 /* feature id */, transitLongWay); loader->AddRoad(5 /* feature id */, false /* one way */, 1.0 /* speed */, - RoadGeometry::Points({{2.0, 1.0}, {2.0, 0.0}}), true /* transitAllowed */); + RoadGeometry::Points({{2.0, 1.0}, {2.0, 0.0}})); vector const joints = { MakeJoint({{0 /* feature id */, 0 /* point id */}}), /* joint at point (0, 0) */ diff --git a/routing/world_graph.cpp b/routing/world_graph.cpp index 976ce62a4d..4082c6e355 100644 --- a/routing/world_graph.cpp +++ b/routing/world_graph.cpp @@ -64,7 +64,7 @@ RouteWeight WorldGraph::HeuristicCostEstimate(Segment const & from, Segment cons { return RouteWeight( m_estimator->CalcHeuristic(GetPoint(from, true /* front */), GetPoint(to, true /* front */)), - 0); + 0 /* nontransitCross */); } void WorldGraph::GetTwins(Segment const & segment, bool isOutgoing, vector & edges) @@ -76,7 +76,7 @@ void WorldGraph::GetTwins(Segment const & segment, bool isOutgoing, vectorCalcHeuristic(from, to); - edges.emplace_back(twin, RouteWeight(weight, 0)); + edges.emplace_back(twin, RouteWeight(weight, 0 /* nontransitCross */)); } }