AndrewShkrob/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

Gathering all routing traffic information in CarEdgeEstimator.

Browse source
This commit is contained in:
Vladimir Byko-Ianko 2016-12-02 14:41:43 +03:00
parent 3efa51d9a9
commit 388fa362a4
11 changed files with 122 additions and 61 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

37
routing/edge_estimator.cpp
View file

@ -1,5 +1,7 @@
#include "routing/edge_estimator.hpp"
#include "traffic/traffic_info.hpp"
#include "std/algorithm.hpp"
namespace routing
@ -19,22 +21,32 @@ inline double TimeBetweenSec(m2::PointD const & from, m2::PointD const & to, dou
class CarEdgeEstimator : public EdgeEstimator
{
public:
CarEdgeEstimator(IVehicleModel const & vehicleModel);
CarEdgeEstimator(IVehicleModel const & vehicleModel, traffic::TrafficInfoGetter const & getter);
// EdgeEstimator overrides:
void Start(MwmSet::MwmId const & mwmId) override;
double CalcEdgesWeight(uint32_t featureId, RoadGeometry const & road, uint32_t pointFrom,
uint32_t pointTo) const override;
double CalcHeuristic(m2::PointD const & from, m2::PointD const & to) const override;
void Finish() override;
private:
TrafficInfoGetter const & m_trafficGetter;
shared_ptr<traffic::TrafficInfo> m_trafficInfo;
double const m_maxSpeedMPS;
};
CarEdgeEstimator::CarEdgeEstimator(IVehicleModel const & vehicleModel)
: m_maxSpeedMPS(vehicleModel.GetMaxSpeed() * kKMPH2MPS)
CarEdgeEstimator::CarEdgeEstimator(IVehicleModel const & vehicleModel,
traffic::TrafficInfoGetter const & getter)
: m_trafficGetter(getter), m_maxSpeedMPS(vehicleModel.GetMaxSpeed() * kKMPH2MPS)
{
}
void CarEdgeEstimator::Start(MwmSet::MwmId const & mwmId)
{
m_trafficInfo = m_trafficGetter.GetTrafficInfo(mwmId);
}
double CarEdgeEstimator::CalcEdgesWeight(uint32_t featureId, RoadGeometry const & road,
uint32_t pointFrom, uint32_t pointTo) const
{
@ -44,8 +56,8 @@ double CarEdgeEstimator::CalcEdgesWeight(uint32_t featureId, RoadGeometry const
double result = 0.0;
double const speedMPS = road.GetSpeed() * kKMPH2MPS;
uint8_t const dir = pointFrom < pointTo ? TrafficInfo::RoadSegmentId::kForwardDirection
: TrafficInfo::RoadSegmentId::kReverseDirection;
auto const dir = pointFrom < pointTo ? TrafficInfo::RoadSegmentId::kForwardDirection
: TrafficInfo::RoadSegmentId::kReverseDirection;
for (uint32_t i = start; i < finish; ++i)
{
double factor = 1.0;
@ -68,18 +80,19 @@ double CarEdgeEstimator::CalcHeuristic(m2::PointD const & from, m2::PointD const
{
return TimeBetweenSec(from, to, m_maxSpeedMPS);
}
void CarEdgeEstimator::Finish()
{
m_trafficInfo.reset();
}
} // namespace
namespace routing
{
void EdgeEstimator::SetTrafficInfo(shared_ptr<traffic::TrafficInfo> trafficInfo)
{
m_trafficInfo = trafficInfo;
}
// static
shared_ptr<EdgeEstimator> EdgeEstimator::CreateForCar(IVehicleModel const & vehicleModel)
shared_ptr<EdgeEstimator> EdgeEstimator::CreateForCar(IVehicleModel const & vehicleModel,
traffic::TrafficInfoGetter const & getter)
{
return make_shared<CarEdgeEstimator>(vehicleModel);
return make_shared<CarEdgeEstimator>(vehicleModel, getter);
}
} // namespace routing

9
routing/edge_estimator.hpp
View file

@ -5,6 +5,8 @@
#include "traffic/traffic_info.hpp"
#include "indexer/mwm_set.hpp"
#include "geometry/point2d.hpp"
#include "std/cstdint.hpp"
@ -17,13 +19,16 @@ class EdgeEstimator
public:
virtual ~EdgeEstimator() = default;
virtual void Start(MwmSet::MwmId const & mwmId) = 0;
virtual double CalcEdgesWeight(uint32_t featureId, RoadGeometry const & road, uint32_t pointFrom,
uint32_t pointTo) const = 0;
virtual double CalcHeuristic(m2::PointD const & from, m2::PointD const & to) const = 0;
void SetTrafficInfo(shared_ptr<traffic::TrafficInfo> trafficInfo);
virtual void Finish() = 0;
static shared_ptr<EdgeEstimator> CreateForCar(IVehicleModel const & vehicleModel);
static shared_ptr<EdgeEstimator> CreateForCar(IVehicleModel const & vehicleModel,
traffic::TrafficInfoGetter const & getter);
protected:
shared_ptr<traffic::TrafficInfo> m_trafficInfo;

5
routing/routing_integration_tests/routing_test_tools.cpp
View file

@ -1,5 +1,7 @@
#include "routing/routing_integration_tests/routing_test_tools.hpp"
#include "routing/routing_tests/index_graph_tools.hpp"
#include "testing/testing.hpp"
#include "map/feature_vec_model.hpp"
@ -29,8 +31,8 @@
#include <sys/resource.h>
using namespace routing;
using namespace routing_test;
using TRouterFactory =
function<unique_ptr<IRouter>(Index & index, TCountryFileFn const & countryFileFn)>;
@ -112,6 +114,7 @@ namespace integration
}
IRouter * GetRouter() const override { return m_carRouter.get(); }
private:
TrafficInfoGetterTest m_trafficGetter;
unique_ptr<CarRouter> m_carRouter;

13
routing/routing_integration_tests/routing_test_tools.hpp
View file

@ -6,8 +6,6 @@
#include "map/feature_vec_model.hpp"
#include "traffic/traffic_info.hpp"
#include "platform/local_country_file.hpp"
#include "std/set.hpp"
@ -65,21 +63,12 @@ public:
virtual IRouter * GetRouter() const = 0;
storage::CountryInfoGetter const & GetCountryInfoGetter() const noexcept { return *m_infoGetter; }
protected:
shared_ptr<model::FeaturesFetcher> m_featuresFetcher;
unique_ptr<storage::CountryInfoGetter> m_infoGetter;
};
class TrafficInfoGetterTest : public traffic::TrafficInfoGetter
{
public:
// TrafficInfoGetter overrides:
shared_ptr<traffic::TrafficInfo> GetTrafficInfo(MwmSet::MwmId const & mwmId) const override
{
return shared_ptr<traffic::TrafficInfo>();
}
};
void TestOnlineCrosses(ms::LatLon const & startPoint, ms::LatLon const & finalPoint,
vector<string> const & expected, IRouterComponents & routerComponents);
void TestOnlineFetcher(ms::LatLon const & startPoint, ms::LatLon const & finalPoint,

54
routing/routing_tests/applying_traffic_test.cpp
View file

@ -85,22 +85,47 @@ unique_ptr<IndexGraph> BuildXXGraph(shared_ptr<EdgeEstimator> estimator)
return graph;
}
class TrafficInfoGetterTest : public TrafficInfoGetter
{
public:
TrafficInfoGetterTest(shared_ptr<TrafficInfo> trafficInfo = shared_ptr<TrafficInfo>())
: m_trafficInfo(trafficInfo) {}
// TrafficInfoGetter overrides:
shared_ptr<traffic::TrafficInfo> GetTrafficInfo(MwmSet::MwmId const &) const override
{
return m_trafficInfo;
}
private:
shared_ptr<TrafficInfo> m_trafficInfo;
};
class ApplyingTrafficTest
{
public:
ApplyingTrafficTest()
ApplyingTrafficTest() { classificator::Load(); }
void SetEstimator(TrafficInfo::Coloring && coloring)
{
classificator::Load();
m_estimator = EdgeEstimator::CreateForCar(*make_shared<CarModelFactory>()->GetVehicleModel());
m_trafficGetter = make_unique<TrafficInfoGetterTest>(make_shared<TrafficInfo>(move(coloring)));
m_estimator = EdgeEstimator::CreateForCar(*make_shared<CarModelFactory>()->GetVehicleModel(),
*m_trafficGetter);
}
shared_ptr<EdgeEstimator> GetEstimator() const { return m_estimator; }
private:
unique_ptr<TrafficInfoGetter> m_trafficGetter;
shared_ptr<EdgeEstimator> m_estimator;
};
// Route through XX graph without any traffic info.
UNIT_CLASS_TEST(ApplyingTrafficTest, XXGraph_EmptyTrafficColoring)
{
unique_ptr<IndexGraph> graph = BuildXXGraph(m_estimator);
SetEstimator({} /* coloring */);
unique_ptr<IndexGraph> graph = BuildXXGraph(GetEstimator());
IndexGraphStarter starter(*graph, RoadPoint(1, 0) /* start */, RoadPoint(6, 1) /* finish */);
vector<m2::PointD> const expectedGeom = {{2 /* x */, 0 /* y */}, {1, 1}, {2, 2}, {3, 3}};
TestRouteGeometry(starter, AStarAlgorithm<IndexGraphStarter>::Result::OK, expectedGeom);
@ -112,13 +137,12 @@ UNIT_CLASS_TEST(ApplyingTrafficTest, XXGraph_G0onF3)
TrafficInfo::Coloring coloring = {
{{3 /* feature id */, 0 /* segment id */, TrafficInfo::RoadSegmentId::kForwardDirection},
SpeedGroup::G0}};
shared_ptr<TrafficInfo> trafficInfo = make_shared<TrafficInfo>();
trafficInfo->SetColoringForTesting(coloring);
m_estimator->SetTrafficInfo(trafficInfo);
SetEstimator(move(coloring));
unique_ptr<IndexGraph> graph = BuildXXGraph(m_estimator);
unique_ptr<IndexGraph> graph = BuildXXGraph(GetEstimator());
IndexGraphStarter starter(*graph, RoadPoint(1, 0) /* start */, RoadPoint(6, 1) /* finish */);
vector<m2::PointD> const expectedGeom = {{2 /* x */, 0 /* y */}, {3, 0}, {3, 1}, {2, 2}, {3, 3}};
GetEstimator()->Start(MwmSet::MwmId());
TestRouteGeometry(starter, AStarAlgorithm<IndexGraphStarter>::Result::OK, expectedGeom);
}
@ -128,13 +152,12 @@ UNIT_CLASS_TEST(ApplyingTrafficTest, XXGraph_G0onF3ReverseDir)
TrafficInfo::Coloring coloring = {
{{3 /* feature id */, 0 /* segment id */, TrafficInfo::RoadSegmentId::kReverseDirection},
SpeedGroup::G0}};
shared_ptr<TrafficInfo> trafficInfo = make_shared<TrafficInfo>();
trafficInfo->SetColoringForTesting(coloring);
m_estimator->SetTrafficInfo(trafficInfo);
SetEstimator(move(coloring));
unique_ptr<IndexGraph> graph = BuildXXGraph(m_estimator);
unique_ptr<IndexGraph> graph = BuildXXGraph(GetEstimator());
IndexGraphStarter starter(*graph, RoadPoint(1, 0) /* start */, RoadPoint(6, 1) /* finish */);
vector<m2::PointD> const expectedGeom = {{2 /* x */, 0 /* y */}, {1, 1}, {2, 2}, {3, 3}};
GetEstimator()->Start(MwmSet::MwmId());
TestRouteGeometry(starter, AStarAlgorithm<IndexGraphStarter>::Result::OK, expectedGeom);
}
@ -150,13 +173,12 @@ UNIT_CLASS_TEST(ApplyingTrafficTest, XXGraph_G0onF3andF6andG4onF8andF4)
SpeedGroup::G4},
{{7 /* feature id */, 0 /* segment id */, TrafficInfo::RoadSegmentId::kForwardDirection},
SpeedGroup::G4}};
shared_ptr<TrafficInfo> trafficInfo = make_shared<TrafficInfo>();
trafficInfo->SetColoringForTesting(coloring);
m_estimator->SetTrafficInfo(trafficInfo);
SetEstimator(move(coloring));
unique_ptr<IndexGraph> graph = BuildXXGraph(m_estimator);
unique_ptr<IndexGraph> graph = BuildXXGraph(GetEstimator());
IndexGraphStarter starter(*graph, RoadPoint(1, 0) /* start */, RoadPoint(6, 1) /* finish */);
vector<m2::PointD> const expectedGeom = {{2 /* x */, 0 /* y */}, {3, 0}, {3, 1}, {2, 2}, {3, 3}};
GetEstimator()->Start(MwmSet::MwmId());
TestRouteGeometry(starter, AStarAlgorithm<IndexGraphStarter>::Result::OK, expectedGeom);
}
} // namespace

