generator/isolines_generator.cpp - master - githubmirror/omim

generator/isolines_generator.cpp
92 строки3 KB
Daria Volvenkova
[generator] Assign names for all isolines if altitudes step greater than 10.
27 фев 2020, 13:42
27 фев 2020, 13:42ebfe9ca
#include "generator/isolines_generator.hpp"

#include "topography_generator/isolines_utils.hpp"
#include "topography_generator/utils/contours_serdes.hpp"

#include "indexer/classificator.hpp"

namespace generator
{
namespace
{
std::vector<int> const kAltClasses = {1000, 500, 100, 50, 10};
int const kNamedAltStep = 50;
int const kNamedAltRange = 150;
std::string const kTypePrefix = "step_";
std::string const kTypeZero = "zero";

std::string GetIsolineName(int altitude, int step, int minAltitude, int maxAltitude)
{
  if (step > 10 ||
      abs(altitude) % kNamedAltStep == 0 ||
      maxAltitude - minAltitude <= kNamedAltRange)
  {
    return strings::to_string(altitude);
  }
  return "";
}
}  // namespace

IsolineFeaturesGenerator::IsolineFeaturesGenerator(std::string const & isolinesDir)
  : m_isolinesDir(isolinesDir)
{
  ASSERT(std::is_sorted(kAltClasses.cbegin(), kAltClasses.cend(), std::greater<int>()), ());
  for (auto alt : kAltClasses)
  {
    auto const type = kTypePrefix + strings::to_string(alt);
    m_altClassToType[alt] = classif().GetTypeByPath({"isoline", type});
  }
  m_altClassToType[0] = classif().GetTypeByPath({"isoline", kTypeZero});
}

uint32_t IsolineFeaturesGenerator::GetIsolineType(int altitude) const
{
  if (altitude == 0)
    return m_altClassToType.at(0);

  for (auto altStep : kAltClasses)
  {
    if (abs(altitude) % altStep == 0)
      return m_altClassToType.at(altStep);
  }
  return ftype::GetEmptyValue();
}

void IsolineFeaturesGenerator::GenerateIsolines(std::string const & countryName,
                                                FeaturesCollectFn const & fn) const
{
  auto const isolinesPath = topography_generator::GetIsolinesFilePath(countryName,
                                                                      m_isolinesDir);
  topography_generator::Contours<topography_generator::Altitude> countryIsolines;
  if (!topography_generator::LoadContours(isolinesPath, countryIsolines))
  {
    LOG(LWARNING, ("Can't load contours", isolinesPath));
    return;
  }
  LOG(LINFO, ("Generating isolines for", countryName));
  for (auto const & levelIsolines : countryIsolines.m_contours)
  {
    auto const altitude = levelIsolines.first;
    auto const isolineName = GetIsolineName(altitude, countryIsolines.m_valueStep,
                                            countryIsolines.m_minValue, countryIsolines.m_maxValue);
    auto const isolineType = GetIsolineType(altitude);
    if (isolineType == ftype::GetEmptyValue())
    {
      LOG(LWARNING, ("Skip unsupported altitudes level", altitude, "in", countryName));
      continue;
    }

    for (auto const & isoline : levelIsolines.second)
    {
      feature::FeatureBuilder fb;
      for (auto const & pt : isoline)
        fb.AddPoint(pt);
      fb.AddType(isolineType);
      if (!isolineName.empty())
        fb.AddName("default", isolineName);
      fb.SetLinear();
      fn(std::move(fb));
    }
  }
}
}  // namespace generator