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

Fixing routing_benchmarks and using IndexRouter instead of RoadGraphRouter in it.

Browse source
This commit is contained in:
Vladimir Byko-Ianko 2018-01-26 15:07:42 +03:00 • committed by mpimenov
parent b7b60eef4d
commit 4a8a03815c
4 changed files with 64 additions and 44 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
routing/routing_benchmarks/CMakeLists.txt
View file

@ -2,6 +2,8 @@ project(routing_benchmarks)
set(
SRC
../routing_integration_tests/routing_test_tools.cpp
../routing_integration_tests/routing_test_tools.hpp
bicycle_routing_tests.cpp
helpers.cpp
helpers.hpp
@ -16,9 +18,12 @@ omim_link_libraries(
routing
traffic
routing_common
transit
search
storage
mwm_diff
indexer
traffic
platform
editor
oauthcpp
@ -28,6 +33,7 @@ omim_link_libraries(
base
jansson
protobuf
bsdiff
stats_client
succinct
pugixml

44
routing/routing_benchmarks/helpers.cpp
View file

@ -7,6 +7,8 @@
#include "routing/route.hpp"
#include "routing/router_delegate.hpp"
#include "routing_integration_tests/routing_test_tools.hpp"
#include "indexer/classificator_loader.hpp"
#include "indexer/mwm_set.hpp"
@ -18,9 +20,12 @@
#include "base/logging.hpp"
#include "base/math.hpp"
#include "base/stl_add.hpp"
#include "base/timer.hpp"
#include "std/limits.hpp"
#include <limits>
using namespace std;
namespace
{
@ -58,23 +63,22 @@ m2::PointD GetPointOnEdge(routing::Edge const & e, double posAlong)
} // namespace
RoutingTest::RoutingTest(routing::IRoadGraph::Mode mode, set<string> const & neededMaps)
: m_mode(mode)
: m_mode(mode), m_neededMaps(neededMaps), m_numMwmIds(my::make_unique<routing::NumMwmIds>())
{
classificator::Load();
Platform & platform = GetPlatform();
m_cig = storage::CountryInfoReader::CreateCountryInfoReader(platform);
vector<platform::LocalCountryFile> localFiles;
platform::FindAllLocalMapsAndCleanup(numeric_limits<int64_t>::max(), localFiles);
platform::FindAllLocalMapsAndCleanup(numeric_limits<int64_t>::max(), m_localFiles);
set<string> registeredMaps;
for (auto const & localFile : localFiles)
for (auto const & localFile : m_localFiles)
{
m_numMwmIds->RegisterFile(localFile.GetCountryFile());
auto const & name = localFile.GetCountryName();
if (neededMaps.count(name) == 0)
if (m_neededMaps.count(name) == 0)
continue;
UNUSED_VALUE(m_index.RegisterMap(localFile));
@ -87,9 +91,9 @@ RoutingTest::RoutingTest(routing::IRoadGraph::Mode mode, set<string> const & nee
registeredMaps.insert(name);
}
if (registeredMaps != neededMaps)
if (registeredMaps != m_neededMaps)
{
for (auto const & file : neededMaps)
for (auto const & file : m_neededMaps)
{
if (registeredMaps.count(file) == 0)
LOG(LERROR, ("Can't find map:", file));
@ -103,22 +107,21 @@ void RoutingTest::TestRouters(m2::PointD const & startPos, m2::PointD const & fi
// Find route by A*-bidirectional algorithm.
routing::Route routeFoundByAstarBidirectional("");
{
auto router =
CreateRouter<routing::AStarBidirectionalRoutingAlgorithm>("test-astar-bidirectional");
auto router = CreateRouter("test-astar-bidirectional");
TestRouter(*router, startPos, finalPos, routeFoundByAstarBidirectional);
}
// Find route by A* algorithm.
routing::Route routeFoundByAstar("");
{
auto router = CreateRouter<routing::AStarRoutingAlgorithm>("test-astar");
auto router = CreateRouter("test-astar");
TestRouter(*router, startPos, finalPos, routeFoundByAstar);
}
double constexpr kEpsilon = 1e-6;
TEST(my::AlmostEqualAbs(routeFoundByAstar.GetTotalDistanceMeters(),
routeFoundByAstarBidirectional.GetTotalDistanceMeters(), kEpsilon),
());
routeFoundByAstarBidirectional.GetTotalDistanceMeters(), kEpsilon),
());
}
void RoutingTest::TestTwoPointsOnFeature(m2::PointD const & startPos, m2::PointD const & finalPos)
@ -139,6 +142,21 @@ void RoutingTest::TestTwoPointsOnFeature(m2::PointD const & startPos, m2::PointD
TestRouters(startPosOnFeature, finalPosOnFeature);
}
unique_ptr<routing::IRouter> RoutingTest::CreateRouter(string const & name)
{
vector<platform::LocalCountryFile> neededLocalFiles;
neededLocalFiles.reserve(m_neededMaps.size());
for (auto const & lf : m_localFiles)
{
if (m_neededMaps.count(lf.GetCountryName()) != 0)
neededLocalFiles.push_back(lf);
}
unique_ptr<routing::IRouter> router = integration::CreateVehicleRouter(
m_index, *m_cig, m_trafficCache, neededLocalFiles, routing::VehicleType::Pedestrian);
return router;
}
void RoutingTest::GetNearestEdges(m2::PointD const & pt,
vector<pair<routing::Edge, routing::Junction>> & edges)
{

57
routing/routing_benchmarks/helpers.hpp
View file

@ -1,29 +1,31 @@
#pragma once
#include "routing/index_router.hpp"
#include "routing/road_graph.hpp"
#include "routing/router.hpp"
#include "routing/road_graph_router.hpp"
#include "routing/vehicle_mask.hpp"
#include "routing_common/num_mwm_id.hpp"
#include "routing_common/vehicle_model.hpp"
#include "indexer/index.hpp"
#include "storage/country_info_getter.hpp"
#include "traffic/traffic_cache.hpp"
#include "indexer/index.hpp"
#include "geometry/point2d.hpp"
#include "std/set.hpp"
#include "std/shared_ptr.hpp"
#include "std/string.hpp"
#include "std/unique_ptr.hpp"
#include "std/utility.hpp"
#include "std/vector.hpp"
#include <memory>
#include <set>
#include <string>
#include <utility>
#include <vector>
class RoutingTest
{
public:
RoutingTest(routing::IRoadGraph::Mode mode, set<string> const & neededMaps);
RoutingTest(routing::IRoadGraph::Mode mode, std::set<std::string> const & neededMaps);
virtual ~RoutingTest() = default;
@ -31,29 +33,22 @@ public:
void TestTwoPointsOnFeature(m2::PointD const & startPos, m2::PointD const & finalPos);
protected:
virtual unique_ptr<routing::IDirectionsEngine> CreateDirectionsEngine(
shared_ptr<routing::NumMwmIds> numMwmIds) = 0;
virtual unique_ptr<routing::VehicleModelFactoryInterface> CreateModelFactory() = 0;
template <typename Algorithm>
unique_ptr<routing::IRouter> CreateRouter(string const & name)
{
auto getter = [&](m2::PointD const & pt) { return m_cig->GetRegionCountryId(pt); };
unique_ptr<routing::IRoutingAlgorithm> algorithm(new Algorithm());
unique_ptr<routing::IRouter> router(
new routing::RoadGraphRouter(name, m_index, getter, m_mode, CreateModelFactory(),
move(algorithm), CreateDirectionsEngine(m_numMwmIds)));
return router;
}
virtual std::unique_ptr<routing::IDirectionsEngine> CreateDirectionsEngine(
std::shared_ptr<routing::NumMwmIds> numMwmIds) = 0;
virtual std::unique_ptr<routing::VehicleModelFactoryInterface> CreateModelFactory() = 0;
std::unique_ptr<routing::IRouter> CreateRouter(std::string const & name);
void GetNearestEdges(m2::PointD const & pt,
vector<pair<routing::Edge, routing::Junction>> & edges);
std::vector<std::pair<routing::Edge, routing::Junction>> & edges);
routing::IRoadGraph::Mode const m_mode;
Index m_index;
traffic::TrafficCache m_trafficCache;
shared_ptr<routing::NumMwmIds> m_numMwmIds;
unique_ptr<storage::CountryInfoGetter> m_cig;
std::vector<platform::LocalCountryFile> m_localFiles;
std::set<std::string> const & m_neededMaps;
std::shared_ptr<routing::NumMwmIds> m_numMwmIds;
std::unique_ptr<storage::CountryInfoGetter> m_cig;
};
template <typename Model>
@ -85,13 +80,13 @@ public:
SimplifiedModelFactory() : m_model(make_shared<SimplifiedModel>()) {}
// VehicleModelFactoryInterface overrides:
shared_ptr<routing::VehicleModelInterface> GetVehicleModel() const override { return m_model; }
shared_ptr<routing::VehicleModelInterface> GetVehicleModelForCountry(
string const & /*country*/) const override
std::shared_ptr<routing::VehicleModelInterface> GetVehicleModel() const override { return m_model; }
std::shared_ptr<routing::VehicleModelInterface> GetVehicleModelForCountry(
std::string const & /* country */) const override
{
return m_model;
}
private:
shared_ptr<SimplifiedModel> const m_model;
std::shared_ptr<SimplifiedModel> const m_model;
};

1
routing/routing_integration_tests/routing_test_tools.cpp
View file

@ -104,6 +104,7 @@ namespace integration
{
auto const & countryFile = f.GetCountryFile();
auto const mwmId = index.GetMwmIdByCountryFile(countryFile);
CHECK(mwmId.IsAlive(), ());
if (mwmId.GetInfo()->GetType() == MwmInfo::COUNTRY && countryFile.GetName() != "minsk-pass")
numMwmIds->RegisterFile(countryFile);
}