15
routing/routing_tests/index_graph_test.cpp
View file

@ -100,7 +100,8 @@ UNIT_TEST(EdgesTest)
loader->AddRoad(4 /* featureId */, true, 1.0 /* speed */,
RoadGeometry::Points({{3.0, -1.0}, {3.0, 0.0}, {3.0, 1.0}}));
IndexGraph graph(move(loader), CreateEstimator());
TrafficInfoGetterTest const trafficGetter;
IndexGraph graph(move(loader), CreateEstimator(trafficGetter));
vector<Joint> joints;
joints.emplace_back(MakeJoint({{0, 1}, {3, 1}})); // J0
@ -144,7 +145,8 @@ UNIT_TEST(FindPathCross)
1 /* featureId */, false, 1.0 /* speed */,
RoadGeometry::Points({{0.0, -2.0}, {-1.0, 0.0}, {0.0, 0.0}, {0.0, 1.0}, {0.0, 2.0}}));
IndexGraph graph(move(loader), CreateEstimator());
TrafficInfoGetterTest const trafficGetter;
IndexGraph graph(move(loader), CreateEstimator(trafficGetter));
graph.Import({MakeJoint({{0, 2}, {1, 2}})});
@ -200,7 +202,8 @@ UNIT_TEST(FindPathManhattan)
loader->AddRoad(i + kCitySize, false, 1.0 /* speed */, avenue);
}
IndexGraph graph(move(loader), CreateEstimator());
TrafficInfoGetterTest const trafficGetter;
IndexGraph graph(move(loader), CreateEstimator(trafficGetter));
vector<Joint> joints;
for (uint32_t i = 0; i < kCitySize; ++i)
@ -250,7 +253,8 @@ UNIT_TEST(RedressRace)
2 /* featureId */, false, 1.0 /* speed */,
RoadGeometry::Points({{0.0, 0.0}, {1.0, 1.0}, {2.0, 1.0}, {3.0, 1.0}, {4.0, 0.0}}));
IndexGraph graph(move(loader), CreateEstimator());
TrafficInfoGetterTest const trafficGetter;
IndexGraph graph(move(loader), CreateEstimator(trafficGetter));
vector<Joint> joints;
joints.emplace_back(MakeJoint({{0, 0}, {1, 0}, {2, 0}})); // J0
@ -280,7 +284,8 @@ UNIT_TEST(RoadSpeed)
loader->AddRoad(1 /* featureId */, false, 1.0 /* speed */,
RoadGeometry::Points({{0.0, 0.0}, {2.0, 0.0}, {4.0, 0.0}}));
IndexGraph graph(move(loader), CreateEstimator());
TrafficInfoGetterTest const trafficGetter;
IndexGraph graph(move(loader), CreateEstimator(trafficGetter));
vector<Joint> joints;
joints.emplace_back(MakeJoint({{0, 0}, {1, 0}})); // J0

