Repo created

generator/altitude_generator.cpp

@@ -0,0 +1,214 @@
+#include "generator/altitude_generator.hpp"
+#include "generator/srtm_parser.hpp"
+
+#include "routing/routing_helpers.hpp"
+
+#include "indexer/feature.hpp"
+#include "indexer/feature_altitude.hpp"
+#include "indexer/feature_data.hpp"
+#include "indexer/feature_processor.hpp"
+
+#include "coding/files_container.hpp"
+#include "coding/succinct_mapper.hpp"
+
+#include "base/assert.hpp"
+#include "base/checked_cast.hpp"
+#include "base/logging.hpp"
+#include "base/scope_guard.hpp"
+#include "base/stl_helpers.hpp"
+
+#include "defines.hpp"
+
+#include "3party/succinct/elias_fano.hpp"
+#include "3party/succinct/rs_bit_vector.hpp"
+
+namespace routing
+{
+using namespace feature;
+using namespace geometry;
+
+namespace
+{
+class SrtmGetter : public AltitudeGetter
+{
+public:
+  explicit SrtmGetter(std::string const & srtmDir) : m_srtmManager(srtmDir) {}
+
+  // AltitudeGetter overrides:
+  Altitude GetAltitude(m2::PointD const & p) override { return m_srtmManager.GetAltitude(mercator::ToLatLon(p)); }
+
+  void PrintStatsAndPurge() override
+  {
+    LOG(LINFO, ("Srtm tiles number (x26Mb):", m_srtmManager.GeTilesNumber()));
+    m_srtmManager.Purge();
+  }
+
+private:
+  generator::SrtmTileManager m_srtmManager;
+};
+
+class Processor
+{
+public:
+  struct FeatureAltitude
+  {
+    FeatureAltitude(uint32_t featureId, geometry::Altitudes && altitudes)
+      : m_featureId(featureId)
+      , m_altitudes(std::move(altitudes))
+    {}
+
+    uint32_t m_featureId;
+    feature::Altitudes m_altitudes;
+  };
+
+  explicit Processor(AltitudeGetter & altitudeGetter)
+    : m_minAltitude(geometry::kInvalidAltitude)
+    , m_altitudeGetter(altitudeGetter)
+  {}
+
+  void operator()(FeatureType & f, uint32_t id)
+  {
+    CHECK_EQUAL(f.GetID().m_index, id, ());
+    CHECK_EQUAL(id, m_altitudeAvailabilityBuilder.size(), ());
+
+    bool hasAltitude = false;
+    SCOPE_GUARD(altitudeAvailabilityBuilding, [&]() { m_altitudeAvailabilityBuilder.push_back(hasAltitude); });
+
+    if (!routing::IsRoad(feature::TypesHolder(f)))
+      return;
+
+    f.ParseGeometry(FeatureType::BEST_GEOMETRY);
+    size_t const pointsCount = f.GetPointsCount();
+    if (pointsCount == 0)
+      return;
+
+    geometry::Altitudes altitudes;
+    altitudes.reserve(pointsCount);
+    Altitude minFeatureAltitude = geometry::kInvalidAltitude;
+    for (size_t i = 0; i < pointsCount; ++i)
+    {
+      auto const & pt = f.GetPoint(i);
+      Altitude const a = m_altitudeGetter.GetAltitude(pt);
+      if (a == geometry::kInvalidAltitude)
+      {
+        // Print warning for missing altitude point (if not a ferry or so).
+        auto const type = CarModel::AllLimitsInstance().GetHighwayType(feature::TypesHolder(f));
+        if (type && *type != HighwayType::RouteFerry && *type != HighwayType::RouteShuttleTrain)
+          LOG(LWARNING, ("Invalid altitude at:", mercator::ToLatLon(pt)));
+
+        // One invalid point invalidates the whole feature.
+        return;
+      }
+
+      if (minFeatureAltitude == geometry::kInvalidAltitude)
+        minFeatureAltitude = a;
+      else
+        minFeatureAltitude = std::min(minFeatureAltitude, a);
+
+      altitudes.push_back(a);
+    }
+
+    hasAltitude = true;
+    m_featureAltitudes.emplace_back(id, std::move(altitudes));
+
+    if (m_minAltitude == geometry::kInvalidAltitude)
+      m_minAltitude = minFeatureAltitude;
+    else
+      m_minAltitude = std::min(minFeatureAltitude, m_minAltitude);
+  }
+
+  bool HasAltitudeInfo() const { return !m_featureAltitudes.empty(); }
+
+public:
+  std::vector<FeatureAltitude> m_featureAltitudes;
+  succinct::bit_vector_builder m_altitudeAvailabilityBuilder;
+  Altitude m_minAltitude;
+
+  AltitudeGetter & m_altitudeGetter;
+};
+}  // namespace
+
+void BuildRoadAltitudes(std::string const & mwmPath, AltitudeGetter & altitudeGetter)
+{
+  try
+  {
+    // Preparing altitude information.
+    Processor processor(altitudeGetter);
+    feature::ForEachFeature(mwmPath, processor);
+    processor.m_altitudeGetter.PrintStatsAndPurge();
+
+    if (!processor.HasAltitudeInfo())
+    {
+      // Possible for small islands like Bouvet or Willis.
+      LOG(LWARNING, ("No altitude information for road features of mwm:", mwmPath));
+      return;
+    }
+
+    FilesContainerW cont(mwmPath, FileWriter::OP_WRITE_EXISTING);
+    auto w = cont.GetWriter(ALTITUDES_FILE_TAG);
+
+    AltitudeHeader header;
+    header.m_minAltitude = processor.m_minAltitude;
+
+    auto const startOffset = w->Pos();
+    header.Serialize(*w);
+    {
+      // Altitude availability serialization.
+      coding::FreezeVisitor<Writer> visitor(*w);
+      succinct::rs_bit_vector(&processor.m_altitudeAvailabilityBuilder).map(visitor);
+    }
+    header.m_featureTableOffset = base::checked_cast<uint32_t>(w->Pos() - startOffset);
+
+    std::vector<uint32_t> offsets;
+    std::vector<uint8_t> deltas;
+    {
+      // Altitude info serialization to memory.
+      MemWriter<std::vector<uint8_t>> writer(deltas);
+      for (auto const & a : processor.m_featureAltitudes)
+      {
+        offsets.push_back(base::checked_cast<uint32_t>(writer.Pos()));
+        a.m_altitudes.Serialize(header.m_minAltitude, writer);
+      }
+    }
+    {
+      // Altitude offsets serialization.
+      CHECK(base::IsSortedAndUnique(offsets), ());
+
+      succinct::elias_fano::elias_fano_builder builder(offsets.back(), offsets.size());
+      for (uint32_t offset : offsets)
+        builder.push_back(offset);
+
+      coding::FreezeVisitor<Writer> visitor(*w);
+      succinct::elias_fano(&builder).map(visitor);
+    }
+    // Writing altitude info.
+    header.m_altitudesOffset = base::checked_cast<uint32_t>(w->Pos() - startOffset);
+    w->Write(deltas.data(), deltas.size());
+    w->WritePaddingByEnd(8);
+    header.m_endOffset = base::checked_cast<uint32_t>(w->Pos() - startOffset);
+
+    // Rewriting header info.
+    auto const endOffset = w->Pos();
+    w->Seek(startOffset);
+    header.Serialize(w);
+    w->Seek(endOffset);
+
+    LOG(LINFO, (ALTITUDES_FILE_TAG, "section is ready. The size is", header.m_endOffset));
+    if (processor.HasAltitudeInfo())
+      LOG(LINFO, ("Min altitude is", processor.m_minAltitude));
+    else
+      LOG(LINFO, ("Min altitude isn't defined."));
+  }
+  catch (RootException const & e)
+  {
+    LOG(LERROR, ("An exception happened while creating", ALTITUDES_FILE_TAG, "section:", e.what()));
+  }
+}
+
+void BuildRoadAltitudes(std::string const & mwmPath, std::string const & srtmDir)
+{
+  LOG(LINFO, ("mwmPath =", mwmPath, "srtmDir =", srtmDir));
+  SrtmGetter srtmGetter(srtmDir);
+  BuildRoadAltitudes(mwmPath, srtmGetter);
+}
+}  // namespace routing