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

Merge pull request #10688 from maksimandrianov/maxspeed_changes

Browse source 
[generator] Collecting speed cameras now only stage 'features'.
This commit is contained in:
gmoryes 2019-04-16 14:07:45 +03:00 • committed by GitHub
commit 5d90abfb32
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
36 changed files with 584 additions and 550 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
defines.hpp
View file

@ -17,8 +17,6 @@
#define NODES_FILE "nodes.dat"
#define WAYS_FILE "ways.dat"
#define CAMERAS_NODES_TO_WAYS_FILE "cameras_nodes_to_ways.dat"
#define CAMERAS_MAXSPEED_FILE "cameras_maxspeed.bin"
#define RELATIONS_FILE "relations.dat"
#define TOWNS_FILE "towns.csv"
#define OFFSET_EXT ".offs"

5
generator/CMakeLists.txt
View file

@ -20,8 +20,6 @@ set(SRC
brands_loader.hpp
camera_info_collector.cpp
camera_info_collector.hpp
camera_node_processor.cpp
camera_node_processor.hpp
centers_table_builder.cpp
centers_table_builder.hpp
check_model.cpp
@ -39,6 +37,8 @@ set(SRC
collection_base.hpp
collector_addresses.cpp
collector_addresses.hpp
collector_camera.cpp
collector_camera.hpp
collector_collection.cpp
collector_collection.hpp
collector_interface.hpp
@ -55,6 +55,7 @@ set(SRC
emitter_country.hpp
emitter_factory.hpp
emitter_interface.hpp
emitter_noop.hpp
emitter_restaurants.cpp
emitter_restaurants.hpp
emitter_simple.cpp

153
generator/camera_node_processor.cpp
View file

@ -1,153 +0,0 @@
#include "generator/camera_node_processor.hpp"
#include "generator/feature_builder.hpp"
#include "generator/maxspeeds_parser.hpp"
#include "routing_common/maxspeed_conversion.hpp"
#include "platform/measurement_utils.hpp"
#include "base/assert.hpp"
#include "base/control_flow.hpp"
#include "base/logging.hpp"
#include "base/string_utils.hpp"
#include <array>
namespace generator
{
size_t const CameraNodeIntermediateDataProcessor::kMaxSpeedSpeedStringLength = 32;
} // namespace generator
namespace routing
{
CameraNodeProcessor::CameraNodeProcessor(std::string const & writerFile, std::string const & readerFile,
std::string const & speedFile)
{
Open(writerFile, readerFile, speedFile);
}
void CameraNodeProcessor::Open(std::string const & writerFile, std::string const & readerFile,
std::string const & speedFile)
{
m_fileWriter = std::make_unique<FileWriter>(writerFile);
m_cameraNodeToWays = std::make_unique<Cache>(readerFile);
m_cameraNodeToWays->ReadAll();
FileReader maxSpeedReader(speedFile);
ReaderSource<FileReader> src(maxSpeedReader);
static auto constexpr kMaxSpeedSpeedStringLength =
generator::CameraNodeIntermediateDataProcessor::kMaxSpeedSpeedStringLength;
std::array<char, kMaxSpeedSpeedStringLength> buffer{};
uint64_t nodeOsmId = 0;
size_t maxSpeedStringLength = 0;
while (src.Size() > 0)
{
ReadPrimitiveFromSource(src, nodeOsmId);
ReadPrimitiveFromSource(src, maxSpeedStringLength);
CHECK_LESS(maxSpeedStringLength, kMaxSpeedSpeedStringLength, ("Too long maxspeed string"));
src.Read(buffer.data(), maxSpeedStringLength);
buffer[maxSpeedStringLength] = '\0';
m_cameraToMaxSpeed[nodeOsmId] = buffer.data();
}
}
void CameraNodeProcessor::CollectFeature(FeatureBuilder1 const & feature, OsmElement const & p)
{
if (!(p.type == OsmElement::EntityType::Node && ftypes::IsSpeedCamChecker::Instance()(feature.GetTypes())))
return;
std::string maxSpeedStringKmPH = "0";
auto const it = m_cameraToMaxSpeed.find(p.id);
if (it != m_cameraToMaxSpeed.cend())
maxSpeedStringKmPH = it->second;
int32_t maxSpeedKmPH = 0;
if (!strings::to_int(maxSpeedStringKmPH.c_str(), maxSpeedKmPH))
LOG(LWARNING, ("Bad speed format of camera:", maxSpeedStringKmPH, ", osmId:", p.id));
CHECK_GREATER_OR_EQUAL(maxSpeedKmPH, 0, ());
uint32_t const lat =
DoubleToUint32(p.lat, ms::LatLon::kMinLat, ms::LatLon::kMaxLat, kPointCoordBits);
WriteToSink(*m_fileWriter, lat);
uint32_t const lon =
DoubleToUint32(p.lon, ms::LatLon::kMinLon, ms::LatLon::kMaxLon, kPointCoordBits);
WriteToSink(*m_fileWriter, lon);
WriteToSink(*m_fileWriter, static_cast<uint32_t>(maxSpeedKmPH));
std::vector<uint64_t> ways;
ForEachWayByNode(p.id, [&ways](uint64_t wayId)
{
ways.push_back(wayId);
return base::ControlFlow::Continue;
});
auto const size = static_cast<uint32_t>(ways.size());
WriteToSink(*m_fileWriter, size);
for (auto wayId : ways)
WriteToSink(*m_fileWriter, wayId);
}
} // namespace routing
namespace generator
{
CameraNodeIntermediateDataProcessor::CameraNodeIntermediateDataProcessor(std::string const & nodesFile,
std::string const & speedFile)
: m_speedCameraNodeToWays(nodesFile),
m_maxSpeedFileWriter(speedFile)
{
LOG(LINFO, ("Saving intermediate data about cameras to:", nodesFile,
", about maxspeed:", speedFile));
}
void CameraNodeIntermediateDataProcessor::ProcessWay(uint64_t id, WayElement const & way)
{
std::vector<uint64_t> nodes;
for (auto const node : way.nodes)
{
if (m_speedCameraNodes.find(node) != m_speedCameraNodes.end())
nodes.push_back(node);
}
if (!nodes.empty())
generator::cache::IntermediateDataWriter::AddToIndex(m_speedCameraNodeToWays, id, nodes);
}
std::string CameraNodeIntermediateDataProcessor::ValidateMaxSpeedString(std::string const & maxSpeedString)
{
routing::SpeedInUnits speed;
if (!ParseMaxspeedTag(maxSpeedString, speed) || !speed.IsNumeric())
return std::string();
return strings::to_string(measurement_utils::ToSpeedKmPH(speed.GetSpeed(), speed.GetUnits()));
}
void CameraNodeIntermediateDataProcessor::ProcessNode(OsmElement & em)
{
for (auto const & tag : em.Tags())
{
std::string const & key(tag.key);
std::string const & value(tag.value);
if (key == "highway" && value == "speed_camera")
{
m_speedCameraNodes.insert(em.id);
}
else if (key == "maxspeed" && !value.empty())
{
WriteToSink(m_maxSpeedFileWriter, em.id);
std::string result = ValidateMaxSpeedString(value);
CHECK_LESS(result.size(), kMaxSpeedSpeedStringLength, ("Too long string for speed"));
WriteToSink(m_maxSpeedFileWriter, result.size());
m_maxSpeedFileWriter.Write(result.c_str(), result.size());
}
}
}
} // namespace generator

87
generator/camera_node_processor.hpp
View file

@ -1,87 +0,0 @@
#pragma once
#include "generator/collector_interface.hpp"
#include "generator/osm_element.hpp"
#include "generator/intermediate_data.hpp"
#include "routing/base/followed_polyline.hpp"
#include "routing/routing_helpers.hpp"
#include "indexer/ftypes_matcher.hpp"
#include "coding/file_reader.hpp"
#include "coding/file_writer.hpp"
#include "coding/write_to_sink.hpp"
#include "base/string_utils.hpp"
#include <cstdint>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <vector>
class FeatureBuilder1;
// TODO (@gmoryes) move members of m_routingTagsProcessor to generator
namespace routing
{
class CameraNodeProcessor : public generator::CollectorInterface
{
public:
CameraNodeProcessor() = default;
CameraNodeProcessor(std::string const & writerFile, std::string const & readerFile,
std::string const & speedFile);
void Open(std::string const & writerFile, std::string const & readerFile,
std::string const & speedFile);
template <typename ToDo>
void ForEachWayByNode(uint64_t id, ToDo && toDo)
{
m_cameraNodeToWays->ForEachByKey(id, std::forward<ToDo>(toDo));
}
// generator::CollectorInterface overrides:
void CollectFeature(FeatureBuilder1 const & feature, OsmElement const & p) override;
void Save() override {}
private:
using Cache = generator::cache::IndexFileReader;
std::unique_ptr<FileWriter> m_fileWriter;
std::unique_ptr<Cache> m_cameraNodeToWays;
std::map<uint64_t, std::string> m_cameraToMaxSpeed;
};
} // namespace routing
namespace generator
{
class CameraNodeIntermediateDataProcessor
{
public:
explicit CameraNodeIntermediateDataProcessor(std::string const & nodesFile, std::string const & speedFile);
static size_t const kMaxSpeedSpeedStringLength;
void ProcessNode(OsmElement & em);
void ProcessWay(uint64_t id, WayElement const & way);
void SaveIndex() { m_speedCameraNodeToWays.WriteAll(); }
private:
/// \brief Gets text with speed, returns formatted speed string in km per hour.
/// \param maxSpeedString - text with speed. Possible format:
/// "130" - means 130 km per hour.
/// "130 mph" - means 130 miles per hour.
/// "130 kmh" - means 130 km per hour.
/// See https://wiki.openstreetmap.org/wiki/Key:maxspeed
/// for more details about input string.
std::string ValidateMaxSpeedString(std::string const & maxSpeedString);
std::set<uint64_t> m_speedCameraNodes;
generator::cache::IndexFileWriter m_speedCameraNodeToWays;
FileWriter m_maxSpeedFileWriter;
};
} // namespace generator

130
generator/collector_camera.cpp Normal file
View file

@ -0,0 +1,130 @@
#include "generator/collector_camera.hpp"
#include "generator/feature_builder.hpp"
#include "generator/osm_element.hpp"
#include "generator/maxspeeds_parser.hpp"
#include "routing/routing_helpers.hpp"
#include "routing_common/maxspeed_conversion.hpp"
#include "indexer/ftypes_matcher.hpp"
#include "platform/measurement_utils.hpp"
#include "coding/point_coding.hpp"
#include "coding/write_to_sink.hpp"
#include "geometry/latlon.hpp"
#include "base/assert.hpp"
#include "base/logging.hpp"
#include "base/string_utils.hpp"
namespace routing
{
size_t const CameraProcessor::kMaxSpeedSpeedStringLength = 32;
std::string ValidateMaxSpeedString(std::string const & maxSpeedString)
{
routing::SpeedInUnits speed;
if (!generator::ParseMaxspeedTag(maxSpeedString, speed) || !speed.IsNumeric())
return std::string();
return strings::to_string(measurement_utils::ToSpeedKmPH(speed.GetSpeed(), speed.GetUnits()));
}
CameraProcessor::CameraInfo::CameraInfo(OsmElement const & element)
: m_id(element.id)
, m_lon(element.lon)
, m_lat(element.lat)
{
auto const maxspeed = element.GetTag("maxspeed");
if (!maxspeed.empty())
m_speed = ValidateMaxSpeedString(maxspeed);
}
void CameraProcessor::ForEachCamera(Fn && toDo) const
{
std::vector<uint64_t> empty;
for (auto const & p : m_speedCameras)
{
auto const & ways = m_cameraToWays.count(p.first) != 0 ? m_cameraToWays.at(p.first) : empty;
toDo(p.second, ways);
}
}
void CameraProcessor::ProcessWay(OsmElement const & element)
{
for (auto const node : element.m_nds)
{
if (m_speedCameras.find(node) == m_speedCameras.cend())
continue;
auto & ways = m_cameraToWays[node];
ways.push_back(element.id);
}
}
void CameraProcessor::ProcessNode(OsmElement const & element)
{
CameraInfo camera(element);
CHECK_LESS(camera.m_speed.size(), kMaxSpeedSpeedStringLength, ());
m_speedCameras.emplace(element.id, std::move(camera));
}
CameraCollector::CameraCollector(std::string const & writerFile) :
m_fileWriter(writerFile) {}
void CameraCollector::CollectFeature(FeatureBuilder1 const & feature, OsmElement const & element)
{
switch (element.type)
{
case OsmElement::EntityType::Node:
{
if (ftypes::IsSpeedCamChecker::Instance()(feature.GetTypes()))
m_processor.ProcessNode(element);
break;
}
case OsmElement::EntityType::Way:
{
if (routing::IsCarRoad(feature.GetTypes()))
m_processor.ProcessWay(element);
break;
}
default:
break;
}
}
void CameraCollector::Write(CameraProcessor::CameraInfo const & camera, std::vector<uint64_t> const & ways)
{
std::string maxSpeedStringKmPH = camera.m_speed;
int32_t maxSpeedKmPH = 0;
if (!strings::to_int(maxSpeedStringKmPH.c_str(), maxSpeedKmPH))
LOG(LWARNING, ("Bad speed format of camera:", maxSpeedStringKmPH, ", osmId:", camera.m_id));
CHECK_GREATER_OR_EQUAL(maxSpeedKmPH, 0, ());
uint32_t const lat =
DoubleToUint32(camera.m_lat, ms::LatLon::kMinLat, ms::LatLon::kMaxLat, kPointCoordBits);
WriteToSink(m_fileWriter, lat);
uint32_t const lon =
DoubleToUint32(camera.m_lon, ms::LatLon::kMinLon, ms::LatLon::kMaxLon, kPointCoordBits);
WriteToSink(m_fileWriter, lon);
WriteToSink(m_fileWriter, static_cast<uint32_t>(maxSpeedKmPH));
auto const size = static_cast<uint32_t>(ways.size());
WriteToSink(m_fileWriter, size);
for (auto wayId : ways)
WriteToSink(m_fileWriter, wayId);
}
void CameraCollector::Save()
{
using namespace std::placeholders;
m_processor.ForEachCamera(std::bind(&CameraCollector::Write, this, _1, _2));
}
} // namespace routing

81
generator/collector_camera.hpp Normal file
View file

@ -0,0 +1,81 @@
#pragma once
#include "generator/collector_interface.hpp"
#include "coding/file_writer.hpp"
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
namespace generator_tests
{
class TestCameraCollector;
} // namespace generator_tests
struct OsmElement;
class FeatureBuilder1;
// TODO (@gmoryes) move members of m_routingTagsProcessor to generator
namespace routing
{
/// \brief Gets text with speed, returns formatted speed string in km per hour.
/// \param maxSpeedString - text with speed. Possible format:
/// "130" - means 130 km per hour.
/// "130 mph" - means 130 miles per hour.
/// "130 kmh" - means 130 km per hour.
/// See https://wiki.openstreetmap.org/wiki/Key:maxspeed
/// for more details about input string.
std::string ValidateMaxSpeedString(std::string const & maxSpeedString);
class CameraProcessor
{
public:
struct CameraInfo;
using Fn = std::function<void (CameraInfo const &, std::vector<uint64_t> const &)>;
struct CameraInfo
{
CameraInfo(const OsmElement & element);
uint64_t m_id = 0;
double m_lon = 0.0;
double m_lat = 0.0;
std::string m_speed;
std::vector<uint64_t> m_ways;
};
static size_t const kMaxSpeedSpeedStringLength;
void ForEachCamera(Fn && toDo) const;
void ProcessNode(OsmElement const & element);
void ProcessWay(OsmElement const & element);
private:
std::unordered_map<uint64_t, CameraInfo> m_speedCameras;
std::unordered_map<uint64_t, std::vector<uint64_t>> m_cameraToWays;
};
class CameraCollector : public generator::CollectorInterface
{
public:
friend class generator_tests::TestCameraCollector;
explicit CameraCollector(std::string const & writerFile);
// generator::CollectorInterface overrides:
// We will process all nodes before ways because of o5m format:
// all nodes are first, then all ways, then all relations.
void CollectFeature(FeatureBuilder1 const & feature, OsmElement const & element) override;
void Save() override;
private:
void Write(CameraProcessor::CameraInfo const & camera, std::vector<uint64_t> const & ways);
FileWriter m_fileWriter;
CameraProcessor m_processor;
};
} // namespace routing

8
generator/emitter_factory.hpp
View file

@ -1,9 +1,10 @@
#pragma once
#include "generator/emitter_booking.hpp"
#include "generator/emitter_coastline.hpp"
#include "generator/emitter_country.hpp"
#include "generator/emitter_interface.hpp"
#include "generator/emitter_booking.hpp"
#include "generator/emitter_noop.hpp"
#include "generator/emitter_restaurants.hpp"
#include "generator/emitter_simple.hpp"
#include "generator/emitter_world.hpp"
@ -23,7 +24,8 @@ enum class EmitterType
SimpleWithPreserialize,
Country,
Coastline,
World
World,
Noop
// Booking
};
@ -44,6 +46,8 @@ std::shared_ptr<EmitterInterface> CreateEmitter(EmitterType type, Args&&... args
return create<EmitterRestaurants>(std::forward<Args>(args)...);
case EmitterType::World:
return create<EmitterWorld>(std::forward<Args>(args)...);
case EmitterType::Noop:
return create<EmitterNoop>(std::forward<Args>(args)...);
}
UNREACHABLE();
}

21
generator/emitter_noop.hpp Normal file
View file

@ -0,0 +1,21 @@
#pragma once
#include "emitter_interface.hpp"
#include <string>
#include <vector>
class FeatureBuilder1;
class FeatureParams;
namespace generator
{
class EmitterNoop : public EmitterInterface
{
public:
// EmitterInterface overrides:
void Process(FeatureBuilder1 &) override {}
bool Finish() override { return true; }
void GetNames(std::vector<std::string> &) const override {}
};
} // namespace generator

8
generator/feature_maker.cpp
View file

@ -40,7 +40,7 @@ bool FeatureMakerSimple::BuildFromWay(OsmElement & p, FeatureParams const & para
m2::PointD pt;
for (uint64_t ref : nodes)
{
if (!m_holder.GetNode(ref, pt.y, pt.x))
if (!m_cache.GetNode(ref, pt.y, pt.x))
return false;
fb.AddPoint(pt);
@ -50,8 +50,8 @@ bool FeatureMakerSimple::BuildFromWay(OsmElement & p, FeatureParams const & para
fb.SetParams(params);
if (fb.IsGeometryClosed())
{
HolesProcessor processor(p.id, m_holder);
m_holder.ForEachRelationByWay(p.id, processor);
HolesProcessor processor(p.id, m_cache);
m_cache.ForEachRelationByWay(p.id, processor);
fb.SetAreaAddHoles(processor.GetHoles());
}
else
@ -65,7 +65,7 @@ bool FeatureMakerSimple::BuildFromWay(OsmElement & p, FeatureParams const & para
bool FeatureMakerSimple::BuildFromRelation(OsmElement & p, FeatureParams const & params)
{
HolesRelation helper(m_holder);
HolesRelation helper(m_cache);
helper.Build(&p);
auto const & holesGeometry = helper.GetHoles();
auto & outer = helper.GetOuter();

10
generator/feature_maker.hpp
View file

@ -17,13 +17,13 @@ public:
protected:
// FeatureMaker overrides:
void ParseParams(FeatureParams & params, OsmElement & p) const override;
void ParseParams(FeatureParams & params, OsmElement & element) const override;
private:
// FeatureMaker overrides:
bool BuildFromNode(OsmElement & p, FeatureParams const & params) override;
bool BuildFromWay(OsmElement & p, FeatureParams const & params) override;
bool BuildFromRelation(OsmElement & p, FeatureParams const & params) override;
bool BuildFromNode(OsmElement & element, FeatureParams const & params) override;
bool BuildFromWay(OsmElement & element, FeatureParams const & params) override;
bool BuildFromRelation(OsmElement & element, FeatureParams const & params) override;
};
// The difference between class FeatureMakerSimple and class FeatureMaker is that
@ -35,6 +35,6 @@ public:
private:
// FeatureMaker overrides:
void ParseParams(FeatureParams & params, OsmElement & p) const override;
void ParseParams(FeatureParams & params, OsmElement & element) const override;
};
} // namespace generator

14
generator/feature_maker_base.cpp
View file

@ -8,20 +8,20 @@
namespace generator
{
FeatureMakerBase::FeatureMakerBase(cache::IntermediateDataReader & holder) : m_holder(holder) {}
FeatureMakerBase::FeatureMakerBase(cache::IntermediateDataReader & cache) : m_cache(cache) {}
bool FeatureMakerBase::Add(OsmElement & p)
bool FeatureMakerBase::Add(OsmElement & element)
{
FeatureParams params;
ParseParams(params, p);
switch (p.type)
ParseParams(params, element);
switch (element.type)
{
case OsmElement::EntityType::Node:
return BuildFromNode(p, params);
return BuildFromNode(element, params);
case OsmElement::EntityType::Way:
return BuildFromWay(p, params);
return BuildFromWay(element, params);
case OsmElement::EntityType::Relation:
return BuildFromRelation(p, params);
return BuildFromRelation(element, params);
default:
return false;
}

14
generator/feature_maker_base.hpp
View file

@ -19,23 +19,23 @@ class IntermediateDataReader;
class FeatureMakerBase
{
public:
explicit FeatureMakerBase(cache::IntermediateDataReader & holder);
explicit FeatureMakerBase(cache::IntermediateDataReader & cache);
virtual ~FeatureMakerBase() = default;
bool Add(OsmElement & p);
bool Add(OsmElement & element);
// The function returns true when the receiving feature was successful and a false when not successful.
bool GetNextFeature(FeatureBuilder1 & feature);
size_t Size() const;
bool Empty() const;
protected:
virtual bool BuildFromNode(OsmElement & p, FeatureParams const & params) = 0;
virtual bool BuildFromWay(OsmElement & p, FeatureParams const & params) = 0;
virtual bool BuildFromRelation(OsmElement & p, FeatureParams const & params) = 0;
virtual bool BuildFromNode(OsmElement & element, FeatureParams const & params) = 0;
virtual bool BuildFromWay(OsmElement & element, FeatureParams const & params) = 0;
virtual bool BuildFromRelation(OsmElement & element, FeatureParams const & params) = 0;
virtual void ParseParams(FeatureParams & params, OsmElement & p) const = 0;
virtual void ParseParams(FeatureParams & params, OsmElement & element) const = 0;
cache::IntermediateDataReader & m_holder;
cache::IntermediateDataReader & m_cache;
std::queue<FeatureBuilder1> m_queue;
};

1
generator/generator_tests/CMakeLists.txt
View file

@ -4,6 +4,7 @@ set(
SRC
altitude_test.cpp
brands_loader_test.cpp
camera_collector_tests.cpp
check_mwms.cpp
cities_boundaries_checker_tests.cpp
city_roads_tests.cpp

251
generator/generator_tests/camera_collector_tests.cpp Normal file
View file

@ -0,0 +1,251 @@
#include "testing/testing.hpp"
#include "platform/platform.hpp"
#include "platform/platform_tests_support/scoped_dir.hpp"
#include "platform/platform_tests_support/scoped_file.hpp"
#include "platform/platform_tests_support/writable_dir_changer.hpp"
#include "generator/collector_camera.hpp"
#include "generator/emitter_factory.hpp"
#include "generator/feature_maker.hpp"
#include "generator/generate_info.hpp"
#include "generator/intermediate_data.hpp"
#include "generator/intermediate_elements.hpp"
#include "generator/osm_source.hpp"
#include "generator/translator.hpp"
#include "indexer/classificator_loader.hpp"
#include "indexer/map_style_reader.hpp"
#include "indexer/map_style.hpp"
#include "base/macros.hpp"
#include "defines.hpp"
#include "std/string_view.hpp"
#include <cstdint>
#include <set>
#include <string>
#include <utility>
using namespace generator;
using namespace generator::cache;
using namespace feature;
using namespace platform::tests_support;
using namespace platform;
using namespace routing;
using namespace std;
namespace
{
string const kSpeedCameraTag = "<tag k=\"highway\" v=\"speed_camera\"/>";
class TranslatorForTest : public Translator
{
public:
explicit TranslatorForTest(std::shared_ptr<EmitterInterface> emitter, cache::IntermediateDataReader & cache,
feature::GenerateInfo const &)
: Translator(emitter, cache, std::make_shared<FeatureMaker>(cache)) {}
};
} // namespace
namespace generator_tests
{
class TestCameraCollector
{
public:
// Directory name for creating test mwm and temprary files.
std::string static const kTestDir;
std::string static const kOsmFileName;
TestCameraCollector()
{
GetStyleReader().SetCurrentStyle(MapStyleMerged);
classificator::Load();
}
bool Test(string const & osmSourceXML, set<pair<uint64_t, uint64_t>> & trueAnswers)
{
Platform & platform = GetPlatform();
WritableDirChanger writableDirChanger(kTestDir);
auto const & writableDir = platform.WritableDir();
ScopedDir const scopedDir(kTestDir);
auto const osmRelativePath = base::JoinPath(kTestDir, kOsmFileName);
ScopedFile const osmScopedFile(osmRelativePath, osmSourceXML);
GenerateInfo genInfo;
// Generate intermediate data.
genInfo.m_intermediateDir = writableDir;
genInfo.m_nodeStorageType = feature::GenerateInfo::NodeStorageType::Index;
genInfo.m_osmFileName = base::JoinPath(writableDir, osmRelativePath);
genInfo.m_osmFileType = feature::GenerateInfo::OsmSourceType::XML;
// Test save intermediate data is OK.
CHECK(GenerateIntermediateData(genInfo), ());
// Test load this data from cached file.
auto collector = std::make_shared<CameraCollector>(genInfo.GetIntermediateFileName(CAMERAS_TO_WAYS_FILENAME));
CacheLoader cacheLoader(genInfo);
auto emitter = CreateEmitter(EmitterType::Noop);
TranslatorForTest translator(emitter, cacheLoader.GetCache(), genInfo);
translator.AddCollector(collector);
CHECK(GenerateRaw(genInfo, translator), ());
set<pair<uint64_t, uint64_t>> answers;
collector->m_processor.ForEachCamera([&](auto const & camera, auto const & ways) {
for (auto const & w : ways)
answers.emplace(camera.m_id, w);
});
return answers == trueAnswers;
}
};
std::string const TestCameraCollector::kTestDir = "camera_test";
std::string const TestCameraCollector::kOsmFileName = "planet" OSM_DATA_FILE_EXTENSION;
} // namespace generator_tests
using namespace generator_tests;
UNIT_CLASS_TEST(TestCameraCollector, test_1)
{
string const osmSourceXML = R"(
<osm version="0.6" generator="osmconvert 0.8.4" timestamp="2018-07-16T02:00:00Z">
<node id="1" lat="55.779384" lon="37.3699375" version="1">)" + kSpeedCameraTag + R"(</node>
<node id="2" lat="55.779304" lon="37.3699375" version="1">)" + kSpeedCameraTag + R"(</node>
<node id="3" lat="55.773084" lon="37.3699375" version="1">)" + kSpeedCameraTag + R"(</node>
<node id="4" lat="55.773084" lon="37.3699375" version="1"></node>
<way id="10" version="1">
<nd ref="1"/>
<nd ref="4"/>
<tag k="highway" v="unclassified"/>
</way>
<way id="20" version="1">
<nd ref="1"/>
<nd ref="2"/>
<nd ref="3"/>
<tag k="highway" v="unclassified"/>
</way>
</osm>
)";
set<pair<uint64_t, uint64_t>> trueAnswers = {
{1, 10}, {1, 20}, {2, 20}, {3, 20}
};
TEST(TestCameraCollector::Test(osmSourceXML, trueAnswers), ());
}
UNIT_CLASS_TEST(TestCameraCollector, test_2)
{
string const osmSourceXML = R"(
<osm version="0.6" generator="osmconvert 0.8.4" timestamp="2018-07-16T02:00:00Z">
<node id="1" lat="55.779384" lon="37.3699375" version="1">)" + kSpeedCameraTag + R"(</node>
<node id="2" lat="55.779304" lon="37.3699375" version="1">)" + kSpeedCameraTag + R"(</node>
<node id="3" lat="55.773084" lon="37.3699375" version="1">)" + kSpeedCameraTag + R"(</node>
<node id="4" lat="55.773024" lon="37.3699375" version="1">)" + kSpeedCameraTag + R"(</node>
<node id="5" lat="55.773014" lon="37.3699375" version="1">)" + kSpeedCameraTag + R"(</node>
<way id="10" version="1">
<nd ref="1"/>
<nd ref="2"/>
<tag k="highway" v="unclassified"/>
</way>
<way id="20" version="1">
<nd ref="1"/>
<nd ref="3"/>
<tag k="highway" v="unclassified"/>
</way>
<way id="30" version="1">
<nd ref="1"/>
<nd ref="3"/>
<nd ref="4"/>
<nd ref="5"/>
<tag k="highway" v="unclassified"/>
</way>
</osm>
)";
set<pair<uint64_t, uint64_t>> trueAnswers = {
{1, 10}, {2, 10}, {1, 20}, {3, 20}, {1, 30}, {3, 30}, {4, 30}, {5, 30}
};
TEST(TestCameraCollector::Test(osmSourceXML, trueAnswers), ());
}
UNIT_CLASS_TEST(TestCameraCollector, test_3)
{
string const osmSourceXML = R"(
<osm version="0.6" generator="osmconvert 0.8.4" timestamp="2018-07-16T02:00:00Z">
<node id="1" lat="55.779384" lon="37.3699375" version="1">)" + kSpeedCameraTag + R"(</node>
<node id="2" lat="55.779384" lon="37.3699375" version="1"></node>
<way id="10" version="1">
<nd ref="1"/>
<nd ref="2"/>
<tag k="highway" v="unclassified"/>
</way>
<way id="20" version="1">
<nd ref="1"/>
<nd ref="2"/>
<tag k="highway" v="unclassified"/>
</way>
</osm>
)";
set<pair<uint64_t, uint64_t>> trueAnswers = {
{1, 10}, {1, 20}
};
TEST(TestCameraCollector::Test(osmSourceXML, trueAnswers), ());
}
UNIT_CLASS_TEST(TestCameraCollector, test_4)
{
string const osmSourceXML = R"(
<osm version="0.6" generator="osmconvert 0.8.4" timestamp="2018-07-16T02:00:00Z">
<node id="1" lat="55.779384" lon="37.3699375" version="1">)" + kSpeedCameraTag + R"(</node>
<way id="10" version="1">
<tag k="highway" v="unclassified"/>
</way>
<way id="20" version="1">
<tag k="highway" v="unclassified"/>
</way>
</osm>
)";
set<pair<uint64_t, uint64_t>> trueAnswers = {};
TEST(TestCameraCollector::Test(osmSourceXML, trueAnswers), ());
}
UNIT_CLASS_TEST(TestCameraCollector, test_5)
{
string const osmSourceXML = R"(
<osm version="0.6" generator="osmconvert 0.8.4" timestamp="2018-07-16T02:00:00Z">
<node id="1" lat="55.779384" lon="37.3699375" version="1"></node>
<way id="10" version="1">
<nd ref="1"/>
<tag k="highway" v="unclassified"/>
</way>
</osm>
)";
set<pair<uint64_t, uint64_t>> trueAnswers = {};
TEST(TestCameraCollector::Test(osmSourceXML, trueAnswers), ());
}

202
generator/generator_tests/intermediate_data_test.cpp
View file

@ -8,90 +8,23 @@
#include "testing/testing.hpp"
#include "platform/platform.hpp"
#include "platform/platform_tests_support/scoped_dir.hpp"
#include "platform/platform_tests_support/scoped_file.hpp"
#include "platform/platform_tests_support/writable_dir_changer.hpp"
#include "generator/camera_node_processor.hpp"
#include "generator/generate_info.hpp"
#include "generator/intermediate_data.hpp"
#include "generator/intermediate_elements.hpp"
#include "generator/osm_source.hpp"
#include "base/control_flow.hpp"
#include "base/macros.hpp"
#include "coding/reader.hpp"
#include "coding/writer.hpp"
#include "defines.hpp"
#include <cstdint>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace generator;
using namespace cache; // after generator, because it is generator::cache
using namespace feature;
using namespace platform::tests_support;
using namespace platform;
using namespace routing;
using namespace std;
namespace
{
string const kSpeedCameraTag = "<tag k=\"highway\" v=\"speed_camera\"/>";
string const kTestDir = "camera_generation_test";
void TestIntermediateData_SpeedCameraNodesToWays(
string const & osmSourceXML,
set<pair<uint64_t, uint64_t>> & trueAnswers,
uint64_t numberOfNodes)
{
// Directory name for creating test mwm and temporary files.
static string const kTestDir = "camera_nodes_to_ways_test";
static string const kOsmFileName = "town" OSM_DATA_FILE_EXTENSION;
Platform & platform = GetPlatform();
WritableDirChanger writableDirChanger(kTestDir);
string const & writableDir = platform.WritableDir();
ScopedDir const scopedDir(kTestDir);
string const osmRelativePath = base::JoinPath(kTestDir, kOsmFileName);
ScopedFile const osmScopedFile(osmRelativePath, osmSourceXML);
// Generate intermediate data.
GenerateInfo genInfo;
genInfo.m_intermediateDir = writableDir;
genInfo.m_nodeStorageType = feature::GenerateInfo::NodeStorageType::Index;
genInfo.m_osmFileName = base::JoinPath(writableDir, osmRelativePath);
genInfo.m_osmFileType = feature::GenerateInfo::OsmSourceType::XML;
// Test save intermediate data is OK.
TEST(GenerateIntermediateData(genInfo), ("Can not generate intermediate data for speed cam"));
// Test load this data from cached file.
CameraNodeProcessor cameraNodeProcessor;
cameraNodeProcessor.Open(genInfo.GetIntermediateFileName(CAMERAS_TO_WAYS_FILENAME),
genInfo.GetIntermediateFileName(CAMERAS_NODES_TO_WAYS_FILE),
genInfo.GetIntermediateFileName(CAMERAS_MAXSPEED_FILE));
for (uint64_t i = 1; i <= numberOfNodes; ++i)
{
cameraNodeProcessor.ForEachWayByNode(i, [&](uint64_t wayId)
{
auto const it = trueAnswers.find({i, wayId});
TEST(it != trueAnswers.cend(), ("Found pair that should not be here"));
trueAnswers.erase(it);
return base::ControlFlow::Continue;
});
}
TEST(trueAnswers.empty(), ("Some data wasn't cached"));
}
UNIT_TEST(Intermediate_Data_empty_way_element_save_load_test)
{
WayElement e1(1 /* fake osm id */);
@ -182,132 +115,3 @@ UNIT_TEST(Intermediate_Data_relation_element_save_load_test)
TEST_NOT_EQUAL(e2.tags["key1old"], "value1old", ());
TEST_NOT_EQUAL(e2.tags["key2old"], "value2old", ());
}
UNIT_TEST(IntermediateData_CameraNodesToWays_test_1)
{
string const osmSourceXML = R"(
<osm version="0.6" generator="osmconvert 0.8.4" timestamp="2018-07-16T02:00:00Z">
<node id="1" lat="55.779384" lon="37.3699375" version="1">)" + kSpeedCameraTag + R"(</node>
<node id="2" lat="55.779304" lon="37.3699375" version="1">)" + kSpeedCameraTag + R"(</node>
<node id="3" lat="55.773084" lon="37.3699375" version="1">)" + kSpeedCameraTag + R"(</node>
<way id="10" version="1">
<nd ref="1"/>
</way>
<way id="20" version="1">
<nd ref="1"/>
<nd ref="2"/>
<nd ref="3"/>
</way>
</osm>
)";
set<pair<uint64_t, uint64_t>> trueAnswers = {
{1, 10}, {1, 20}, {2, 20}, {3, 20}
};
TestIntermediateData_SpeedCameraNodesToWays(osmSourceXML, trueAnswers, /* number of nodes in xml = */ 3);
}
UNIT_TEST(IntermediateData_CameraNodesToWays_test_2)
{
string const osmSourceXML = R"(
<osm version="0.6" generator="osmconvert 0.8.4" timestamp="2018-07-16T02:00:00Z">
<node id="1" lat="55.779384" lon="37.3699375" version="1">)" + kSpeedCameraTag + R"(</node>
<node id="2" lat="55.779304" lon="37.3699375" version="1">)" + kSpeedCameraTag + R"(</node>
<node id="3" lat="55.773084" lon="37.3699375" version="1">)" + kSpeedCameraTag + R"(</node>
<node id="4" lat="55.773024" lon="37.3699375" version="1">)" + kSpeedCameraTag + R"(</node>
<node id="5" lat="55.773014" lon="37.3699375" version="1">)" + kSpeedCameraTag + R"(</node>
<way id="10" version="1">
<nd ref="1"/>
<nd ref="2"/>
</way>
<way id="20" version="1">
<nd ref="1"/>
<nd ref="3"/>
</way>
<way id="30" version="1">
<nd ref="1"/>
<nd ref="3"/>
<nd ref="4"/>
<nd ref="5"/>
</way>
</osm>
)";
set<pair<uint64_t, uint64_t>> trueAnswers = {
{1, 10}, {2, 10}, {1, 20}, {3, 20}, {1, 30}, {3, 30}, {4, 30}, {5, 30}
};
TestIntermediateData_SpeedCameraNodesToWays(osmSourceXML, trueAnswers, /* number of nodes in xml = */ 5);
}
UNIT_TEST(IntermediateData_CameraNodesToWays_test_3)
{
string const osmSourceXML = R"(
<osm version="0.6" generator="osmconvert 0.8.4" timestamp="2018-07-16T02:00:00Z">
<node id="1" lat="55.779384" lon="37.3699375" version="1">)" + kSpeedCameraTag + R"(</node>
<way id="10" version="1">
<nd ref="1"/>
</way>
<way id="20" version="1">
<nd ref="1"/>
</way>
</osm>
)";
set<pair<uint64_t, uint64_t>> trueAnswers = {
{1, 10}, {1, 20}
};
TestIntermediateData_SpeedCameraNodesToWays(osmSourceXML, trueAnswers, /* number of nodes in xml = */ 1);
}
UNIT_TEST(IntermediateData_CameraNodesToWays_test_4)
{
string const osmSourceXML = R"(
<osm version="0.6" generator="osmconvert 0.8.4" timestamp="2018-07-16T02:00:00Z">
<node id="1" lat="55.779384" lon="37.3699375" version="1">)" + kSpeedCameraTag + R"(</node>
<way id="10" version="1">
</way>
<way id="20" version="1">
</way>
</osm>
)";
set<pair<uint64_t, uint64_t>> trueAnswers = {};
TestIntermediateData_SpeedCameraNodesToWays(osmSourceXML, trueAnswers, /* number of nodes in xml = */ 1);
}
UNIT_TEST(IntermediateData_CameraNodesToWays_test_5)
{
string const osmSourceXML = R"(
<osm version="0.6" generator="osmconvert 0.8.4" timestamp="2018-07-16T02:00:00Z">
<node id="1" lat="55.779384" lon="37.3699375" version="1"></node>
<way id="10" version="1">
<nd ref="1"/>
</way>
</osm>
)";
set<pair<uint64_t, uint64_t>> trueAnswers = {};
TestIntermediateData_SpeedCameraNodesToWays(osmSourceXML, trueAnswers, /* number of nodes in xml = */ 1);
}
} // namespace