4
routing/routing_tests/index_graph_tools.cpp
View file

@ -34,9 +34,9 @@ Joint MakeJoint(vector<RoadPoint> const & points)
return joint;
}
shared_ptr<EdgeEstimator> CreateEstimator()
shared_ptr<EdgeEstimator> CreateEstimator(TrafficInfoGetterTest const & trafficGetter)
{
return EdgeEstimator::CreateForCar(*make_shared<CarModelFactory>()->GetVehicleModel());
return EdgeEstimator::CreateForCar(*make_shared<CarModelFactory>()->GetVehicleModel(), trafficGetter);
}
AStarAlgorithm<IndexGraphStarter>::Result CalculateRoute(IndexGraphStarter & starter,

16
routing/routing_tests/index_graph_tools.hpp
View file

@ -7,6 +7,8 @@
#include "routing/base/astar_algorithm.hpp"
#include "traffic/traffic_info.hpp"
#include "geometry/point2d.hpp"
#include "std/algorithm.hpp"
@ -30,9 +32,21 @@ private:
unordered_map<uint32_t, routing::RoadGeometry> m_roads;
};
class TrafficInfoGetterTest : public traffic::TrafficInfoGetter
{
public:
TrafficInfoGetterTest() {}
// TrafficInfoGetter overrides:
shared_ptr<traffic::TrafficInfo> GetTrafficInfo(MwmSet::MwmId const & mwmId) const override
{
return shared_ptr<traffic::TrafficInfo>();
}
};
routing::Joint MakeJoint(vector<routing::RoadPoint> const & points);
shared_ptr<routing::EdgeEstimator> CreateEstimator();
shared_ptr<routing::EdgeEstimator> CreateEstimator(TrafficInfoGetterTest const & trafficGette);
routing::AStarAlgorithm<routing::IndexGraphStarter>::Result CalculateRoute(
routing::IndexGraphStarter & graph, vector<routing::RoadPoint> & roadPoints);

