[generator] Collecting speed cameras now only stage 'features'.

10 files changed, 248 insertions, 238 deletions

diff --git a/generator/CMakeLists.txt b/generator/CMakeLists.txt
index f63dc82f58..00ff760778 100644
--- a/generator/CMakeLists.txt
+++ b/generator/CMakeLists.txt
@@ -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
diff --git a/generator/camera_node_processor.cpp b/generator/camera_node_processor.cpp
index 7718e78ac5..671a6afc40 100644
--- a/generator/camera_node_processor.cpp
+++ b/generator/camera_node_processor.cpp
@@ -1,153 +1,128 @@
 #include "generator/camera_node_processor.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/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)
+size_t const CameraProcessor::kMaxSpeedSpeedStringLength = 32;
+
+void CameraProcessor::ForEachCamera(Fn && toDo) const
 {
-  Open(writerFile, readerFile, speedFile);
+  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 CameraNodeProcessor::Open(std::string const & writerFile, std::string const & readerFile,
-                               std::string const & speedFile)
+void CameraProcessor::ProcessWay(OsmElement const & element)
 {
-  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)
+  for (auto const node : element.m_nds)
   {
-    ReadPrimitiveFromSource(src, nodeOsmId);
+    if (m_speedCameras.find(node) == m_speedCameras.cend())
+      continue;
 
-    ReadPrimitiveFromSource(src, maxSpeedStringLength);
-    CHECK_LESS(maxSpeedStringLength, kMaxSpeedSpeedStringLength, ("Too long maxspeed string"));
+    auto & ways = m_cameraToWays[node];
+    ways.push_back(element.id);
+  }
+}
 
-    src.Read(buffer.data(), maxSpeedStringLength);
-    buffer[maxSpeedStringLength] = '\0';
+// static
+std::string CameraProcessor::ValidateMaxSpeedString(std::string const & maxSpeedString)
+{
+  routing::SpeedInUnits speed;
+  if (!generator::ParseMaxspeedTag(maxSpeedString, speed) || !speed.IsNumeric())
+    return std::string();
 
-    m_cameraToMaxSpeed[nodeOsmId] = buffer.data();
-  }
+  return strings::to_string(measurement_utils::ToSpeedKmPH(speed.GetSpeed(), speed.GetUnits()));
 }
 
-void CameraNodeProcessor::CollectFeature(FeatureBuilder1 const & feature, OsmElement const & p)
+void CameraProcessor::ProcessNode(OsmElement const & element)
 {
-  if (!(p.type == OsmElement::EntityType::Node && ftypes::IsSpeedCamChecker::Instance()(feature.GetTypes())))
-    return;
+  CameraInfo camera;
+  camera.m_id = element.id;
+  camera.m_lat = element.lat;
+  camera.m_lon = element.lon;
+  auto const maxspeed = element.GetTag("maxspeed");
+  if (!maxspeed.empty())
+    camera.m_speed = ValidateMaxSpeedString(maxspeed);
+
+  CHECK_LESS(camera.m_speed.size(), kMaxSpeedSpeedStringLength, ("Too long string for speed"));
+  m_speedCameras.emplace(element.id, std::move(camera));
+}
 
-  std::string maxSpeedStringKmPH = "0";
-  auto const it = m_cameraToMaxSpeed.find(p.id);
-  if (it != m_cameraToMaxSpeed.cend())
-    maxSpeedStringKmPH = it->second;
+CameraNodeProcessor::CameraNodeProcessor(std::string const & writerFile) :
+  m_fileWriter(writerFile) {}
 
+void CameraNodeProcessor::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 CameraNodeProcessor::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:", p.id));
+    LOG(LWARNING, ("Bad speed format of camera:", maxSpeedStringKmPH, ", osmId:", camera.m_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);
+      DoubleToUint32(camera.m_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);
+      DoubleToUint32(camera.m_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;
-  });
+  WriteToSink(m_fileWriter, static_cast<uint32_t>(maxSpeedKmPH));
 
   auto const size = static_cast<uint32_t>(ways.size());
-  WriteToSink(*m_fileWriter, size);
+  WriteToSink(m_fileWriter, size);
   for (auto wayId : ways)
-    WriteToSink(*m_fileWriter, wayId);
+    WriteToSink(m_fileWriter, wayId);
 }
-}  // namespace routing
 
