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

[routing] Renaming maxspeed to maxspeeds.

Browse source
This commit is contained in:
Vladimir Byko-Ianko 2018-11-23 15:28:50 +03:00 • committed by mpimenov
parent b1ac6dab1c
commit 3f162dd710
14 changed files with 111 additions and 111 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
generator/CMakeLists.txt
View file

@ -69,12 +69,12 @@ set(SRC
intermediate_elements.hpp
locality_sorter.cpp
locality_sorter.hpp
maxspeed_builder.cpp
maxspeed_builder.hpp
maxspeed_collector.cpp
maxspeed_collector.hpp
maxspeed_parser.cpp
maxspeed_parser.hpp
maxspeeds_builder.cpp
maxspeeds_builder.hpp
maxspeeds_collector.cpp
maxspeeds_collector.hpp
maxspeeds_parser.cpp
maxspeeds_parser.hpp
metalines_builder.cpp
metalines_builder.hpp
node_mixer.cpp

2
generator/camera_node_processor.cpp
View file

@ -1,6 +1,6 @@
#include "generator/camera_node_processor.hpp"
#include "generator/maxspeed_parser.hpp"
#include "generator/maxspeeds_parser.hpp"
#include "routing_common/maxspeed_conversion.hpp"

2
generator/generator_tests/CMakeLists.txt
View file

@ -13,7 +13,7 @@ set(
feature_merger_test.cpp
filter_elements_tests.cpp
intermediate_data_test.cpp
maxspeed_tests.cpp
maxspeeds_tests.cpp
metadata_parser_test.cpp
node_mixer_test.cpp
osm2meta_test.cpp

122
generator/generator_tests/maxspeed_tests.cpp → generator/generator_tests/maxspeeds_tests.cpp
View file

@ -2,8 +2,8 @@
#include "generator/generator_tests_support/test_feature.cpp"
#include "generator/generator_tests_support/test_mwm_builder.hpp"
#include "generator/maxspeed_builder.hpp"
#include "generator/maxspeed_parser.hpp"
#include "generator/maxspeeds_builder.hpp"
#include "generator/maxspeeds_parser.hpp"
#include "generator/routing_helpers.hpp"
#include "routing/maxspeeds_serialization.hpp"
@ -51,11 +51,11 @@ using namespace std;
using Features = vector<vector<m2::PointD>>;
// Directory name for creating test mwm and temporary files.
string const kTestDir = "maxspeed_generation_test";
string const kTestDir = "maxspeeds_generation_test";
// Temporary mwm name for testing.
string const kTestMwm = "test";
// File name for keeping maxspeeds.
string const kCsv = "maxspeed.csv";
string const kCsv = "maxspeeds.csv";
void BuildGeometry(Features const & roads, LocalCountryFile & country)
{
@ -64,15 +64,15 @@ void BuildGeometry(Features const & roads, LocalCountryFile & country)
builder.Add(generator::tests_support::TestStreet(road, string(), string()));
}
void TestMaxspeedSection(Features const & roads, string const & maxspeedCsvContent,
map<uint32_t, base::GeoObjectId> const & featureIdToOsmId)
void TestMaxspeedsSection(Features const & roads, string const & maxspeedsCsvContent,
map<uint32_t, base::GeoObjectId> const & featureIdToOsmId)
{
classificator::Load();
string const testDirFullPath = base::JoinPath(GetPlatform().WritableDir(), kTestDir);
ScopedDir testScopedDir(kTestDir);
// Writing |maxspeedCsvContent| to a file in |kTestDir|.
ScopedFile testScopedMaxspeedCsv(base::JoinPath(kTestDir, kCsv), maxspeedCsvContent);
// Writing |maxspeedsCsvContent| to a file in |kTestDir|.
ScopedFile testScopedMaxspeedsCsv(base::JoinPath(kTestDir, kCsv), maxspeedsCsvContent);
// Writing |roads| to test mwm.
LocalCountryFile country(testDirFullPath, CountryFile(kTestMwm), 1 /* version */);
@ -82,7 +82,7 @@ void TestMaxspeedSection(Features const & roads, string const & maxspeedCsvConte
// Creating maxspeed section in test.mwm.
string const testMwmFullPath = base::JoinPath(testDirFullPath, testMwm);
BuildMaxspeedSection(testMwmFullPath, featureIdToOsmId, base::JoinPath(testDirFullPath, kCsv));
BuildMaxspeedsSection(testMwmFullPath, featureIdToOsmId, base::JoinPath(testDirFullPath, kCsv));
// Loading maxspeed section.
FrozenDataSource dataSource;
@ -118,13 +118,13 @@ void TestMaxspeedSection(Features const & roads, string const & maxspeedCsvConte
feature::ForEachFromDat(testMwmFullPath, processor);
}
// Note. ParseMaxspeeds() is not tested in TestMaxspeedSection() because it's used twice there.
// Note. ParseMaxspeeds() is not tested in TestMaxspeedsSection() because it's used twice there.
// So it's important to test the function separately.
bool ParseCsv(string const & maxspeedCsvContent, OsmIdToMaxspeed & mapping)
bool ParseCsv(string const & maxspeedsCsvContent, OsmIdToMaxspeed & mapping)
{
string const testDirFullPath = base::JoinPath(GetPlatform().WritableDir(), kTestDir);
ScopedDir testScopedDir(kTestDir);
ScopedFile testScopedMaxspeedCsv(base::JoinPath(kTestDir, kCsv), maxspeedCsvContent);
ScopedFile testScopedMaxspeedsCsv(base::JoinPath(kTestDir, kCsv), maxspeedsCsvContent);
return ParseMaxspeeds(base::JoinPath(testDirFullPath, kCsv), mapping);
}
@ -178,126 +178,126 @@ UNIT_TEST(MaxspeedTagValueToSpeedTest)
UNIT_TEST(ParseMaxspeeds_Smoke)
{
string const maxspeedCsvContent;
string const maxspeedsCsvContent;
OsmIdToMaxspeed osmIdToMaxspeed;
TEST(ParseCsv(maxspeedCsvContent, osmIdToMaxspeed), ());
TEST(ParseCsv(maxspeedsCsvContent, osmIdToMaxspeed), ());
TEST(osmIdToMaxspeed.empty(), ());
}
UNIT_TEST(ParseMaxspeeds1)
{
string const maxspeedCsvContent = R"(10,Metric,60
11,Metric,90)";
string const maxspeedsCsvContent = R"(10,Metric,60
11,Metric,90)";
OsmIdToMaxspeed const expectedMapping = {
{base::MakeOsmWay(10), {Units::Metric, 60, kInvalidSpeed}},
{base::MakeOsmWay(11), {Units::Metric, 90, kInvalidSpeed}}};
OsmIdToMaxspeed osmIdToMaxspeed;
TEST(ParseCsv(maxspeedCsvContent, osmIdToMaxspeed), ());
TEST(ParseCsv(maxspeedsCsvContent, osmIdToMaxspeed), ());
TEST_EQUAL(osmIdToMaxspeed, expectedMapping, ());
}
UNIT_TEST(ParseMaxspeeds2)
{
string const maxspeedCsvContent = R"(10,Metric,60,80
11,Metric,120)";
string const maxspeedsCsvContent = R"(10,Metric,60,80
11,Metric,120)";
OsmIdToMaxspeed const expectedMapping = {
{base::MakeOsmWay(10), {Units::Metric, 60, 80}},
{base::MakeOsmWay(11), {Units::Metric, 120, kInvalidSpeed}}};
OsmIdToMaxspeed osmIdToMaxspeed;
TEST(ParseCsv(maxspeedCsvContent, osmIdToMaxspeed), ());
TEST(ParseCsv(maxspeedsCsvContent, osmIdToMaxspeed), ());
TEST_EQUAL(osmIdToMaxspeed, expectedMapping, ());
}
UNIT_TEST(ParseMaxspeeds3)
{
string const maxspeedCsvContent = R"(184467440737095516,Imperial,60,80
184467440737095517,Metric,120)";
string const maxspeedsCsvContent = R"(184467440737095516,Imperial,60,80
184467440737095517,Metric,120)";
OsmIdToMaxspeed const expectedMapping = {
{base::MakeOsmWay(184467440737095516), {Units::Imperial, 60, 80}},
{base::MakeOsmWay(184467440737095517), {Units::Metric, 120, kInvalidSpeed}}};
OsmIdToMaxspeed osmIdToMaxspeed;
TEST(ParseCsv(maxspeedCsvContent, osmIdToMaxspeed), ());
TEST(ParseCsv(maxspeedsCsvContent, osmIdToMaxspeed), ());
TEST_EQUAL(osmIdToMaxspeed, expectedMapping, ());
}
UNIT_TEST(ParseMaxspeeds4)
{
// Note. kNoneMaxSpeed == 65534 and kWalkMaxSpeed == 65533.
string const maxspeedCsvContent = R"(1,Metric,200,65534
2,Metric,65533)";
string const maxspeedsCsvContent = R"(1,Metric,200,65534
2,Metric,65533)";
OsmIdToMaxspeed const expectedMapping = {
{base::MakeOsmWay(1), {Units::Metric, 200, kNoneMaxSpeed}},
{base::MakeOsmWay(2), {Units::Metric, kWalkMaxSpeed, kInvalidSpeed}}};
OsmIdToMaxspeed osmIdToMaxspeed;
TEST(ParseCsv(maxspeedCsvContent, osmIdToMaxspeed), ());
TEST(ParseCsv(maxspeedsCsvContent, osmIdToMaxspeed), ());
TEST_EQUAL(osmIdToMaxspeed, expectedMapping, ());
}
UNIT_TEST(ParseMaxspeeds5)
{
string const maxspeedCsvContent = R"(
2,Metric,10)";
string const maxspeedsCsvContent = R"(
2,Metric,10)";
OsmIdToMaxspeed osmIdToMaxspeed;
TEST(!ParseCsv(maxspeedCsvContent, osmIdToMaxspeed), ());
TEST(!ParseCsv(maxspeedsCsvContent, osmIdToMaxspeed), ());
}
UNIT_TEST(ParseMaxspeeds6)
{
string const maxspeedCsvContent = R"(2U,Metric,10)";
string const maxspeedsCsvContent = R"(2U,Metric,10)";
OsmIdToMaxspeed osmIdToMaxspeed;
TEST(!ParseCsv(maxspeedCsvContent, osmIdToMaxspeed), ());
TEST(!ParseCsv(maxspeedsCsvContent, osmIdToMaxspeed), ());
}
UNIT_TEST(ParseMaxspeeds7)
{
string const maxspeedCsvContent = R"(2,Metric)";
string const maxspeedsCsvContent = R"(2,Metric)";
OsmIdToMaxspeed osmIdToMaxspeed;
TEST(!ParseCsv(maxspeedCsvContent, osmIdToMaxspeed), ());
TEST(!ParseCsv(maxspeedsCsvContent, osmIdToMaxspeed), ());
}
UNIT_TEST(ParseMaxspeeds8)
{
string const maxspeedCsvContent = R"(2,Metric,10,11m)";
string const maxspeedsCsvContent = R"(2,Metric,10,11m)";
OsmIdToMaxspeed osmIdToMaxspeed;
TEST(!ParseCsv(maxspeedCsvContent, osmIdToMaxspeed), ());
TEST(!ParseCsv(maxspeedsCsvContent, osmIdToMaxspeed), ());
}
UNIT_TEST(ParseMaxspeeds_Big)
{
// Note. kNoneMaxSpeed == 65534.
string const maxspeedCsvContent = R"(100,Metric,200,65534
101,Metric,60,90
102,Metric,60
103,Metric,90)";
string const maxspeedsCsvContent = R"(100,Metric,200,65534
101,Metric,60,90
102,Metric,60
103,Metric,90)";
OsmIdToMaxspeed const expectedMapping = {
{base::MakeOsmWay(100), {Units::Metric, 200, kNoneMaxSpeed}},
{base::MakeOsmWay(101), {Units::Metric, 60, 90}},
{base::MakeOsmWay(102), {Units::Metric, 60, kInvalidSpeed}},
{base::MakeOsmWay(103), {Units::Metric, 90, kInvalidSpeed}}};
OsmIdToMaxspeed osmIdToMaxspeed;
TEST(ParseCsv(maxspeedCsvContent, osmIdToMaxspeed), ());
TEST(ParseCsv(maxspeedsCsvContent, osmIdToMaxspeed), ());
TEST_EQUAL(osmIdToMaxspeed, expectedMapping, ());
}
UNIT_TEST(MaxspeedSection_Smoke)
{
Features const roads;
string const maxspeedCsvContent;
string const maxspeedsCsvContent;
map<uint32_t, base::GeoObjectId> const featureIdToOsmId;
TestMaxspeedSection(roads, maxspeedCsvContent, featureIdToOsmId);
TestMaxspeedsSection(roads, maxspeedsCsvContent, featureIdToOsmId);
}
UNIT_TEST(MaxspeedSection1)
{
Features const roads = {{{0.0, 0.0}, {0.0, 1.0}, {0.0, 2.0}} /* Points of feature 0 */,
{{1.0, 0.0}, {1.0, 1.0}, {1.0, 2.0}} /* Points of feature 1 */};
string const maxspeedCsvContent = R"(25258932,Metric,60
25258943,Metric,90)";
string const maxspeedsCsvContent = R"(25258932,Metric,60
25258943,Metric,90)";
map<uint32_t, base::GeoObjectId> const featureIdToOsmId = {
{0 /* feature id */, base::MakeOsmWay(25258932)},
{1 /* feature id */, base::MakeOsmWay(25258943)}};
TestMaxspeedSection(roads, maxspeedCsvContent, featureIdToOsmId);
TestMaxspeedsSection(roads, maxspeedsCsvContent, featureIdToOsmId);
}
UNIT_TEST(MaxspeedSection2)
@ -305,13 +305,13 @@ UNIT_TEST(MaxspeedSection2)
Features const roads = {{{0.0, 0.0}, {0.0, 1.0}} /* Points of feature 0 */,
{{1.0, 0.0}, {1.0, 2.0}} /* Points of feature 1 */,
{{1.0, 2.0}, {1.0, 3.0}} /* Points of feature 2 */};
string const maxspeedCsvContent = R"(25258932,Metric,60,40
32424,Metric,120)";
string const maxspeedsCsvContent = R"(25258932,Metric,60,40
32424,Metric,120)";
map<uint32_t, base::GeoObjectId> const featureIdToOsmId = {
{0 /* feature id */, base::MakeOsmWay(25258932)},
{1 /* feature id */, base::MakeOsmWay(25258943)},
{2 /* feature id */, base::MakeOsmWay(32424)}};
TestMaxspeedSection(roads, maxspeedCsvContent, featureIdToOsmId);
TestMaxspeedsSection(roads, maxspeedsCsvContent, featureIdToOsmId);
}
UNIT_TEST(MaxspeedSection3)
@ -320,26 +320,26 @@ UNIT_TEST(MaxspeedSection3)
{{1.0, 0.0}, {1.0, 2.0}} /* Points of feature 1 */,
{{1.0, 2.0}, {1.0, 3.0}} /* Points of feature 2 */};
// Note. kNoneMaxSpeed == 65535 and kWalkMaxSpeed == 65534.
string const maxspeedCsvContent = R"(25252,Metric,120,65534
258943,Metric,65533
32424,Metric,10,65533)";
string const maxspeedsCsvContent = R"(25252,Metric,120,65534
258943,Metric,65533
32424,Metric,10,65533)";
map<uint32_t, base::GeoObjectId> const featureIdToOsmId = {
{0 /* feature id */, base::MakeOsmWay(25252)},
{1 /* feature id */, base::MakeOsmWay(258943)},
{2 /* feature id */, base::MakeOsmWay(32424)}};
TestMaxspeedSection(roads, maxspeedCsvContent, featureIdToOsmId);
TestMaxspeedsSection(roads, maxspeedsCsvContent, featureIdToOsmId);
}
UNIT_TEST(MaxspeedSection4)
{
Features const roads = {{{0.0, 0.0}, {0.0, 1.0}} /* Points of feature 0 */,
{{1.0, 0.0}, {0.0, 0.0}} /* Points of feature 1 */};
string const maxspeedCsvContent = R"(50000000000,Imperial,30
50000000001,Imperial,50)";
string const maxspeedsCsvContent = R"(50000000000,Imperial,30
50000000001,Imperial,50)";
map<uint32_t, base::GeoObjectId> const featureIdToOsmId = {
{0 /* feature id */, base::MakeOsmWay(50000000000)},
{1 /* feature id */, base::MakeOsmWay(50000000001)}};
TestMaxspeedSection(roads, maxspeedCsvContent, featureIdToOsmId);
TestMaxspeedsSection(roads, maxspeedsCsvContent, featureIdToOsmId);
}
UNIT_TEST(MaxspeedSection_Big)
@ -352,17 +352,17 @@ UNIT_TEST(MaxspeedSection_Big)
{{1.0, 2.0}, {2.0, 7.0}} /* Points of feature 5 */,
{{1.0, 2.0}, {7.0, 4.0}} /* Points of feature 6 */};
// Note. kNoneMaxSpeed == 65534.
string const maxspeedCsvContent = R"(100,Imperial,100,65534
200,Imperial,50
300,Imperial,30
400,Imperial,10,20
600,)"
string const maxspeedsCsvContent = R"(100,Imperial,100,65534
200,Imperial,50
300,Imperial,30
400,Imperial,10,20
600,)"
"Imperial,50,20\n700,Imperial,10\n";
map<uint32_t, base::GeoObjectId> const featureIdToOsmId = {
{0 /* feature id */, base::MakeOsmWay(100)}, {1 /* feature id */, base::MakeOsmWay(200)},
{2 /* feature id */, base::MakeOsmWay(300)}, {3 /* feature id */, base::MakeOsmWay(400)},
{4 /* feature id */, base::MakeOsmWay(500)}, {5 /* feature id */, base::MakeOsmWay(600)},
{6 /* feature id */, base::MakeOsmWay(700)}};
TestMaxspeedSection(roads, maxspeedCsvContent, featureIdToOsmId);
TestMaxspeedsSection(roads, maxspeedsCsvContent, featureIdToOsmId);
}
} // namespace