22
routing/single_mwm_router.cpp
View file

@ -44,18 +44,30 @@ vector<Junction> ConvertToJunctions(IndexGraphStarter & starter, vector<Joint::I
return junctions;
}
class EstimatorGuard
{
public:
EstimatorGuard(MwmSet::MwmId const & mwmId, EdgeEstimator & estimator) : m_estimator(estimator)
{
m_estimator.Start(mwmId);
}
~EstimatorGuard() { m_estimator.Finish(); }
private:
EdgeEstimator & m_estimator;
};
} // namespace
namespace routing
{
SingleMwmRouter::SingleMwmRouter(string const & name, Index const & index,
traffic::TrafficInfoGetter const & getter,
shared_ptr<VehicleModelFactory> vehicleModelFactory,
shared_ptr<EdgeEstimator> estimator,
unique_ptr<IDirectionsEngine> directionsEngine)
: m_name(name)
, m_index(index)
, m_trafficInfoGetter(getter)
, m_roadGraph(index, IRoadGraph::Mode::ObeyOnewayTag, vehicleModelFactory)
, m_vehicleModelFactory(vehicleModelFactory)
, m_estimator(estimator)
@ -108,7 +120,7 @@ IRouter::ResultCode SingleMwmRouter::DoCalculateRoute(MwmSet::MwmId const & mwmI
RoadPoint const start(startEdge.GetFeatureId().m_index, startEdge.GetSegId());
RoadPoint const finish(finishEdge.GetFeatureId().m_index, finishEdge.GetSegId());
m_estimator->SetTrafficInfo(m_trafficInfoGetter.GetTrafficInfo(mwmId));
EstimatorGuard guard(mwmId, *m_estimator);
IndexGraph graph(GeometryLoader::Create(
m_index, mwmId, m_vehicleModelFactory->GetVehicleModelForCountry(country)),
@ -221,9 +233,9 @@ unique_ptr<SingleMwmRouter> SingleMwmRouter::CreateCarRouter(
// @TODO Bicycle turn generation engine is used now. It's ok for the time being.
// But later a special car turn generation engine should be implemented.
auto directionsEngine = make_unique<BicycleDirectionsEngine>(index);
auto estimator = EdgeEstimator::CreateForCar(*vehicleModelFactory->GetVehicleModel());
auto estimator = EdgeEstimator::CreateForCar(*vehicleModelFactory->GetVehicleModel(), getter);
auto router =
make_unique<SingleMwmRouter>("astar-bidirectional-car", index, getter,
make_unique<SingleMwmRouter>("astar-bidirectional-car", index,
move(vehicleModelFactory), estimator, move(directionsEngine));
return router;
}

4
routing/single_mwm_router.hpp
View file

@ -6,8 +6,6 @@
#include "routing/router.hpp"
#include "routing/vehicle_model.hpp"
#include "traffic/traffic_info.hpp"
#include "indexer/index.hpp"
#include "indexer/mwm_set.hpp"
@ -23,7 +21,6 @@ class SingleMwmRouter
{
public:
SingleMwmRouter(string const & name, Index const & index,
traffic::TrafficInfoGetter const & getter,
shared_ptr<VehicleModelFactory> vehicleModelFactory,
shared_ptr<EdgeEstimator> estimator,
unique_ptr<IDirectionsEngine> directionsEngine);
@ -49,7 +46,6 @@ private:
string const m_name;
Index const & m_index;
traffic::TrafficInfoGetter const & m_trafficInfoGetter;
FeaturesRoadGraph m_roadGraph;
shared_ptr<VehicleModelFactory> m_vehicleModelFactory;
shared_ptr<EdgeEstimator> m_estimator;

4
traffic/traffic_info.hpp
View file

@ -70,7 +70,9 @@ public:
TrafficInfo(TrafficInfo && info) : m_coloring(move(info.m_coloring)), m_mwmId(info.m_mwmId) {}
void SetColoringForTesting(Coloring & coloring) { m_coloring = coloring; }
// For testing only.
TrafficInfo(Coloring && coloring) : m_coloring(move(coloring)) {}
// Fetches the latest traffic data from the server and updates the coloring.
// Construct the url by passing an MwmId.
// *NOTE* This method must not be called on the UI thread.