-namespace generator
-{
-CameraNodeIntermediateDataProcessor::CameraNodeIntermediateDataProcessor(std::string const & nodesFile,
-                                                                         std::string const & speedFile)
-  : m_speedCameraNodeToWays(nodesFile),
-    m_maxSpeedFileWriter(speedFile)
+void CameraNodeProcessor::Save()
 {
-  LOG(LINFO, ("Saving intermediate data about cameras to:", nodesFile,
-              ", about maxspeed:", speedFile));
+  using namespace std::placeholders;
+  m_processor.ForEachCamera(std::bind(&CameraNodeProcessor::Write, this, _1, _2));
 }
-
-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
+}  // namespace routing
diff --git a/generator/camera_node_processor.hpp b/generator/camera_node_processor.hpp
index c23b1665e4..4242250f53 100644
--- a/generator/camera_node_processor.hpp
+++ b/generator/camera_node_processor.hpp
@@ -1,74 +1,47 @@
 #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 <functional>
 #include <memory>
-#include <set>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
+namespace generator_tests
+{
+class TestCameraNodeProcessor;
+}  // namespace generator_tests
+
+struct OsmElement;
 class FeatureBuilder1;
+
 // TODO (@gmoryes) move members of m_routingTagsProcessor to generator
 namespace routing
 {
-class CameraNodeProcessor : public generator::CollectorInterface
+class CameraProcessor
 {
 public:
-  CameraNodeProcessor() = default;
-  CameraNodeProcessor(std::string const & writerFile, std::string const & readerFile,
-                      std::string const & speedFile);
+  struct CameraInfo;
+  using Fn = std::function<void (CameraInfo const &, std::vector<uint64_t> const &)>;
 
-  void Open(std::string const & writerFile, std::string const & readerFile,
-            std::string const & speedFile);
-
-  template <typename ToDo>
-  void ForEachWayByNode(uint64_t id, ToDo && toDo)
+  struct CameraInfo
   {
-    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);
+    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 ProcessNode(OsmElement & em);
-
-  void ProcessWay(uint64_t id, WayElement const & way);
-
-  void SaveIndex() { m_speedCameraNodeToWays.WriteAll(); }
+  void ForEachCamera(Fn && toDo) const;
+  void ProcessNode(OsmElement const & element);
+  void ProcessWay(OsmElement const & element);
 
 private:
   /// \brief Gets text with speed, returns formatted speed string in km per hour.
@@ -78,10 +51,27 @@ private:
   ///                         "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);
+  static std::string ValidateMaxSpeedString(std::string const & maxSpeedString);
+
+  std::unordered_map<uint64_t, CameraInfo> m_speedCameras;
+  std::unordered_map<uint64_t, std::vector<uint64_t>> m_cameraToWays;
+};
+
+class CameraNodeProcessor : public generator::CollectorInterface
+{
+public:
+  friend class generator_tests::TestCameraNodeProcessor;
+
+  explicit CameraNodeProcessor(std::string const & writerFile);
+
+  // generator::CollectorInterface overrides:
+  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);
 
-  std::set<uint64_t> m_speedCameraNodes;
-  generator::cache::IndexFileWriter m_speedCameraNodeToWays;
-  FileWriter m_maxSpeedFileWriter;
+  FileWriter m_fileWriter;
+  CameraProcessor m_processor;
 };
-}  // namespace generator
+}  // namespace routing
diff --git a/generator/emitter_factory.hpp b/generator/emitter_factory.hpp
index 265e9cee3d..c212fb5247 100644
--- a/generator/emitter_factory.hpp
+++ b/generator/emitter_factory.hpp
@@ -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();
 }
diff --git a/generator/emitter_noop.hpp b/generator/emitter_noop.hpp
new file mode 100644
index 0000000000..64202ab11c
--- /dev/null
+++ b/generator/emitter_noop.hpp
@@ -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
diff --git a/generator/generator_tests/intermediate_data_test.cpp b/generator/generator_tests/intermediate_data_test.cpp
index 84c56f9ba6..bf1ad0264a 100644
--- a/generator/generator_tests/intermediate_data_test.cpp
+++ b/generator/generator_tests/intermediate_data_test.cpp
@@ -14,10 +14,13 @@
 #include "platform/platform_tests_support/writable_dir_changer.hpp"
 
 #include "generator/camera_node_processor.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 "base/control_flow.hpp"
 #include "base/macros.hpp"
@@ -42,55 +45,67 @@ 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)
+class TranslatorForTest : public Translator
 {
-  // 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;
+public:
+  explicit TranslatorForTest(std::shared_ptr<EmitterInterface> emitter, cache::IntermediateDataReader & holder,
+                             feature::GenerateInfo const &)
+    : Translator(emitter, holder, std::make_shared<FeatureMaker>(holder)) {}
+};
+}  // namespace
 
