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

[generator] Update link max speed with ingoing highway max speed.

Browse source 
Signed-off-by: vng <viktor.govako@gmail.com>
This commit is contained in:
vng 2021-05-03 14:26:33 +03:00 • committed by Alexander Borsuk
parent ff5d5b452a
commit dd7ca48ca7
13 changed files with 215 additions and 146 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
generator/generator_tests/maxspeeds_tests.cpp
View file

@ -90,7 +90,7 @@ void TestMaxspeedsSection(Features const & roads, string const & maxspeedsCsvCon
// Creating maxspeed section in test.mwm.
string const testMwmFullPath = base::JoinPath(testDirFullPath, testMwm);
BuildMaxspeedsSection(testMwmFullPath, featureIdToOsmId, base::JoinPath(testDirFullPath, kCsv));
BuildMaxspeedsSection(nullptr, testMwmFullPath, featureIdToOsmId, base::JoinPath(testDirFullPath, kCsv));
// Loading maxspeed section.
FrozenDataSource dataSource;

9
generator/generator_tests/restriction_collector_test.cpp
View file

@ -133,7 +133,8 @@ public:
void ValidCase()
{
RestrictionCollector restrictionCollector(m_osmIdsToFeatureIdFullPath, BuildTwoCubeGraph());
auto graph = BuildTwoCubeGraph();
RestrictionCollector restrictionCollector(m_osmIdsToFeatureIdFullPath, *graph);
// Adding restrictions.
TEST(restrictionCollector.AddRestriction(
@ -166,7 +167,8 @@ public:
void InvalidCase_NoSuchFeature()
{
RestrictionCollector restrictionCollector(m_osmIdsToFeatureIdFullPath, BuildTwoCubeGraph());
auto graph = BuildTwoCubeGraph();
RestrictionCollector restrictionCollector(m_osmIdsToFeatureIdFullPath, *graph);
// No such feature - 2809
TEST(!restrictionCollector.AddRestriction({2.0, 1.0}, Restriction::Type::No,
@ -177,7 +179,8 @@ public:
void InvalidCase_FeaturesNotIntersecting()
{
RestrictionCollector restrictionCollector(m_osmIdsToFeatureIdFullPath, BuildTwoCubeGraph());
auto graph = BuildTwoCubeGraph();
RestrictionCollector restrictionCollector(m_osmIdsToFeatureIdFullPath, *graph);
// Fetures with id 1 and 2 do not intersect in {2.0, 1.0}
TEST(!restrictionCollector.AddRestriction({2.0, 1.0}, Restriction::Type::No,

3
generator/generator_tests/restriction_test.cpp
View file

@ -168,8 +168,7 @@ void TestRestrictionBuilding(string const & restrictionPath,
string const & mwmFullPath = scopedMwm.GetFullPath();
// Prepare data to collector.
auto restrictionCollector =
make_unique<RestrictionCollector>(osmIdsToFeatureIdFullPath, move(graph));
auto restrictionCollector = make_unique<RestrictionCollector>(osmIdsToFeatureIdFullPath, *graph);
TEST(restrictionCollector->Process(restrictionFullPath), ("Bad restrictions were given."));

26
generator/generator_tool/generator_tool.cpp
View file

@ -504,9 +504,22 @@ MAIN_WITH_ERROR_HANDLING([](int argc, char ** argv)
string const roadAccessFilename = genInfo.GetIntermediateFileName(ROAD_ACCESS_FILENAME);
routing::BuildRoutingIndex(dataFile, country, *countryParentGetter);
routing::BuildRoadRestrictions(path, dataFile, country, restrictionsFilename,
osmToFeatureFilename, *countryParentGetter);
routing::BuildRoadAccessInfo(dataFile, roadAccessFilename, osmToFeatureFilename);
auto routingGraph = routing::CreateIndexGraph(path, dataFile, country, *countryParentGetter);
CHECK(routingGraph, ());
/// @todo CHECK return result doesn't work now for some small countries like Somalie.
if (!routing::BuildRoadRestrictions(*routingGraph, dataFile, restrictionsFilename, osmToFeatureFilename) ||
!routing::BuildRoadAccessInfo(dataFile, roadAccessFilename, osmToFeatureFilename))
{
LOG(LERROR, ("Routing build failed for", dataFile));
}
if (FLAGS_generate_maxspeed)
{
string const maxspeedsFilename = genInfo.GetIntermediateFileName(MAXSPEEDS_FILENAME);
LOG(LINFO, ("Generating maxspeeds section for", dataFile, "using", maxspeedsFilename));
routing::BuildMaxspeedsSection(routingGraph.get(), dataFile, osmToFeatureFilename, maxspeedsFilename);
}
}
if (FLAGS_make_city_roads)
@ -519,13 +532,6 @@ MAIN_WITH_ERROR_HANDLING([](int argc, char ** argv)
LOG(LCRITICAL, ("Generating city roads error."));
}
if (FLAGS_generate_maxspeed)
{
LOG(LINFO, ("Generating maxspeeds section for", dataFile));
string const maxspeedsFilename = genInfo.GetIntermediateFileName(MAXSPEEDS_FILENAME);
routing::BuildMaxspeedsSection(dataFile, osmToFeatureFilename, maxspeedsFilename);
}
if (FLAGS_make_cross_mwm || FLAGS_make_transit_cross_mwm ||
FLAGS_make_transit_cross_mwm_experimental)
{

194
generator/maxspeeds_builder.cpp
View file

@ -3,6 +3,7 @@
#include "generator/maxspeeds_parser.hpp"
#include "generator/routing_helpers.hpp"
#include "routing/index_graph.hpp"
#include "routing/maxspeeds_serialization.hpp"
#include "routing/routing_helpers.hpp"
@ -37,7 +38,7 @@ namespace
{
char const kDelim[] = ", \t\r\n";
bool ParseOneSpeedValue(strings::SimpleTokenizer & iter, uint16_t & value)
bool ParseOneSpeedValue(strings::SimpleTokenizer & iter, MaxspeedType & value)
{
if (!iter)
return false;
@ -45,9 +46,9 @@ bool ParseOneSpeedValue(strings::SimpleTokenizer & iter, uint16_t & value)
uint64_t parsedSpeed = 0;
if (!strings::to_uint64(*iter, parsedSpeed))
return false;
if (parsedSpeed > numeric_limits<uint16_t>::max())
if (parsedSpeed > routing::kInvalidSpeed)
return false;
value = static_cast<uint16_t>(parsedSpeed);
value = static_cast<MaxspeedType>(parsedSpeed);
++iter;
return true;
}
@ -61,47 +62,138 @@ FeatureMaxspeed ToFeatureMaxspeed(uint32_t featureId, Maxspeed const & maxspeed)
/// \brief Collects all maxspeed tag values of specified mwm based on maxspeeds.csv file.
class MaxspeedsMwmCollector
{
public:
MaxspeedsMwmCollector(string const & dataPath,
map<uint32_t, base::GeoObjectId> const & featureIdToOsmId,
string const & maxspeedCsvPath);
vector<FeatureMaxspeed> && StealMaxspeeds();
private:
vector<FeatureMaxspeed> m_maxspeeds;
public:
MaxspeedsMwmCollector(IndexGraph * graph, string const & dataPath,
map<uint32_t, base::GeoObjectId> const & featureIdToOsmId,
string const & maxspeedCsvPath)
{
OsmIdToMaxspeed osmIdToMaxspeed;
CHECK(ParseMaxspeeds(maxspeedCsvPath, osmIdToMaxspeed), (maxspeedCsvPath));
auto const GetOsmID = [&](uint32_t fid) -> base::GeoObjectId
{
auto const osmIdIt = featureIdToOsmId.find(fid);
if (osmIdIt == featureIdToOsmId.cend())
return base::GeoObjectId();
return osmIdIt->second;
};
auto const GetSpeed = [&](uint32_t fid) -> Maxspeed *
{
auto osmid = GetOsmID(fid);
if (osmid.GetType() == base::GeoObjectId::Type::Invalid)
return nullptr;
auto const maxspeedIt = osmIdToMaxspeed.find(osmid);
if (maxspeedIt == osmIdToMaxspeed.cend())
return nullptr;
return &maxspeedIt->second;
};
auto const GetRoad = [&](uint32_t fid) -> routing::RoadGeometry const &
{
return graph->GetGeometry().GetRoad(fid);
};
auto const GetLastIndex = [&](uint32_t fid)
{
return GetRoad(fid).GetPointsCount() - 2;
};
auto const GetOpposite = [&](Segment const & seg)
{
// Assume that links are connected with main roads in first or last point, always.
uint32_t const fid = seg.GetFeatureId();
return Segment(0, fid, seg.GetSegmentIdx() > 0 ? 0 : GetLastIndex(fid), seg.IsForward());
};
ForEachFeature(dataPath, [&](FeatureType & ft, uint32_t fid)
{
if (!routing::IsCarRoad(TypesHolder(ft)))
return;
Maxspeed * maxSpeed = GetSpeed(fid);
if (!maxSpeed)
return;
auto const osmid = GetOsmID(fid).GetSerialId();
// Recalculate link speed accordint to the ingoing highway.
// See MaxspeedsCollector::CollectFeature.
if (maxSpeed->GetForward() == routing::kCommonMaxSpeedValue)
{
// Check if we are in unit tests.
if (graph == nullptr)
return;
// 0 - not updated, 1 - goto next iteration, 2 - updated
int status;
// Check ingoing first, then - outgoing.
for (bool direction : { false, true })
{
Segment seg(0, fid, 0, true);
if (direction)
seg = GetOpposite(seg);
std::unordered_set<uint32_t> reviewed;
do
{
status = 0;
reviewed.insert(seg.GetFeatureId());
IndexGraph::SegmentEdgeListT edges;
graph->GetEdgeList(seg, direction, true /* useRoutingOptions */, edges);
for (auto const & e : edges)
{
Segment const target = e.GetTarget();
Maxspeed * s = GetSpeed(target.GetFeatureId());
if (s)
{
if (s->GetForward() != routing::kCommonMaxSpeedValue)
{
status = 2;
maxSpeed->SetForward(s->GetForward());
// In theory, we should iterate on forward and backward segments/speeds separately,
// but I don't see any reason for this complication.
if (!GetRoad(fid).IsOneWay())
maxSpeed->SetBackward(s->GetForward());
LOG(LINFO, ("Updated link speed for way", osmid, "with", *maxSpeed));
break;
}
else if (reviewed.find(target.GetFeatureId()) == reviewed.end())
{
// Found another input link. Save it for the next iteration.
status = 1;
seg = GetOpposite(target);
}
}
}
} while (status == 1);
if (status == 2)
break;
}
if (status == 0)
{
LOG(LWARNING, ("Didn't find connected edge with speed for way", osmid));
return;
}
}
m_maxspeeds.push_back(ToFeatureMaxspeed(fid, *maxSpeed));
});
}
vector<FeatureMaxspeed> const & GetMaxspeeds()
{
CHECK(is_sorted(m_maxspeeds.cbegin(), m_maxspeeds.cend(), IsFeatureIdLess), ());
return m_maxspeeds;
}
};
MaxspeedsMwmCollector::MaxspeedsMwmCollector(
string const & dataPath, map<uint32_t, base::GeoObjectId> const & featureIdToOsmId,
string const & maxspeedCsvPath)
{
OsmIdToMaxspeed osmIdToMaxspeed;
CHECK(ParseMaxspeeds(maxspeedCsvPath, osmIdToMaxspeed), (maxspeedCsvPath));
ForEachFeature(dataPath, [&](FeatureType & ft, uint32_t fid) {
if (!routing::IsCarRoad(TypesHolder(ft)))
return;
auto const osmIdIt = featureIdToOsmId.find(fid);
if (osmIdIt == featureIdToOsmId.cend())
return;
// @TODO Consider adding check here. |fid| should be in |featureIdToOsmId| anyway.
auto const maxspeedIt = osmIdToMaxspeed.find(osmIdIt->second);
if (maxspeedIt == osmIdToMaxspeed.cend())
return;
auto const & maxspeed = maxspeedIt->second;
m_maxspeeds.push_back(ToFeatureMaxspeed(fid, maxspeed));
});
}
vector<FeatureMaxspeed> && MaxspeedsMwmCollector::StealMaxspeeds()
{
CHECK(is_sorted(m_maxspeeds.cbegin(), m_maxspeeds.cend(), IsFeatureIdLess), ());
return move(m_maxspeeds);
}
} // namespace
namespace routing
@ -134,7 +226,7 @@ bool ParseMaxspeeds(string const & maxspeedsFilename, OsmIdToMaxspeed & osmIdToM
speed.SetUnits(StringToUnits(*iter));
++iter;
uint16_t forward = 0;
MaxspeedType forward = 0;
if (!ParseOneSpeedValue(iter, forward))
return false;
@ -143,7 +235,7 @@ bool ParseMaxspeeds(string const & maxspeedsFilename, OsmIdToMaxspeed & osmIdToM
if (iter)
{
// There's backward maxspeed limit.
uint16_t backward = 0;
MaxspeedType backward = 0;
if (!ParseOneSpeedValue(iter, backward))
return false;
@ -160,7 +252,7 @@ bool ParseMaxspeeds(string const & maxspeedsFilename, OsmIdToMaxspeed & osmIdToM
return true;
}
void SerializeMaxspeeds(string const & dataPath, vector<FeatureMaxspeed> && speeds)
void SerializeMaxspeeds(string const & dataPath, vector<FeatureMaxspeed> const & speeds)
{
if (speeds.empty())
return;
@ -172,21 +264,19 @@ void SerializeMaxspeeds(string const & dataPath, vector<FeatureMaxspeed> && spee
LOG(LINFO, ("SerializeMaxspeeds(", dataPath, ", ...) serialized:", speeds.size(), "maxspeed tags."));
}
void BuildMaxspeedsSection(string const & dataPath,
void BuildMaxspeedsSection(IndexGraph * graph, string const & dataPath,
map<uint32_t, base::GeoObjectId> const & featureIdToOsmId,
string const & maxspeedsFilename)
{
MaxspeedsMwmCollector collector(dataPath, featureIdToOsmId, maxspeedsFilename);
SerializeMaxspeeds(dataPath, collector.StealMaxspeeds());
MaxspeedsMwmCollector collector(graph, dataPath, featureIdToOsmId, maxspeedsFilename);
SerializeMaxspeeds(dataPath, collector.GetMaxspeeds());
}
void BuildMaxspeedsSection(string const & dataPath, string const & osmToFeaturePath,
string const & maxspeedsFilename)
void BuildMaxspeedsSection(IndexGraph * graph, string const & dataPath,
string const & osmToFeaturePath, string const & maxspeedsFilename)
{
LOG(LINFO, ("BuildMaxspeedsSection(", dataPath, ",", osmToFeaturePath, ",", maxspeedsFilename, ")"));
map<uint32_t, base::GeoObjectId> featureIdToOsmId;
CHECK(ParseWaysFeatureIdToOsmIdMapping(osmToFeaturePath, featureIdToOsmId), ());
BuildMaxspeedsSection(dataPath, featureIdToOsmId, maxspeedsFilename);
BuildMaxspeedsSection(graph, dataPath, featureIdToOsmId, maxspeedsFilename);
}
} // namespace routing

9
generator/maxspeeds_builder.hpp
View file

@ -13,6 +13,7 @@
namespace routing
{
class IndexGraph;
using OsmIdToMaxspeed = std::map<base::GeoObjectId, Maxspeed>;
/// \brief Parses csv file with path |maxspeedsFilename| and stores the result in |osmIdToMaxspeed|.
@ -20,9 +21,9 @@ using OsmIdToMaxspeed = std::map<base::GeoObjectId, Maxspeed>;
bool ParseMaxspeeds(std::string const & maxspeedsFilename, OsmIdToMaxspeed & osmIdToMaxspeed);
/// \brief Writes |speeds| to maxspeeds section to mwm with |dataPath|.
void SerializeMaxspeeds(std::string const & dataPath, std::vector<FeatureMaxspeed> && speeds);
void SerializeMaxspeeds(std::string const & dataPath, std::vector<FeatureMaxspeed> const & speeds);
void BuildMaxspeedsSection(std::string const & dataPath,
void BuildMaxspeedsSection(IndexGraph * graph, std::string const & dataPath,
std::map<uint32_t, base::GeoObjectId> const & featureIdToOsmId,
std::string const & maxspeedsFilename);
@ -34,6 +35,6 @@ void BuildMaxspeedsSection(std::string const & dataPath,
// to a csv file.
/// 2. Calls GenerateFeatures()
/// 3. Generates geometry.
void BuildMaxspeedsSection(std::string const & dataPath, std::string const & osmToFeaturePath,
std::string const & maxspeedsFilename);
void BuildMaxspeedsSection(IndexGraph * graph, std::string const & dataPath,
std::string const & osmToFeaturePath, std::string const & maxspeedsFilename);
} // namespace routing

13
generator/maxspeeds_collector.cpp
View file

@ -102,15 +102,18 @@ void MaxspeedsCollector::CollectFeature(FeatureBuilder const & ft, OsmElement co
ss << "," << strings::to_string(maxspeedBackward.GetSpeed());
}
}
else if (ftypes::IsLinkChecker::Instance()(ft.GetTypes()) &&
ParseMaxspeedAndWriteToStream(maxspeedAdvisoryStr, maxspeed, ss))
else if (ftypes::IsLinkChecker::Instance()(ft.GetTypes()))
{
// Assign maxspeed:advisory for highway:xxx_link types to avoid situation when
// not defined link speed is predicted bigger than defined parent ingoing highway speed.
// https://www.openstreetmap.org/way/5511439#map=18/45.55465/-122.67787
/// @todo Best solution is to correct not defined link speed according to the defined parent highway speed
/// in graph building process, but it needs much more efforts.
if (!ParseMaxspeedAndWriteToStream(maxspeedAdvisoryStr, maxspeed, ss))
{
// Write indicator that it's a link and the speed should be recalculated.
// Idea is to set the link speed equal to the ingoing highway speed (now it's "default" and can be bigger).
// https://www.openstreetmap.org/way/842536050#map=19/45.43449/-122.56678
ss << UnitsToString(measurement_utils::Units::Metric) << "," << strings::to_string(routing::kCommonMaxSpeedValue);
}
}
else
return;

23
generator/restriction_collector.cpp
View file

@ -49,8 +49,8 @@ namespace routing
m2::PointD constexpr RestrictionCollector::kNoCoords;
RestrictionCollector::RestrictionCollector(std::string const & osmIdsToFeatureIdPath,
std::unique_ptr<IndexGraph> && graph)
: m_indexGraph(std::move(graph))
IndexGraph & graph)
: m_indexGraph(graph)
{
CHECK(ParseWaysOsmIdToFeatureIdMapping(osmIdsToFeatureIdPath, m_osmIdToFeatureIds),
("An error happened while parsing feature id to "
@ -59,8 +59,6 @@ RestrictionCollector::RestrictionCollector(std::string const & osmIdsToFeatureId
bool RestrictionCollector::Process(std::string const & restrictionPath)
{
CHECK(m_indexGraph, ());
SCOPE_GUARD(clean, [this]() {
m_osmIdToFeatureIds.clear();
m_restrictions.clear();
@ -129,11 +127,11 @@ bool RestrictionCollector::ParseRestrictions(std::string const & path)
Joint::Id RestrictionCollector::GetFirstCommonJoint(uint32_t firstFeatureId,
uint32_t secondFeatureId) const
{
uint32_t const firstLen = m_indexGraph->GetGeometry().GetRoad(firstFeatureId).GetPointsCount();
uint32_t const secondLen = m_indexGraph->GetGeometry().GetRoad(secondFeatureId).GetPointsCount();
uint32_t const firstLen = m_indexGraph.GetGeometry().GetRoad(firstFeatureId).GetPointsCount();
uint32_t const secondLen = m_indexGraph.GetGeometry().GetRoad(secondFeatureId).GetPointsCount();
auto const firstRoad = m_indexGraph->GetRoad(firstFeatureId);
auto const secondRoad = m_indexGraph->GetRoad(secondFeatureId);
auto const firstRoad = m_indexGraph.GetRoad(firstFeatureId);
auto const secondRoad = m_indexGraph.GetRoad(secondFeatureId);
std::unordered_set<Joint::Id> used;
for (uint32_t i = 0; i < firstLen; ++i)
@ -154,8 +152,7 @@ Joint::Id RestrictionCollector::GetFirstCommonJoint(uint32_t firstFeatureId,
bool RestrictionCollector::FeatureHasPointWithCoords(uint32_t featureId,
m2::PointD const & coords) const
{
CHECK(m_indexGraph, ());
auto const & roadGeometry = m_indexGraph->GetGeometry().GetRoad(featureId);
auto const & roadGeometry = m_indexGraph.GetGeometry().GetRoad(featureId);
uint32_t const pointsCount = roadGeometry.GetPointsCount();
for (uint32_t i = 0; i < pointsCount; ++i)
{
@ -245,7 +242,7 @@ bool RestrictionCollector::CheckAndProcessUTurn(Restriction::Type & restrictionT
uint32_t & featureId = featureIds.back();
auto const & road = m_indexGraph->GetGeometry().GetRoad(featureId);
auto const & road = m_indexGraph.GetGeometry().GetRoad(featureId);
// Can not do UTurn from feature to the same feature if it is one way.
if (road.IsOneWay())
return false;
@ -282,14 +279,14 @@ bool RestrictionCollector::IsRestrictionValid(Restriction::Type & restrictionTyp
m2::PointD const & coords,
std::vector<uint32_t> & featureIds) const
{
if (featureIds.empty() || !m_indexGraph->IsRoad(featureIds[0]))
if (featureIds.empty() || !m_indexGraph.IsRoad(featureIds[0]))
return false;
for (size_t i = 1; i < featureIds.size(); ++i)
{
auto prev = featureIds[i - 1];
auto cur = featureIds[i];
if (!m_indexGraph->IsRoad(cur))
if (!m_indexGraph.IsRoad(cur))
return false;
if (!FeaturesAreCross(coords, prev, cur))

5
generator/restriction_collector.hpp
View file

@ -30,8 +30,7 @@ public:
static m2::PointD constexpr kNoCoords =
m2::PointD(std::numeric_limits<double>::max(), std::numeric_limits<double>::max());
RestrictionCollector(std::string const & osmIdsToFeatureIdPath,
std::unique_ptr<IndexGraph> && graph);
RestrictionCollector(std::string const & osmIdsToFeatureIdPath, IndexGraph & graph);
bool Process(std::string const & restrictionPath);
@ -94,7 +93,7 @@ private:
std::vector<Restriction> m_restrictions;
OsmIdToFeatureIds m_osmIdToFeatureIds;
std::unique_ptr<IndexGraph> m_indexGraph;
IndexGraph & m_indexGraph;
std::string m_restrictionPath;
};

54
generator/restriction_generator.cpp
View file

@ -26,9 +26,8 @@
#include <utility>
#include <vector>
namespace
namespace routing
{
using namespace routing;
std::unique_ptr<IndexGraph>
CreateIndexGraph(std::string const & targetPath,
@ -51,37 +50,6 @@ CreateIndexGraph(std::string const & targetPath,
return graph;
}
} // namespace
namespace routing
{
std::unique_ptr<RestrictionCollector>
CreateRestrictionCollectorAndParse(
std::string const & targetPath, std::string const & mwmPath, std::string const & country,
std::string const & restrictionPath, std::string const & osmIdsToFeatureIdsPath,
CountryParentNameGetterFn const & countryParentNameGetterFn)
{
LOG(LDEBUG, ("BuildRoadRestrictions(", targetPath, ", ", restrictionPath, ", ",
osmIdsToFeatureIdsPath, ");"));
std::unique_ptr<IndexGraph> graph =
CreateIndexGraph(targetPath, mwmPath, country, countryParentNameGetterFn);
auto restrictionCollector =
std::make_unique<RestrictionCollector>(osmIdsToFeatureIdsPath, std::move(graph));
if (!restrictionCollector->Process(restrictionPath))
return {};
if (!restrictionCollector->HasRestrictions())
{
LOG(LINFO, ("No restrictions for", targetPath, "It's necessary to check that",
restrictionPath, "and", osmIdsToFeatureIdsPath, "are available."));
return {};
}
return restrictionCollector;
}
void SerializeRestrictions(RestrictionCollector & restrictionCollector,
std::string const & mwmPath)
@ -125,21 +93,25 @@ void SerializeRestrictions(RestrictionCollector & restrictionCollector,
RestrictionSerializer::Serialize(header, restrictions.begin(), restrictions.end(), *w);
}
bool BuildRoadRestrictions(std::string const & targetPath,
bool BuildRoadRestrictions(IndexGraph & graph,
std::string const & mwmPath,
std::string const & country,
std::string const & restrictionPath,
std::string const & osmIdsToFeatureIdsPath,
CountryParentNameGetterFn const & countryParentNameGetterFn)
std::string const & osmIdsToFeatureIdsPath)
{
auto collector =
CreateRestrictionCollectorAndParse(targetPath, mwmPath, country, restrictionPath,
osmIdsToFeatureIdsPath, countryParentNameGetterFn);
LOG(LINFO, ("BuildRoadRestrictions(", restrictionPath, ", ", osmIdsToFeatureIdsPath, ");"));
if (!collector)
auto collector = std::make_unique<RestrictionCollector>(osmIdsToFeatureIdsPath, graph);
if (!collector->Process(restrictionPath))
return false;
if (!collector->HasRestrictions())
{
LOG(LWARNING, ("No restrictions created. Check that", restrictionPath, "and", osmIdsToFeatureIdsPath, "are available."));
return false;
}
SerializeRestrictions(*collector, mwmPath);
return true;
}
} // namespace routing

16
generator/restriction_generator.hpp
View file

@ -8,11 +8,11 @@
namespace routing
{
std::unique_ptr<RestrictionCollector>
CreateRestrictionCollectorAndParse(
std::string const & targetPath, std::string const & mwmPath, std::string const & country,
std::string const & restrictionPath, std::string const & osmIdsToFeatureIdsPath,
CountryParentNameGetterFn const & countryParentNameGetterFn);
std::unique_ptr<IndexGraph>
CreateIndexGraph(std::string const & targetPath,
std::string const & mwmPath,
std::string const & country,
CountryParentNameGetterFn const & countryParentNameGetterFn);
void SerializeRestrictions(RestrictionCollector & restrictionCollector,
std::string const & mwmPath);
@ -41,10 +41,8 @@ void SerializeRestrictions(RestrictionCollector & restrictionCollector,
/// \param osmIdsToFeatureIdsPath a binary file with mapping form osm ids to feature ids.
/// One osm id is mapped to one feature id. The file should be saved with the help of
/// OsmID2FeatureID class or using a similar way.
bool BuildRoadRestrictions(std::string const & targetPath,
bool BuildRoadRestrictions(IndexGraph & graph,
std::string const & mwmPath,
std::string const & country,
std::string const & restrictionPath,
std::string const & osmIdsToFeatureIdsPath,
CountryParentNameGetterFn const & countryParentNameGetterFn);
std::string const & osmIdsToFeatureIdsPath);
} // namespace routing

5
generator/road_access_generator.cpp
View file

@ -822,7 +822,7 @@ string AccessConditionalTagParser::TrimAndDropAroundParentheses(string input) co
}
// Functions ------------------------------------------------------------------
void BuildRoadAccessInfo(string const & dataFilePath, string const & roadAccessPath,
bool BuildRoadAccessInfo(string const & dataFilePath, string const & roadAccessPath,
string const & osmIdsToFeatureIdsPath)
{
LOG(LINFO, ("Generating road access info for", dataFilePath));
@ -832,12 +832,13 @@ void BuildRoadAccessInfo(string const & dataFilePath, string const & roadAccessP
if (!collector.IsValid())
{
LOG(LWARNING, ("Unable to parse road access in osm terms"));
return;
return false;
}
FilesContainerW cont(dataFilePath, FileWriter::OP_WRITE_EXISTING);
auto writer = cont.GetWriter(ROAD_ACCESS_FILE_TAG);
RoadAccessSerializer::Serialize(*writer, collector.GetRoadAccessAllTypes());
return true;
}
} // namespace routing

2
generator/road_access_generator.hpp
View file

@ -161,6 +161,6 @@ private:
// The generator tool's interface to writing the section with
// road accessibility information for one mwm file.
void BuildRoadAccessInfo(std::string const & dataFilePath, std::string const & roadAccessPath,
bool BuildRoadAccessInfo(std::string const & dataFilePath, std::string const & roadAccessPath,
std::string const & osmIdsToFeatureIdsPath);
} // namespace routing