1
generator/generator_tests/maxspeeds_tests.cpp
View file

@ -8,6 +8,7 @@
#include "routing/maxspeeds_serialization.hpp"
#include "routing/maxspeeds.hpp"
#include "routing/routing_helpers.hpp"
#include "routing_common/maxspeed_conversion.hpp"

14
generator/holes.cpp
View file

@ -7,8 +7,8 @@
namespace generator
{
HolesAccumulator::HolesAccumulator(cache::IntermediateDataReader & holder) :
m_merger(holder)
HolesAccumulator::HolesAccumulator(cache::IntermediateDataReader & cache) :
m_merger(cache)
{
}
@ -23,9 +23,9 @@ FeatureBuilder1::Geometry & HolesAccumulator::GetHoles()
return m_holes;
}
HolesProcessor::HolesProcessor(uint64_t id, cache::IntermediateDataReader & holder) :
HolesProcessor::HolesProcessor(uint64_t id, cache::IntermediateDataReader & cache) :
m_id(id),
m_holes(holder)
m_holes(cache)
{
}
@ -51,9 +51,9 @@ void HolesProcessor::operator() (uint64_t id, std::string const & role)
m_holes(id);
}
HolesRelation::HolesRelation(cache::IntermediateDataReader & holder) :
m_holes(holder),
m_outer(holder)
HolesRelation::HolesRelation(cache::IntermediateDataReader & cache) :
m_holes(cache),
m_outer(cache)
{
}