2
generator/generator_tests/speed_cameras_test.cpp
View file

@ -6,7 +6,7 @@
#include "generator/generate_info.hpp"
#include "generator/generator_tests_support/routing_helpers.hpp"
#include "generator/generator_tests_support/test_mwm_builder.hpp"
#include "generator/maxspeed_parser.hpp"
#include "generator/maxspeeds_parser.hpp"
#include "generator/metalines_builder.hpp"
#include "generator/osm_source.hpp"

6
generator/generator_tool/generator_tool.cpp
View file

@ -13,7 +13,7 @@
#include "generator/generate_info.hpp"
#include "generator/geo_objects/geo_objects.hpp"
#include "generator/locality_sorter.hpp"
#include "generator/maxspeed_builder.hpp"
#include "generator/maxspeeds_builder.hpp"
#include "generator/metalines_builder.hpp"
#include "generator/osm_source.hpp"
#include "generator/popular_places_section_builder.hpp"
@ -531,8 +531,8 @@ int main(int argc, char ** argv)
if (FLAGS_generate_maxspeed)
{
LOG(LINFO, ("Generating maxspeeds section for", datFile));
string const maxspeedFilename = genInfo.GetIntermediateFileName(MAXSPEEDS_FILENAME);
routing::BuildMaxspeedSection(datFile, osmToFeatureFilename, maxspeedFilename);
string const maxspeedsFilename = genInfo.GetIntermediateFileName(MAXSPEEDS_FILENAME);
routing::BuildMaxspeedsSection(datFile, osmToFeatureFilename, maxspeedsFilename);
}
if (FLAGS_make_cross_mwm || FLAGS_make_transit_cross_mwm)