-  Platform & platform = GetPlatform();
+namespace generator_tests
+{
+class TestCameraNodeProcessor
+{
+public:
+  bool Test(string const & osmSourceXML, set<pair<uint64_t, uint64_t>> & trueAnswers)
+  {
+    // 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;
 
-  WritableDirChanger writableDirChanger(kTestDir);
+    Platform & platform = GetPlatform();
 
-  string const & writableDir = platform.WritableDir();
+    WritableDirChanger writableDirChanger(kTestDir);
 
-  ScopedDir const scopedDir(kTestDir);
+    string const & writableDir = platform.WritableDir();
 
-  string const osmRelativePath = base::JoinPath(kTestDir, kOsmFileName);
-  ScopedFile const osmScopedFile(osmRelativePath, osmSourceXML);
+    ScopedDir const scopedDir(kTestDir);
 
-  // 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;
+    string const osmRelativePath = base::JoinPath(kTestDir, kOsmFileName);
+    ScopedFile const osmScopedFile(osmRelativePath, osmSourceXML);
 
-  // Test save intermediate data is OK.
-  TEST(GenerateIntermediateData(genInfo), ("Can not generate intermediate data for speed cam"));
+    // 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 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));
+    // Test save intermediate data is OK.
+    CHECK(GenerateIntermediateData(genInfo), ());
 
-  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 load this data from cached file.
+    auto collector = std::make_shared<CameraNodeProcessor>(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;
   }
+};
+} // namespace generator_tests
 
-  TEST(trueAnswers.empty(), ("Some data wasn't cached"));
-}
+using namespace generator_tests;
 
 UNIT_TEST(Intermediate_Data_empty_way_element_save_load_test)
 {
@@ -183,7 +198,7 @@ UNIT_TEST(Intermediate_Data_relation_element_save_load_test)
   TEST_NOT_EQUAL(e2.tags["key2old"], "value2old", ());
 }
 
-UNIT_TEST(IntermediateData_CameraNodesToWays_test_1)
+UNIT_CLASS_TEST(TestCameraNodeProcessor, CameraNodesToWays_test_1)
 {
   string const osmSourceXML = R"(
 <osm version="0.6" generator="osmconvert 0.8.4" timestamp="2018-07-16T02:00:00Z">
@@ -191,14 +206,18 @@ UNIT_TEST(IntermediateData_CameraNodesToWays_test_1)
     <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>
@@ -208,10 +227,10 @@ UNIT_TEST(IntermediateData_CameraNodesToWays_test_1)
     {1, 10}, {1, 20}, {2, 20}, {3, 20}
   };
 
-  TestIntermediateData_SpeedCameraNodesToWays(osmSourceXML, trueAnswers, /* number of nodes in xml = */ 3);
+  TEST(TestCameraNodeProcessor::Test(osmSourceXML, trueAnswers), ());
 }
 
-UNIT_TEST(IntermediateData_CameraNodesToWays_test_2)
+UNIT_CLASS_TEST(TestCameraNodeProcessor, CameraNodesToWays_test_2)
 {
   string const osmSourceXML = R"(
 <osm version="0.6" generator="osmconvert 0.8.4" timestamp="2018-07-16T02:00:00Z">
@@ -225,16 +244,19 @@ UNIT_TEST(IntermediateData_CameraNodesToWays_test_2)
     <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>
@@ -244,21 +266,26 @@ UNIT_TEST(IntermediateData_CameraNodesToWays_test_2)
     {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);
+  TEST(TestCameraNodeProcessor::Test(osmSourceXML, trueAnswers), ());
 }
 
-UNIT_TEST(IntermediateData_CameraNodesToWays_test_3)
+UNIT_CLASS_TEST(TestCameraNodeProcessor, 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>
+    <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>
@@ -268,11 +295,10 @@ UNIT_TEST(IntermediateData_CameraNodesToWays_test_3)
     {1, 10}, {1, 20}
   };
 
-  TestIntermediateData_SpeedCameraNodesToWays(osmSourceXML, trueAnswers, /* number of nodes in xml = */ 1);
+  TEST(TestCameraNodeProcessor::Test(osmSourceXML, trueAnswers), ());
 }
 