6
generator/holes.hpp
View file

@ -19,7 +19,7 @@ class IntermediateDataReader;
class HolesAccumulator
{
public:
explicit HolesAccumulator(cache::IntermediateDataReader & holder);
explicit HolesAccumulator(cache::IntermediateDataReader & cache);
void operator() (uint64_t id) { m_merger.AddWay(id); }
FeatureBuilder1::Geometry & GetHoles();
@ -33,7 +33,7 @@ private:
class HolesProcessor
{
public:
explicit HolesProcessor(uint64_t id, cache::IntermediateDataReader & holder);
explicit HolesProcessor(uint64_t id, cache::IntermediateDataReader & cache);
/// 1. relations process function
base::ControlFlow operator() (uint64_t /* id */, RelationElement const & e);
@ -49,7 +49,7 @@ private:
class HolesRelation
{
public:
explicit HolesRelation(cache::IntermediateDataReader & holder);
explicit HolesRelation(cache::IntermediateDataReader & cache);
void Build(OsmElement const * p);
FeatureBuilder1::Geometry & GetHoles() { return m_holes.GetHoles(); }

1
generator/maxspeeds_builder.cpp
View file

@ -4,6 +4,7 @@
#include "generator/routing_helpers.hpp"
#include "routing/maxspeeds_serialization.hpp"
#include "routing/routing_helpers.hpp"
#include "routing_common/maxspeed_conversion.hpp"

47
generator/osm_source.cpp
View file

@ -1,6 +1,5 @@
#include "generator/osm_source.hpp"
#include "generator/camera_node_processor.hpp"
#include "generator/intermediate_elements.hpp"
#include "generator/node_mixer.hpp"
#include "generator/osm_element.hpp"
@ -54,8 +53,7 @@ uint64_t SourceReader::Read(char * buffer, uint64_t bufferSize)
}
// Functions ---------------------------------------------------------------------------------------
void AddElementToCache(cache::IntermediateDataWriter & cache,
CameraNodeIntermediateDataProcessor & cameras, OsmElement & em)
void AddElementToCache(cache::IntermediateDataWriter & cache, OsmElement & em)
{
switch (em.type)
{
@ -63,7 +61,6 @@ void AddElementToCache(cache::IntermediateDataWriter & cache,
{
auto const pt = MercatorBounds::FromLatLon(em.lat, em.lon);
cache.AddNode(em.id, pt.y, pt.x);
cameras.ProcessNode(em);
break;
}
case OsmElement::EntityType::Way:
@ -74,10 +71,7 @@ void AddElementToCache(cache::IntermediateDataWriter & cache,
way.nodes.push_back(nd);
if (way.IsValid())
{
cache.AddWay(em.id, way);
cameras.ProcessWay(em.id, way);
}
break;
}
case OsmElement::EntityType::Relation:
@ -115,28 +109,28 @@ void AddElementToCache(cache::IntermediateDataWriter & cache,
}
void BuildIntermediateDataFromXML(SourceReader & stream, cache::IntermediateDataWriter & cache,
TownsDumper & towns, CameraNodeIntermediateDataProcessor & cameras)
TownsDumper & towns)
{
XMLSource parser([&](OsmElement * e)
XMLSource parser([&](OsmElement * element)
{
towns.CheckElement(*e);
AddElementToCache(cache, cameras, *e);
towns.CheckElement(*element);
AddElementToCache(cache, *element);
});
ParseXMLSequence(stream, parser);
}
void ProcessOsmElementsFromXML(SourceReader & stream, function<void(OsmElement *)> processor)
{
XMLSource parser([&](OsmElement * e) { processor(e); });
XMLSource parser([&](OsmElement * element) { processor(element); });
ParseXMLSequence(stream, parser);
}
void BuildIntermediateDataFromO5M(SourceReader & stream, cache::IntermediateDataWriter & cache,
TownsDumper & towns, CameraNodeIntermediateDataProcessor & cameras)
TownsDumper & towns)
{
auto processor = [&cache, &cameras, &towns](OsmElement * em) {
towns.CheckElement(*em);
AddElementToCache(cache, cameras, *em);
auto processor = [&](OsmElement * element) {
towns.CheckElement(*element);
AddElementToCache(cache, *element);
};
// Use only this function here, look into ProcessOsmElementsFromO5M
@ -213,10 +207,9 @@ void ProcessOsmElementsFromO5M(SourceReader & stream, function<void(OsmElement *
bool GenerateRaw(feature::GenerateInfo & info, TranslatorInterface & translators)
{
auto const fn = [&](OsmElement * e) {
CHECK(e, ());
auto & element = *e;
translators.Emit(element);
auto const fn = [&](OsmElement * element) {
CHECK(element, ());
translators.Emit(*element);
};
SourceReader reader = info.m_osmFileName.empty() ? SourceReader() : SourceReader(info.m_osmFileName);
@ -254,10 +247,10 @@ CacheLoader::CacheLoader(feature::GenerateInfo & info) : m_info(info) {}
cache::IntermediateDataReader & CacheLoader::GetCache()
{
if (!m_loader)
m_loader = std::make_unique<LoaderWrapper>(m_info);
if (!m_loader)
m_loader = std::make_unique<LoaderWrapper>(m_info);
return m_loader->GetReader();
return m_loader->GetReader();
}
bool GenerateIntermediateData(feature::GenerateInfo & info)
@ -268,9 +261,6 @@ bool GenerateIntermediateData(feature::GenerateInfo & info)
info.GetIntermediateFileName(NODES_FILE));
cache::IntermediateDataWriter cache(nodes, info);
TownsDumper towns;
CameraNodeIntermediateDataProcessor cameras(info.GetIntermediateFileName(CAMERAS_NODES_TO_WAYS_FILE),
info.GetIntermediateFileName(CAMERAS_MAXSPEED_FILE));
SourceReader reader = info.m_osmFileName.empty() ? SourceReader() : SourceReader(info.m_osmFileName);
LOG(LINFO, ("Data source:", info.m_osmFileName));
@ -278,15 +268,14 @@ bool GenerateIntermediateData(feature::GenerateInfo & info)
switch (info.m_osmFileType)
{
case feature::GenerateInfo::OsmSourceType::XML:
BuildIntermediateDataFromXML(reader, cache, towns, cameras);
BuildIntermediateDataFromXML(reader, cache, towns);
break;
case feature::GenerateInfo::OsmSourceType::O5M:
BuildIntermediateDataFromO5M(reader, cache, towns, cameras);
BuildIntermediateDataFromO5M(reader, cache, towns);
break;
}
cache.SaveIndex();
cameras.SaveIndex();
towns.Dump(info.GetIntermediateFileName(TOWNS_FILE));
LOG(LINFO, ("Added points count =", nodes->GetNumProcessedPoints()));
}

7
generator/routing_helpers.hpp
View file

@ -1,12 +1,5 @@
#pragma once
#include "generator/camera_node_processor.hpp"
#include "generator/maxspeeds_collector.hpp"
#include "generator/restriction_writer.hpp"
#include "generator/road_access_generator.hpp"
#include "routing/cross_mwm_ids.hpp"
#include "base/geo_object_id.hpp"
#include <cstdint>

10
generator/translator.cpp
View file

@ -9,22 +9,22 @@
namespace generator
{
Translator::Translator(std::shared_ptr<EmitterInterface> emitter, cache::IntermediateDataReader & holder,
Translator::Translator(std::shared_ptr<EmitterInterface> emitter, cache::IntermediateDataReader & cache,
std::shared_ptr<FeatureMakerBase> maker, FilterCollection const & filters,
CollectorCollection const & collectors)
: m_filters(filters)
, m_collectors(collectors)
, m_tagsEnricher(holder)
, m_tagsEnricher(cache)
, m_featureMaker(maker)
, m_emitter(emitter)
, m_holder(holder)
, m_cache(cache)
{
CHECK(m_emitter, ());
}
Translator::Translator(std::shared_ptr<EmitterInterface> emitter, cache::IntermediateDataReader & holder,
Translator::Translator(std::shared_ptr<EmitterInterface> emitter, cache::IntermediateDataReader & cache,
std::shared_ptr<FeatureMakerBase> maker)
: Translator(emitter, holder, maker, {} /* filters */, {} /* collectors */) {}
: Translator(emitter, cache, maker, {} /* filters */, {} /* collectors */) {}
void Translator::Emit(OsmElement & element)
{

6
generator/translator.hpp
View file

@ -28,10 +28,10 @@ class IntermediateDataReader;
class Translator : public TranslatorInterface
{
public:
explicit Translator(std::shared_ptr<EmitterInterface> emitter, cache::IntermediateDataReader & holder,
explicit Translator(std::shared_ptr<EmitterInterface> emitter, cache::IntermediateDataReader & cache,
std::shared_ptr<FeatureMakerBase> maker, FilterCollection const & filters,
CollectorCollection const & collectors);
explicit Translator(std::shared_ptr<EmitterInterface> emitter, cache::IntermediateDataReader & holder,
explicit Translator(std::shared_ptr<EmitterInterface> emitter, cache::IntermediateDataReader & cache,
std::shared_ptr<FeatureMakerBase> maker);
// TranslatorInterface overrides:
@ -51,6 +51,6 @@ protected:
RelationTagsEnricher m_tagsEnricher;
std::shared_ptr<FeatureMakerBase> m_featureMaker;
std::shared_ptr<EmitterInterface> m_emitter;
cache::IntermediateDataReader & m_holder;
cache::IntermediateDataReader & m_cache;
};
} // namespace generator

4
generator/translator_coastline.cpp
View file

@ -30,8 +30,8 @@ public:
} // namespace
TranslatorCoastline::TranslatorCoastline(std::shared_ptr<EmitterInterface> emitter,
cache::IntermediateDataReader & holder)
: Translator(emitter, holder, std::make_shared<FeatureMaker>(holder))
cache::IntermediateDataReader & cache)
: Translator(emitter, cache, std::make_shared<FeatureMaker>(cache))
{
AddFilter(std::make_shared<FilterPlanet>());
AddFilter(std::make_shared<CoastlineFilter>());

2
generator/translator_coastline.hpp
View file

@ -22,6 +22,6 @@ class TranslatorCoastline : public Translator
{
public:
explicit TranslatorCoastline(std::shared_ptr<EmitterInterface> emitter,
cache::IntermediateDataReader & holder);
cache::IntermediateDataReader & cache);
};
} // namespace generator

15
generator/translator_country.cpp
View file

@ -1,7 +1,7 @@
#include "generator/translator_country.hpp"
#include "generator/camera_node_processor.hpp"
#include "generator/collector_addresses.hpp"
#include "generator/collector_camera.hpp"
#include "generator/collector_interface.hpp"
#include "generator/collector_tag.hpp"
#include "generator/feature_maker.hpp"
@ -69,9 +69,9 @@ bool WikiDataValidator(std::string const & tagValue)
}
} // namespace
TranslatorCountry::TranslatorCountry(std::shared_ptr<EmitterInterface> emitter, cache::IntermediateDataReader & holder,
TranslatorCountry::TranslatorCountry(std::shared_ptr<EmitterInterface> emitter, cache::IntermediateDataReader & cache,
feature::GenerateInfo const & info)
: Translator(emitter, holder, std::make_shared<FeatureMaker>(holder))
: Translator(emitter, cache, std::make_shared<FeatureMaker>(cache))
, m_tagAdmixer(info.GetIntermediateFileName("ways", ".csv"), info.GetIntermediateFileName("towns", ".csv"))
, m_tagReplacer(base::JoinPath(GetPlatform().ResourcesDir(), REPLACED_TAGS_FILE))
, m_osmTagMixer(base::JoinPath(GetPlatform().ResourcesDir(), MIXED_TAGS_FILE))
@ -87,9 +87,8 @@ TranslatorCountry::TranslatorCountry(std::shared_ptr<EmitterInterface> emitter,
AddCollector(std::make_shared<MaxspeedsCollector>(info.GetIntermediateFileName(MAXSPEEDS_FILENAME)));
AddCollector(std::make_shared<routing::RestrictionWriter>(info.GetIntermediateFileName(RESTRICTIONS_FILENAME)));
AddCollector(std::make_shared<routing::RoadAccessWriter>(info.GetIntermediateFileName(ROAD_ACCESS_FILENAME)));
AddCollector(std::make_shared<routing::CameraNodeProcessor>(info.GetIntermediateFileName(CAMERAS_TO_WAYS_FILENAME),
info.GetIntermediateFileName(CAMERAS_NODES_TO_WAYS_FILE),
info.GetIntermediateFileName(CAMERAS_MAXSPEED_FILE)));
AddCollector(std::make_shared<routing::CameraCollector>(info.GetIntermediateFileName(CAMERAS_TO_WAYS_FILENAME)));
if (info.m_genAddresses)
AddCollector(std::make_shared<CollectorAddresses>(info.GetAddressesFileName()));
}
@ -107,8 +106,8 @@ void TranslatorCountry::CollectFromRelations(OsmElement const & element)
{
RelationCollector collector(m_collectors);
if (element.IsNode())
m_holder.ForEachRelationByNodeCached(element.id, collector);
m_cache.ForEachRelationByNodeCached(element.id, collector);
else if (element.IsWay())
m_holder.ForEachRelationByWayCached(element.id, collector);
m_cache.ForEachRelationByWayCached(element.id, collector);
}
} // namespace generator

2
generator/translator_country.hpp
View file

@ -22,7 +22,7 @@ namespace generator
class TranslatorCountry : public Translator
{
public:
explicit TranslatorCountry(std::shared_ptr<EmitterInterface> emitter, cache::IntermediateDataReader & holder,
explicit TranslatorCountry(std::shared_ptr<EmitterInterface> emitter, cache::IntermediateDataReader & cache,
feature::GenerateInfo const & info);
// TranslatorInterface overrides:

4
generator/translator_geo_objects.cpp
View file

@ -27,8 +27,8 @@ public:
} // namespace
TranslatorGeoObjects::TranslatorGeoObjects(std::shared_ptr<EmitterInterface> emitter,
cache::IntermediateDataReader & holder)
: Translator(emitter, holder, std::make_shared<FeatureMakerSimple>(holder))
cache::IntermediateDataReader & cache)
: Translator(emitter, cache, std::make_shared<FeatureMakerSimple>(cache))
{
AddFilter(std::make_shared<FilterGeoObjects>());

2
generator/translator_geo_objects.hpp
View file

@ -18,6 +18,6 @@ class TranslatorGeoObjects : public Translator
{
public:
explicit TranslatorGeoObjects(std::shared_ptr<EmitterInterface> emitter,
cache::IntermediateDataReader & holder);
cache::IntermediateDataReader & cache);
};
} // namespace generator

2
generator/translator_interface.hpp
View file

@ -13,7 +13,7 @@ class TranslatorInterface
public:
virtual ~TranslatorInterface() = default;
virtual void Preprocess(OsmElement & element) {}
virtual void Preprocess(OsmElement &) {}
virtual void Emit(OsmElement & element) = 0;
virtual bool Finish() = 0;
virtual void GetNames(std::vector<std::string> & names) const = 0;

4
generator/translator_region.cpp
View file

@ -41,9 +41,9 @@ public:
};
} // namespace
TranslatorRegion::TranslatorRegion(std::shared_ptr<EmitterInterface> emitter, cache::IntermediateDataReader & holder,
TranslatorRegion::TranslatorRegion(std::shared_ptr<EmitterInterface> emitter, cache::IntermediateDataReader & cache,
feature::GenerateInfo const & info)
: Translator(emitter, holder, std::make_shared<FeatureMakerSimple>(holder))
: Translator(emitter, cache, std::make_shared<FeatureMakerSimple>(cache))
{
AddFilter(std::make_shared<FilterRegions>());

2
generator/translator_region.hpp
View file

@ -21,7 +21,7 @@ namespace generator
class TranslatorRegion : public Translator
{
public:
explicit TranslatorRegion(std::shared_ptr<EmitterInterface> emitter, cache::IntermediateDataReader & holder,
explicit TranslatorRegion(std::shared_ptr<EmitterInterface> emitter, cache::IntermediateDataReader & cache,
feature::GenerateInfo const & info);
};
} // namespace generator

4
generator/translator_world.cpp
View file

@ -14,9 +14,9 @@
namespace generator
{
TranslatorWorld::TranslatorWorld(std::shared_ptr<EmitterInterface> emitter, cache::IntermediateDataReader & holder,
TranslatorWorld::TranslatorWorld(std::shared_ptr<EmitterInterface> emitter, cache::IntermediateDataReader & cache,
feature::GenerateInfo const & info)
: Translator(emitter, holder, std::make_shared<FeatureMaker>(holder))
: Translator(emitter, cache, std::make_shared<FeatureMaker>(cache))
, m_tagAdmixer(info.GetIntermediateFileName("ways", ".csv"), info.GetIntermediateFileName("towns", ".csv"))
, m_tagReplacer(GetPlatform().ResourcesDir() + REPLACED_TAGS_FILE)
, m_osmTagMixer(GetPlatform().ResourcesDir() + MIXED_TAGS_FILE)

2
generator/translator_world.hpp
View file

@ -22,7 +22,7 @@ namespace generator
class TranslatorWorld : public Translator
{
public:
explicit TranslatorWorld(std::shared_ptr<EmitterInterface> emitter, cache::IntermediateDataReader & holder,
explicit TranslatorWorld(std::shared_ptr<EmitterInterface> emitter, cache::IntermediateDataReader & cache,
feature::GenerateInfo const & info);
// TranslatorInterface overrides:

6
generator/ways_merger.cpp
View file

@ -2,15 +2,15 @@
namespace generator
{
AreaWayMerger::AreaWayMerger(cache::IntermediateDataReader & holder) :
m_holder(holder)
AreaWayMerger::AreaWayMerger(cache::IntermediateDataReader & cache) :
m_cache(cache)
{
}
void AreaWayMerger::AddWay(uint64_t id)
{
auto e = std::make_shared<WayElement>(id);
if (m_holder.GetWay(id, *e) && e->IsValid())
if (m_cache.GetWay(id, *e) && e->IsValid())
{
m_map.emplace(e->nodes.front(), e);
m_map.emplace(e->nodes.back(), e);

6
generator/ways_merger.hpp
View file

@ -20,7 +20,7 @@ class AreaWayMerger
using WayMapIterator = WayMap::iterator;
public:
explicit AreaWayMerger(cache::IntermediateDataReader & holder);
explicit AreaWayMerger(cache::IntermediateDataReader & cache);
void AddWay(uint64_t id);
@ -46,7 +46,7 @@ public:
e->ForEachPointOrdered(id, [this, &points](uint64_t id)
{
m2::PointD pt;
if (m_holder.GetNode(id, pt.y, pt.x))
if (m_cache.GetNode(id, pt.y, pt.x))
points.push_back(pt);
});
@ -76,7 +76,7 @@ public:
}
private:
cache::IntermediateDataReader & m_holder;
cache::IntermediateDataReader & m_cache;
WayMap m_map;
};
} // namespace generator