34
generator/maxspeed_builder.cpp → generator/maxspeeds_builder.cpp
View file

@ -1,6 +1,6 @@
#include "generator/maxspeed_builder.hpp"
#include "generator/maxspeeds_builder.hpp"
#include "generator/maxspeed_parser.hpp"
#include "generator/maxspeeds_parser.hpp"
#include "generator/routing_helpers.hpp"
#include "routing/maxspeeds_serialization.hpp"
@ -57,11 +57,11 @@ FeatureMaxspeed ToFeatureMaxspeed(uint32_t featureId, Maxspeed const & maxspeed)
maxspeed.GetBackward());
}
/// \brief Collects all maxspeed tag value of specified mwm based on maxspeeds.csv file.
class MaxspeedMwmCollector
/// \brief Collects all maxspeed tag values of specified mwm based on maxspeeds.csv file.
class MaxspeedsMwmCollector
{
public:
MaxspeedMwmCollector(string const & dataPath,
MaxspeedsMwmCollector(string const & dataPath,
map<uint32_t, base::GeoObjectId> const & featureIdToOsmId,
string const & maxspeedCsvPath);
@ -71,7 +71,7 @@ private:
vector<FeatureMaxspeed> m_maxspeeds;
};
MaxspeedMwmCollector::MaxspeedMwmCollector(
MaxspeedsMwmCollector::MaxspeedsMwmCollector(
string const & dataPath, map<uint32_t, base::GeoObjectId> const & featureIdToOsmId,
string const & maxspeedCsvPath)
{
@ -96,7 +96,7 @@ MaxspeedMwmCollector::MaxspeedMwmCollector(
});
}
vector<FeatureMaxspeed> && MaxspeedMwmCollector::StealMaxspeeds()
vector<FeatureMaxspeed> && MaxspeedsMwmCollector::StealMaxspeeds()
{
CHECK(is_sorted(m_maxspeeds.cbegin(), m_maxspeeds.cend(), IsFeatureIdLess), ());
return move(m_maxspeeds);
@ -105,11 +105,11 @@ vector<FeatureMaxspeed> && MaxspeedMwmCollector::StealMaxspeeds()
namespace routing
{
bool ParseMaxspeeds(string const & maxspeedFilename, OsmIdToMaxspeed & osmIdToMaxspeed)
bool ParseMaxspeeds(string const & maxspeedsFilename, OsmIdToMaxspeed & osmIdToMaxspeed)
{
osmIdToMaxspeed.clear();
ifstream stream(maxspeedFilename);
ifstream stream(maxspeedsFilename);
if (!stream)
return false;
@ -171,21 +171,21 @@ void SerializeMaxspeeds(string const & dataPath, vector<FeatureMaxspeed> && spee
LOG(LINFO, ("SerializeMaxspeeds(", dataPath, ", ...) serialized:", speeds.size(), "maxspeed tags."));
}
void BuildMaxspeedSection(string const & dataPath,
map<uint32_t, base::GeoObjectId> const & featureIdToOsmId,
string const & maxspeedFilename)
void BuildMaxspeedsSection(string const & dataPath,
map<uint32_t, base::GeoObjectId> const & featureIdToOsmId,
string const & maxspeedsFilename)
{
MaxspeedMwmCollector collector(dataPath, featureIdToOsmId, maxspeedFilename);
MaxspeedsMwmCollector collector(dataPath, featureIdToOsmId, maxspeedsFilename);
SerializeMaxspeeds(dataPath, collector.StealMaxspeeds());
}
void BuildMaxspeedSection(string const & dataPath, string const & osmToFeaturePath,
string const & maxspeedFilename)
void BuildMaxspeedsSection(string const & dataPath, string const & osmToFeaturePath,
string const & maxspeedsFilename)
{
LOG(LINFO, ("BuildMaxspeedSection(", dataPath, ",", osmToFeaturePath, ",", maxspeedFilename, ")"));
LOG(LINFO, ("BuildMaxspeedsSection(", dataPath, ",", osmToFeaturePath, ",", maxspeedsFilename, ")"));
map<uint32_t, base::GeoObjectId> featureIdToOsmId;
CHECK(ParseFeatureIdToOsmIdMapping(osmToFeaturePath, featureIdToOsmId), ());
BuildMaxspeedSection(dataPath, featureIdToOsmId, maxspeedFilename);
BuildMaxspeedsSection(dataPath, featureIdToOsmId, maxspeedsFilename);
}
} // namespace routing

18
generator/maxspeed_builder.hpp → generator/maxspeeds_builder.hpp
View file

@ -15,25 +15,25 @@ namespace routing
{
using OsmIdToMaxspeed = std::map<base::GeoObjectId, Maxspeed>;
/// \brief Parses csv file with path |maxspeedFilename| and stores the result in |osmIdToMaxspeed|.
/// \brief Parses csv file with path |maxspeedsFilename| and stores the result in |osmIdToMaxspeed|.
/// \note There's a detailed description of the csv file in generator/maxspeed_collector.hpp.
bool ParseMaxspeeds(std::string const & maxspeedFilename, OsmIdToMaxspeed & osmIdToMaxspeed);
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 BuildMaxspeedSection(std::string const & dataPath,
std::map<uint32_t, base::GeoObjectId> const & featureIdToOsmId,
std::string const & maxspeedFilename);
void BuildMaxspeedsSection(std::string const & dataPath,
std::map<uint32_t, base::GeoObjectId> const & featureIdToOsmId,
std::string const & maxspeedsFilename);
/// \brief Builds maxspeeds section in mwm with |dataPath|. This section contains max speed limits
/// if they are available in file |maxspeedFilename|.
/// \param maxspeedFilename file name to csv file with maxspeed tag values.
/// if they are available in file |maxspeedsFilename|.
/// \param maxspeedsFilename file name to csv file with maxspeed tag values.
/// \note To start building the section, the following steps should be done:
/// 1. Calls GenerateIntermediateData(). It stores data about maxspeed tags value of road features
// to a csv file.
/// 2. Calls GenerateFeatures()
/// 3. Generates geometry.
void BuildMaxspeedSection(std::string const & dataPath, std::string const & osmToFeaturePath,
std::string const & maxspeedFilename);
void BuildMaxspeedsSection(std::string const & dataPath, std::string const & osmToFeaturePath,
std::string const & maxspeedsFilename);
} // namespace routing

8
generator/maxspeed_collector.cpp → generator/maxspeeds_collector.cpp
View file

@ -1,6 +1,6 @@
#include "generator/maxspeed_collector.hpp"
#include "generator/maxspeeds_collector.hpp"
#include "generator/maxspeed_parser.hpp"
#include "generator/maxspeeds_parser.hpp"
#include "routing_common/maxspeed_conversion.hpp"
@ -32,7 +32,7 @@ bool ParseMaxspeedAndWriteToStream(string const & maxspeed, SpeedInUnits & speed
namespace generator
{
void MaxspeedCollector::Process(OsmElement const & p)
void MaxspeedsCollector::Process(OsmElement const & p)
{
ostringstream ss;
ss << p.id << ",";
@ -95,7 +95,7 @@ void MaxspeedCollector::Process(OsmElement const & p)
m_data.push_back(ss.str());
}
void MaxspeedCollector::Flush()
void MaxspeedsCollector::Flush()
{
LOG(LINFO, ("Saving maxspeed tag values to", m_filePath));
ofstream stream(m_filePath);

6
generator/maxspeed_collector.hpp → generator/maxspeeds_collector.hpp
View file

@ -10,12 +10,12 @@ namespace generator
/// \brief Collects all maxspeed tags value and saves them to a csv file.
/// Every line describes maxspeed, maxspeed:forward and maxspeed:backward
/// tags of features. The format of the lines is described below.
class MaxspeedCollector
class MaxspeedsCollector
{
public:
/// \param filePath path to csv file.
explicit MaxspeedCollector(std::string const & filePath) : m_filePath(filePath) {}
~MaxspeedCollector() { Flush(); }
explicit MaxspeedsCollector(std::string const & filePath) : m_filePath(filePath) {}
~MaxspeedsCollector() { Flush(); }
void Process(OsmElement const & p);

2
generator/maxspeed_parser.cpp → generator/maxspeeds_parser.cpp
View file

@ -1,4 +1,4 @@
#include "generator/maxspeed_parser.hpp"
#include "generator/maxspeeds_parser.hpp"
#include "base/assert.hpp"
#include "base/string_utils.hpp"

0
generator/maxspeed_parser.hpp → generator/maxspeeds_parser.hpp
View file

6
generator/routing_helpers.hpp
View file

@ -1,7 +1,7 @@
#pragma once
#include "generator/camera_node_processor.hpp"
#include "generator/maxspeed_collector.hpp"
#include "generator/maxspeeds_collector.hpp"
#include "generator/restriction_writer.hpp"
#include "generator/road_access_generator.hpp"
@ -17,12 +17,12 @@ namespace routing
{
struct TagsProcessor
{
explicit TagsProcessor(std::string const & maxspeedFilePath) : m_maxspeedCollector(maxspeedFilePath) {}
explicit TagsProcessor(std::string const & maxspeedsFilePath) : m_maxspeedsCollector(maxspeedsFilePath) {}
RoadAccessWriter m_roadAccessWriter;
RestrictionWriter m_restrictionWriter;
CameraNodeProcessor m_cameraNodeWriter;
generator::MaxspeedCollector m_maxspeedCollector;
generator::MaxspeedsCollector m_maxspeedsCollector;
};
// Adds feature id and corresponding |osmId| to |osmIdToFeatureId|.

2
generator/translator_planet.cpp
View file

@ -97,7 +97,7 @@ void TranslatorPlanet::EmitElement(OsmElement * p)
ft.SetOsmId(base::MakeOsmWay(p->id));
m_routingTagsProcessor.m_maxspeedCollector.Process(*p);
m_routingTagsProcessor.m_maxspeedsCollector.Process(*p);
bool isCoastline = (m_coastType != 0 && params.IsTypeExist(m_coastType));