-
-UNIT_TEST(IntermediateData_CameraNodesToWays_test_4)
+UNIT_CLASS_TEST(TestCameraNodeProcessor, CameraNodesToWays_test_4)
 {
   string const osmSourceXML = R"(
 <osm version="0.6" generator="osmconvert 0.8.4" timestamp="2018-07-16T02:00:00Z">
@@ -280,8 +306,10 @@ UNIT_TEST(IntermediateData_CameraNodesToWays_test_4)
     <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>
@@ -289,10 +317,10 @@ UNIT_TEST(IntermediateData_CameraNodesToWays_test_4)
 
   set<pair<uint64_t, uint64_t>> trueAnswers = {};
 
-  TestIntermediateData_SpeedCameraNodesToWays(osmSourceXML, trueAnswers, /* number of nodes in xml = */ 1);
+  TEST(TestCameraNodeProcessor::Test(osmSourceXML, trueAnswers), ());
 }
 
-UNIT_TEST(IntermediateData_CameraNodesToWays_test_5)
+UNIT_CLASS_TEST(TestCameraNodeProcessor, CameraNodesToWays_test_5)
 {
   string const osmSourceXML = R"(
 <osm version="0.6" generator="osmconvert 0.8.4" timestamp="2018-07-16T02:00:00Z">
@@ -301,6 +329,7 @@ UNIT_TEST(IntermediateData_CameraNodesToWays_test_5)
 
     <way id="10" version="1">
       <nd ref="1"/>
+      <tag k="highway" v="unclassified"/>
     </way>
 
   </osm>
@@ -308,6 +337,5 @@ UNIT_TEST(IntermediateData_CameraNodesToWays_test_5)
 
   set<pair<uint64_t, uint64_t>> trueAnswers = {};
 
-  TestIntermediateData_SpeedCameraNodesToWays(osmSourceXML, trueAnswers, /* number of nodes in xml = */ 1);
+  TEST(TestCameraNodeProcessor::Test(osmSourceXML, trueAnswers), ());
 }
-}  // namespace
diff --git a/generator/generator_tests/maxspeeds_tests.cpp b/generator/generator_tests/maxspeeds_tests.cpp
index 52b36e3eb4..9088379cbc 100644
--- a/generator/generator_tests/maxspeeds_tests.cpp
+++ b/generator/generator_tests/maxspeeds_tests.cpp
@@ -8,6 +8,7 @@
 
 #include "routing/maxspeeds_serialization.hpp"
 #include "routing/maxspeeds.hpp"
+#include "routing/routing_helpers.hpp"
 
 #include "routing_common/maxspeed_conversion.hpp"
 
diff --git a/generator/maxspeeds_builder.cpp b/generator/maxspeeds_builder.cpp
index 0f65898909..d2a3ab79cb 100644
--- a/generator/maxspeeds_builder.cpp
+++ b/generator/maxspeeds_builder.cpp
@@ -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"
 
diff --git a/generator/osm_source.cpp b/generator/osm_source.cpp
index 8cf6061950..8edba3caba 100644
--- a/generator/osm_source.cpp
+++ b/generator/osm_source.cpp
@@ -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,12 +109,12 @@ void AddElementToCache(cache::IntermediateDataWriter & cache,
 }
 
 void BuildIntermediateDataFromXML(SourceReader & stream, cache::IntermediateDataWriter & cache,
-                                  TownsDumper & towns, CameraNodeIntermediateDataProcessor & cameras)
+                                  TownsDumper & towns)
 {
   XMLSource parser([&](OsmElement * e)
   {
     towns.CheckElement(*e);
-    AddElementToCache(cache, cameras, *e);
+    AddElementToCache(cache, *e);
   });
   ParseXMLSequence(stream, parser);
 }
@@ -132,11 +126,11 @@ void ProcessOsmElementsFromXML(SourceReader & stream, function<void(OsmElement *
 }
 
 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 * e) {
+    towns.CheckElement(*e);
+    AddElementToCache(cache, *e);
   };
 
   // Use only this function here, look into ProcessOsmElementsFromO5M
@@ -254,10 +248,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 +262,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 +269,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()));
   }
diff --git a/generator/translator_country.cpp b/generator/translator_country.cpp
index 97851a973b..69ae5bfdee 100644
--- a/generator/translator_country.cpp
+++ b/generator/translator_country.cpp
@@ -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::CameraNodeProcessor>(info.GetIntermediateFileName(CAMERAS_TO_WAYS_FILENAME)));
+
   if (info.m_genAddresses)
     AddCollector(std::make_shared<CollectorAddresses>(info.GetAddressesFileName()));
 }