kirylkaveryn/organicmaps
1
Fork 0
forked from organicmaps/organicmaps-tmp
Code Pull requests Activity

Merge pull request #9867 from maksimandrianov/approximation_region_kv

Browse source 
[generator] Added approximation regions without a boundary.
This commit is contained in:
cc-engineering 2019-01-29 12:19:06 +03:00 • committed by GitHub
commit 5da69005b7
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
26 changed files with 794 additions and 619 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
coding/string_utf8_multilang.cpp
View file

@ -259,6 +259,15 @@ int8_t StringUtf8Multilang::FindString(string const & utf8s) const
return result;
}
size_t StringUtf8Multilang::CountLangs() const
{
size_t count = 0;
for (size_t i = 0; i < m_s.size(); i = GetNextIndex(i))
++count;
return count;
}
string DebugPrint(StringUtf8Multilang const & s)
{
string result;

1
coding/string_utf8_multilang.hpp
View file

@ -142,6 +142,7 @@ public:
bool HasString(int8_t lang) const;
int8_t FindString(string const & utf8s) const;
size_t CountLangs() const;
template <class TSink>
void Write(TSink & sink) const

4
generator/CMakeLists.txt
View file

@ -121,10 +121,14 @@ set(SRC
regions/region.hpp
regions/region_base.cpp
regions/region_base.hpp
regions/region_info.cpp
regions/region_info.hpp
regions/regions.cpp
regions/regions.hpp
regions/regions_builder.cpp
regions/regions_builder.hpp
regions/regions_fixer.cpp
regions/regions_fixer.hpp
regions/to_string_policy.cpp
regions/to_string_policy.hpp
restriction_collector.cpp

1
generator/generator_tests/region_info_collector_tests.cpp
View file

@ -3,6 +3,7 @@
#include "generator/generator_tests/common.hpp"
#include "generator/osm_element.hpp"
#include "generator/regions/collector_region_info.hpp"
#include "generator/regions/region_info.hpp"
#include "coding/file_name_utils.hpp"

31
generator/generator_tests/regions_tests.cpp
View file

@ -149,20 +149,14 @@ RegionsBuilder::Regions MakeTestDataSet1(RegionInfo & collector)
class Helper : public ToStringPolicyInterface
{
public:
Helper(std::vector<std::string> & bankOfNames) : m_bankOfNames(bankOfNames) {}
std::string ToString(Node::PtrList const & nodePtrList) override
std::string ToString(Node::PtrList const & nodePtrList) const override
{
std::stringstream stream;
for (auto const & n : nodePtrList)
stream << n->GetData().GetName();
auto str = stream.str();
m_bankOfNames.push_back(str);
return str;
return stream.str();
}
std::vector<std::string> & m_bankOfNames;
};
bool ExistsName(std::vector<std::string> const & coll, std::string const name)
@ -202,25 +196,20 @@ UNIT_TEST(RegionsBuilderTest_GetCountryTrees)
auto const filename = MakeCollectorData();
RegionInfo collector(filename);
std::vector<std::string> bankOfNames;
RegionsBuilder builder(MakeTestDataSet1(collector), std::make_unique<Helper>(bankOfNames));
RegionsBuilder builder(MakeTestDataSet1(collector), std::make_unique<Helper>());
builder.ForEachNormalizedCountry([&](std::string const & name, Node::Ptr const & tree) {
auto const idStringList = builder.ToIdStringList(tree);
for (auto const & idString : idStringList)
bankOfNames.push_back(idString.second);
});
auto const countryTrees = builder.GetCountryTrees();
for (auto const & countryName : builder.GetCountryNames())
{
auto const keyRange = countryTrees.equal_range(countryName);
for (auto it = keyRange.first; it != keyRange.second; ++it)
{
auto const unused = builder.ToIdStringList(it->second);
UNUSED_VALUE(unused);
}
}
TEST(ExistsName(bankOfNames, "Country_2"), ());
TEST(ExistsName(bankOfNames, "Country_2_Region_8Country_2"), ());
TEST_EQUAL(std::count(std::begin(bankOfNames), std::end(bankOfNames), "Country_2"), 2, ());
TEST(ExistsName(bankOfNames, "Country_1"), ());
TEST(ExistsName(bankOfNames, "Country_1_Region_3Country_1"), ());
TEST(ExistsName(bankOfNames, "Country_1_Region_4Country_1"), ());
TEST(ExistsName(bankOfNames, "Country_1_Region_5Country_1"), ());
TEST(ExistsName(bankOfNames, "Country_2_Region_8Country_2"), ());
TEST(ExistsName(bankOfNames, "Country_1_Region_5_Subregion_6Country_1_Region_5Country_1"), ());
TEST(ExistsName(bankOfNames, "Country_1_Region_5_Subregion_7Country_1_Region_5Country_1"), ());
}

129
generator/geo_objects/geo_objects.cpp
View file

@ -11,6 +11,8 @@
#include "coding/mmap_reader.hpp"
#include "geometry/mercator.hpp"
#include "base/geo_object_id.hpp"
#include "base/logging.hpp"
#include "base/timer.hpp"
@ -32,6 +34,8 @@ namespace
using KeyValue = std::pair<uint64_t, base::Json>;
using IndexReader = ReaderPtr<Reader>;
bool DefaultPred(KeyValue const &) { return true; }
bool ParseKey(std::string const & line, int64_t & key)
{
auto const pos = line.find(" ");
@ -97,8 +101,7 @@ public:
class KeyValueMem : public KeyValueInterface
{
public:
KeyValueMem(std::istream & stream, std::function<bool(KeyValue const &)> pred =
[](KeyValue const &) { return true; })
KeyValueMem(std::istream & stream, std::function<bool(KeyValue const &)> pred = DefaultPred)
{
std::string line;
KeyValue kv;
@ -213,9 +216,8 @@ std::vector<base::GeoObjectId> SearchObjectsInIndex(FeatureBuilder1 const & fb,
{
std::vector<base::GeoObjectId> ids;
auto const fn = [&ids] (base::GeoObjectId const & osmid) { ids.emplace_back(osmid); };
auto const center = fb.GetLimitRect().Center();
auto const rect = MercatorBounds::RectByCenterXYAndSizeInMeters(center, 0 /* meters */);
index.ForEachInRect(fn, rect);
auto const center = fb.GetKeyPoint();
index.ForEachInRect(fn, m2::RectD(center, center));
return ids;
}
@ -227,10 +229,10 @@ int GetRankFromValue(base::Json json)
return rank;
}
base::Json GetDeepestRegion(std::vector<base::GeoObjectId> const & ids,
KeyValueInterface const & regionKv)
boost::optional<KeyValue> GetDeepestRegion(std::vector<base::GeoObjectId> const & ids,
KeyValueInterface const & regionKv)
{
base::Json deepest;
boost::optional<KeyValue> deepest;
int deepestRank = 0;
for (auto const & id : ids)
{
@ -249,17 +251,17 @@ base::Json GetDeepestRegion(std::vector<base::GeoObjectId> const & ids,
continue;
}
if (!deepest.get())
if (!deepest)
{
deepestRank = GetRankFromValue(temp);
deepest = temp;
deepest = KeyValue(static_cast<int64_t>(id.GetEncodedId()), temp);
}
else
{
int tempRank = GetRankFromValue(temp);
if (deepestRank < tempRank)
{
deepest = temp;
deepest = KeyValue(static_cast<int64_t>(id.GetEncodedId()), temp);
deepestRank = tempRank;
}
}
@ -274,17 +276,18 @@ void UpdateCoordinates(m2::PointD const & point, base::Json json)
auto coordinates = json_object_get(geometry, "coordinates");
if (json_array_size(coordinates) == 2)
{
json_array_set_new(coordinates, 0, ToJSON(point.x).release());
json_array_set_new(coordinates, 1, ToJSON(point.y).release());
auto const latLon = MercatorBounds::ToLatLon(point);
json_array_set_new(coordinates, 0, ToJSON(latLon.lat).release());
json_array_set_new(coordinates, 1, ToJSON(latLon.lon).release());
}
}
base::Json AddAddress(FeatureBuilder1 const & fb, base::Json regionJson)
base::Json AddAddress(FeatureBuilder1 const & fb, KeyValue const & regionKeyValue)
{
base::Json result = regionJson.GetDeepCopy();
base::Json result = regionKeyValue.second.GetDeepCopy();
int const kHouseOrPoiRank = 30;
ToJSONObject(*result.get(), "rank", kHouseOrPoiRank);
UpdateCoordinates(fb.GetLimitRect().Center(), result);
UpdateCoordinates(fb.GetKeyPoint(), result);
auto properties = json_object_get(result.get(), "properties");
auto address = json_object_get(properties, "address");
@ -299,29 +302,25 @@ base::Json AddAddress(FeatureBuilder1 const & fb, base::Json regionJson)
else
ToJSONObject(*address, "building", base::NewJSONNull());
ToJSONObject(*properties, "pid", regionKeyValue.first);
// auto locales = json_object_get(result.get(), "locales");
// auto en = json_object_get(result.get(), "en");
// todo(maksimandrianov): Add en locales.
return result;
}
boost::optional<base::Json>
boost::optional<KeyValue>
FindRegion(FeatureBuilder1 const & fb, indexer::RegionsIndex<IndexReader> const & regionIndex,
KeyValueInterface const & regionKv)
{
boost::optional<base::Json> result;
auto const ids = SearchObjectsInIndex(fb, regionIndex);
auto const deepest = GetDeepestRegion(ids, regionKv);
if (deepest.get())
result = deepest;
return result;
return GetDeepestRegion(ids, regionKv);
}
std::unique_ptr<char, JSONFreeDeleter>
MakeGeoObjectValueWithAddress(FeatureBuilder1 const & fb, base::Json json)
MakeGeoObjectValueWithAddress(FeatureBuilder1 const & fb, KeyValue const & keyValue)
{
auto const jsonWithAddress = AddAddress(fb, json);
auto const jsonWithAddress = AddAddress(fb, keyValue);
auto const cstr = json_dumps(jsonWithAddress.get(), JSON_COMPACT);
return std::unique_ptr<char, JSONFreeDeleter>(cstr);
}
@ -340,14 +339,8 @@ FindHousePoi(FeatureBuilder1 const & fb,
auto properties = json_object_get(house->get(), "properties");
auto address = json_object_get(properties, "address");
std::string const kHouseField = "building";
char const * key = nullptr;
json_t * value = nullptr;
json_object_foreach(address, key, value)
{
if (key == kHouseField)
return house;
}
if (json_object_get(address, "building"))
return house;
}
return {};
@ -359,7 +352,7 @@ MakeGeoObjectValueWithoutAddress(FeatureBuilder1 const & fb, base::Json json)
auto const jsonWithAddress = json.GetDeepCopy();
auto properties = json_object_get(jsonWithAddress.get(), "properties");
ToJSONObject(*properties, "name", fb.GetName());
UpdateCoordinates(fb.GetLimitRect().Center(), jsonWithAddress);
UpdateCoordinates(fb.GetKeyPoint(), jsonWithAddress);
auto const cstr = json_dumps(jsonWithAddress.get(), JSON_COMPACT);
return std::unique_ptr<char, JSONFreeDeleter>(cstr);
}
@ -367,13 +360,12 @@ MakeGeoObjectValueWithoutAddress(FeatureBuilder1 const & fb, base::Json json)
boost::optional<indexer::GeoObjectsIndex<IndexReader>>
MakeTempGeoObjectsIndex(std::string const & pathToGeoObjectsTmpMwm)
{
boost::optional<indexer::GeoObjectsIndex<IndexReader>> result;
auto const dataFile = Platform().TmpPathForFile();
SCOPE_GUARD(removeDataFile, std::bind(Platform::RemoveFileIfExists, std::cref(dataFile)));
if (!feature::GenerateGeoObjectsData(pathToGeoObjectsTmpMwm, "" /* nodesFile */, dataFile))
{
LOG(LCRITICAL, ("Error generating geo objects data."));
return result;
return {};
}
auto const indexFile = Platform().TmpPathForFile();
@ -381,57 +373,44 @@ MakeTempGeoObjectsIndex(std::string const & pathToGeoObjectsTmpMwm)
if (!indexer::BuildGeoObjectsIndexFromDataFile(dataFile, indexFile))
{
LOG(LCRITICAL, ("Error generating geo objects index."));
return result;
return {};
}
result = indexer::ReadIndex<indexer::GeoObjectsIndexBox<IndexReader>, MmapReader>(indexFile);
return result;
return indexer::ReadIndex<indexer::GeoObjectsIndexBox<IndexReader>, MmapReader>(indexFile);
}
bool BuildGeoObjectsWithAddresses(indexer::RegionsIndex<IndexReader> const & regionIndex,
void BuildGeoObjectsWithAddresses(indexer::RegionsIndex<IndexReader> const & regionIndex,
KeyValueInterface const & regionKv,
std::string const & pathInGeoObjectsTmpMwm,
std::ostream & streamGeoObjectsKv, bool)
{
size_t countGeoObjects = 0;
auto const fn = [&](FeatureBuilder1 & fb, uint64_t /* currPos */)
{
auto const fn = [&](FeatureBuilder1 & fb, uint64_t /* currPos */) {
if (!(IsBuilding(fb) || HasHouse(fb)))
return;
auto region = FindRegion(fb, regionIndex, regionKv);
if (!region)
auto regionKeyValue = FindRegion(fb, regionIndex, regionKv);
if (!regionKeyValue)
return;
auto const value = MakeGeoObjectValueWithAddress(fb, *region);
auto const value = MakeGeoObjectValueWithAddress(fb, *regionKeyValue);
streamGeoObjectsKv << static_cast<int64_t>(fb.GetMostGenericOsmId().GetEncodedId()) << " "
<< value.get() << "\n";
++countGeoObjects;
};
try
{
feature::ForEachFromDatRawFormat(pathInGeoObjectsTmpMwm, fn);
LOG(LINFO, ("Added ", countGeoObjects, "geo objects with addresses."));
}
catch (Reader::Exception const & e)
{
LOG(LERROR, ("Error while reading file:", e.Msg()));
return false;
}
return true;
feature::ForEachFromDatRawFormat(pathInGeoObjectsTmpMwm, fn);
LOG(LINFO, ("Added ", countGeoObjects, "geo objects with addresses."));
}
bool BuildGeoObjectsWithoutAddresses(indexer::GeoObjectsIndex<IndexReader> const & geoObjectsIndex,
void BuildGeoObjectsWithoutAddresses(indexer::GeoObjectsIndex<IndexReader> const & geoObjectsIndex,
std::string const & pathInGeoObjectsTmpMwm,
KeyValueInterface const & geoObjectsKv,
std::ostream & streamGeoObjectsKv,
std::ostream & streamIdsWithoutAddress, bool)
{
size_t countGeoObjects = 0;
auto const fn = [&](FeatureBuilder1 & fb, uint64_t /* currPos */)
{
auto const fn = [&](FeatureBuilder1 & fb, uint64_t /* currPos */) {
if (IsBuilding(fb) || HasHouse(fb))
return;
@ -449,18 +428,8 @@ bool BuildGeoObjectsWithoutAddresses(indexer::GeoObjectsIndex<IndexReader> const
++countGeoObjects;
};
try
{
feature::ForEachFromDatRawFormat(pathInGeoObjectsTmpMwm, fn);
LOG(LINFO, ("Added ", countGeoObjects, "geo objects without addresses."));
}
catch (Reader::Exception const & e)
{
LOG(LERROR, ("Error while reading file:", e.Msg()));
return false;
}
return true;
feature::ForEachFromDatRawFormat(pathInGeoObjectsTmpMwm, fn);
LOG(LINFO, ("Added ", countGeoObjects, "geo objects without addresses."));
}
} // namespace
@ -490,12 +459,8 @@ bool GenerateGeoObjects(std::string const & pathInRegionsIndx,
LOG(LINFO, ("Size of regions key-value storage:", regionsKv.Size()));
std::ofstream streamIdsWithoutAddress(pathOutIdsWithoutAddress);
std::ofstream streamGeoObjectsKv(pathOutGeoObjectsKv);
if (!BuildGeoObjectsWithAddresses(regionIndex, regionsKv, pathInGeoObjectsTmpMwm,
streamGeoObjectsKv, verbose))
{
return false;
}
BuildGeoObjectsWithAddresses(regionIndex, regionsKv, pathInGeoObjectsTmpMwm,
streamGeoObjectsKv, verbose);
LOG(LINFO, ("Geo objects with addresses were built."));
// Regions key-value storage is big (~80 Gb). We will not load the key value into memory.
// This can be slow.
@ -506,13 +471,11 @@ bool GenerateGeoObjects(std::string const & pathInRegionsIndx,
LOG(LINFO, ("Size of geo objects key-value storage:", geoObjectsKv.Size()));
auto const geoObjectIndex = geoObjectIndexFuture.get();
LOG(LINFO, ("Index was built."));
if (!geoObjectIndex ||
!BuildGeoObjectsWithoutAddresses(*geoObjectIndex, pathInGeoObjectsTmpMwm, geoObjectsKv,
streamGeoObjectsKv, streamIdsWithoutAddress, verbose))
{
if (!geoObjectIndex)
return false;
}
BuildGeoObjectsWithoutAddresses(*geoObjectIndex, pathInGeoObjectsTmpMwm, geoObjectsKv,
streamGeoObjectsKv, streamIdsWithoutAddress, verbose);
LOG(LINFO, ("Geo objects without addresses were built."));
LOG(LINFO, ("Geo objects key-value storage saved to", pathOutGeoObjectsKv));
LOG(LINFO, ("Ids of POIs without addresses saved to", pathOutIdsWithoutAddress));

6
generator/place_node.hpp
View file

@ -32,6 +32,12 @@ public:
Data & GetData() { return m_data; }
Data const & GetData() const { return m_data; }
void ShrinkToFitChildren()
{
if (m_children.capacity() != m_children.size())
PtrList(m_children).swap(m_children);
}
private:
Data m_data;
PtrList m_children;

7
generator/regions/city.hpp
View file

@ -4,12 +4,15 @@
#include "generator/regions/collector_region_info.hpp"
#include "generator/regions/region_base.hpp"
#include <unordered_map>
namespace generator
{
namespace regions
{
struct City : public RegionWithName, public RegionWithData
class City : public RegionWithName, public RegionWithData
{
public:
explicit City(FeatureBuilder1 const & fb, RegionDataProxy const & rd)
: RegionWithName(fb.GetParams().name),
RegionWithData(rd)
@ -23,5 +26,7 @@ struct City : public RegionWithName, public RegionWithData
private:
BoostPoint m_center;
};
using PointCitiesMap = std::unordered_map<base::GeoObjectId, City>;
} // namespace regions
} // namespace generator

180
generator/regions/collector_region_info.cpp
View file

@ -4,7 +4,6 @@
#include "generator/osm_element.hpp"
#include "coding/file_writer.hpp"
#include "coding/reader.hpp"
#include "base/assert.hpp"
#include "base/logging.hpp"
@ -12,16 +11,12 @@
#include <map>
namespace
{
uint8_t const kVersion = 0;
} // namespace
namespace generator
{
namespace regions
{
std::string const CollectorRegionInfo::kDefaultExt = ".regions.bin";
uint8_t const CollectorRegionInfo::kVersion = 0;
PlaceType EncodePlaceType(std::string const & place)
{
@ -58,17 +53,10 @@ void CollectorRegionInfo::Collect(base::GeoObjectId const & osmId, OsmElement co
void CollectorRegionInfo::Save()
{
try
{
FileWriter writer(m_filename);
WriteToSink(writer, kVersion);
WriteMap(writer, m_mapRegionData);
WriteMap(writer, m_mapIsoCode);
}
catch (FileWriter::Exception const & e)
{
LOG(LCRITICAL, ("Failed to save regions info:", e.Msg()));
}
FileWriter writer(m_filename);
WriteToSink(writer, kVersion);
WriteMap(writer, m_mapRegionData);
WriteMap(writer, m_mapIsoCode);
}
void CollectorRegionInfo::FillRegionData(base::GeoObjectId const & osmId, OsmElement const & el,
@ -76,13 +64,6 @@ void CollectorRegionInfo::FillRegionData(base::GeoObjectId const & osmId, OsmEle
{
rd.m_osmId = osmId;
rd.m_place = EncodePlaceType(el.GetTag("place"));
auto const & members = el.Members();
auto const it = std::find_if(std::begin(members), std::end(members),
[](OsmElement::Member const & m) { return m.role == "admin_centre"; });
if (it != std::end(members))
rd.m_osmIdAdminCenter = base::MakeOsmNode(it->ref);
auto const al = el.GetTag("admin_level");
if (al.empty())
return;
@ -128,156 +109,5 @@ void IsoCode::SetNumeric(std::string const & numeric)
CHECK_LESS_OR_EQUAL(numeric.size() + 1, ARRAY_SIZE(m_numeric), ());
std::strcpy(m_numeric, numeric.data());
}
RegionInfo::RegionInfo(std::string const & filename)
{
ParseFile(filename);
}
RegionInfo::RegionInfo(Platform::FilesList const & filenames)
{
for (auto const & filename : filenames)
ParseFile(filename);
}
void RegionInfo::ParseFile(std::string const & filename)
{
try
{
FileReader reader(filename);
ReaderSource<FileReader> src(reader);
uint8_t version;
ReadPrimitiveFromSource(src, version);
CHECK_EQUAL(version, kVersion, ("Versions do not match."));
ReadMap(src, m_mapRegionData);
ReadMap(src, m_mapIsoCode);
}
catch (FileReader::Exception const & e)
{
LOG(LCRITICAL, ("Failed to parse regions info:", e.Msg()));
}
}
RegionDataProxy RegionInfo::Get(base::GeoObjectId const & osmId)
{
return RegionDataProxy(*this, osmId);
}
RegionDataProxy::RegionDataProxy(RegionInfo & regionInfoCollector,
base::GeoObjectId const & osmId)
: m_regionInfoCollector(regionInfoCollector),
m_osmId(osmId)
{
}
RegionInfo const & RegionDataProxy::GetCollector() const
{
return m_regionInfoCollector;
}
RegionInfo & RegionDataProxy::GetCollector()
{
return m_regionInfoCollector;
}
MapRegionData & RegionDataProxy::GetMapRegionData()
{
return GetCollector().m_mapRegionData;
}
MapRegionData const & RegionDataProxy::GetMapRegionData() const
{
return GetCollector().m_mapRegionData;
}
MapIsoCode const & RegionDataProxy::GetMapIsoCode() const
{
return GetCollector().m_mapIsoCode;
}
base::GeoObjectId const & RegionDataProxy::GetOsmId() const
{
return m_osmId;
}
AdminLevel RegionDataProxy::GetAdminLevel() const
{
return GetMapRegionData().at(m_osmId).m_adminLevel;
}
PlaceType RegionDataProxy::GetPlaceType() const
{
return GetMapRegionData().at(m_osmId).m_place;
}
void RegionDataProxy::SetAdminLevel(AdminLevel adminLevel)
{
GetMapRegionData().at(m_osmId).m_adminLevel = adminLevel;
}
void RegionDataProxy::SetPlaceType(PlaceType placeType)
{
GetMapRegionData().at(m_osmId).m_place = placeType;
}
bool RegionDataProxy::HasAdminLevel() const
{
return (GetMapRegionData().count(m_osmId) != 0) &&
(GetMapRegionData().at(m_osmId).m_adminLevel != AdminLevel::Unknown);
}
bool RegionDataProxy::HasPlaceType() const
{
return (GetMapRegionData().count(m_osmId) != 0) &&
(GetMapRegionData().at(m_osmId).m_place != PlaceType::Unknown);
}
bool RegionDataProxy::HasIsoCode() const
{
return GetMapIsoCode().count(m_osmId) != 0;
}
bool RegionDataProxy::HasIsoCodeAlpha2() const
{
return HasIsoCode() && GetMapIsoCode().at(m_osmId).HasAlpha2();
}
bool RegionDataProxy::HasIsoCodeAlpha3() const
{
return HasIsoCode() && GetMapIsoCode().at(m_osmId).HasAlpha3();
}
bool RegionDataProxy::HasIsoCodeAlphaNumeric() const
{
return HasIsoCode() && GetMapIsoCode().at(m_osmId).HasNumeric();
}
std::string RegionDataProxy::GetIsoCodeAlpha2() const
{
return GetMapIsoCode().at(m_osmId).GetAlpha2();
}
std::string RegionDataProxy::GetIsoCodeAlpha3() const
{
return GetMapIsoCode().at(m_osmId).GetAlpha3();
}
std::string RegionDataProxy::GetIsoCodeAlphaNumeric() const
{
return GetMapIsoCode().at(m_osmId).GetNumeric();
}
bool RegionDataProxy::HasAdminCenter() const
{
return (GetMapRegionData().count(m_osmId) != 0) &&
(GetMapRegionData().at(m_osmId).m_osmIdAdminCenter.HasId());
}
base::GeoObjectId RegionDataProxy::GetAdminCenter() const
{
return GetMapRegionData().at(m_osmId).m_osmIdAdminCenter.GetId();
}
} // namespace regions
} // namespace generator

89
generator/regions/collector_region_info.hpp
View file

@ -9,12 +9,10 @@
#include "base/geo_object_id.hpp"
#include <cstdint>
#include <functional>
#include <ostream>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <utility>
struct OsmElement;
class FeatureParams;
@ -59,8 +57,6 @@ enum class PlaceType: uint8_t
PlaceType EncodePlaceType(std::string const & place);
class RegionDataProxy;
// Codes for the names of countries, dependent territories, and special areas of geographical
// interest.
// https://en.wikipedia.org/wiki/ISO_3166-1
@ -84,25 +80,11 @@ struct IsoCode
char m_numeric[4] = {};
};
struct AdminCenter
{
AdminCenter() : m_has(false) {}
AdminCenter(base::GeoObjectId const & id) : m_has(true), m_id(id) {}
bool HasId() const { return m_has; }
base::GeoObjectId GetId() const { return m_id; }
private:
bool m_has;
base::GeoObjectId m_id;
};
struct RegionData
{
base::GeoObjectId m_osmId;
AdminLevel m_adminLevel = AdminLevel::Unknown;
PlaceType m_place = PlaceType::Unknown;
AdminCenter m_osmIdAdminCenter;
};
using MapRegionData = std::unordered_map<base::GeoObjectId, RegionData>;
@ -112,6 +94,7 @@ using MapIsoCode = std::unordered_map<base::GeoObjectId, IsoCode>;
class CollectorRegionInfo : public CollectorInterface
{
public:
static uint8_t const kVersion;
static std::string const kDefaultExt;
CollectorRegionInfo(std::string const & filename);
@ -139,76 +122,6 @@ private:
MapIsoCode m_mapIsoCode;
};
// RegionInfo class is responsible for reading and accessing additional information about the regions.
class RegionInfo
{
public:
RegionInfo() = default;
explicit RegionInfo(std::string const & filename);
explicit RegionInfo(Platform::FilesList const & filenames);
RegionDataProxy Get(base::GeoObjectId const & osmId);
private:
friend class RegionDataProxy;
template <typename Source, typename Map>
void ReadMap(Source & src, Map & seq)
{
uint32_t size = 0;
ReadPrimitiveFromSource(src, size);
typename Map::mapped_type data;
for (uint32_t i = 0; i < size; ++i)
{
ReadPrimitiveFromSource(src, data);
seq.emplace(data.m_osmId, std::move(data));
}
}
void ParseFile(std::string const & filename);
MapRegionData m_mapRegionData;
MapIsoCode m_mapIsoCode;
};
class RegionDataProxy
{
public:
RegionDataProxy(RegionInfo & regionInfoCollector, base::GeoObjectId const & osmId);
base::GeoObjectId const & GetOsmId() const;
AdminLevel GetAdminLevel() const;
PlaceType GetPlaceType() const;
void SetAdminLevel(AdminLevel adminLevel);
void SetPlaceType(PlaceType placeType);
bool HasAdminLevel() const;
bool HasPlaceType() const;
bool HasIsoCodeAlpha2() const;
bool HasIsoCodeAlpha3() const;
bool HasIsoCodeAlphaNumeric() const;
std::string GetIsoCodeAlpha2() const;
std::string GetIsoCodeAlpha3() const;
std::string GetIsoCodeAlphaNumeric() const;
bool HasAdminCenter() const;
base::GeoObjectId GetAdminCenter() const;
private:
bool HasIsoCode() const;
RegionInfo & GetCollector();
RegionInfo const & GetCollector() const;
MapRegionData & GetMapRegionData();
MapRegionData const & GetMapRegionData() const;
MapIsoCode const & GetMapIsoCode() const;
std::reference_wrapper<RegionInfo> m_regionInfoCollector;
base::GeoObjectId m_osmId;
};
inline std::ostream & operator<<(std::ostream & out, AdminLevel const & t)
{
out << static_cast<int>(t);

12
generator/regions/node.cpp
View file

@ -1,6 +1,9 @@
#include "generator/regions/node.hpp"
#include "geometry/mercator.hpp"
#include <algorithm>
#include <iomanip>
#include <numeric>
namespace generator
@ -62,7 +65,9 @@ Node::Ptr MergeHelper(Node::Ptr l, Node::Ptr r, MergeFunc mergeTree)
auto resultChildren = NormalizeChildren(children, mergeTree);
l->SetChildren(std::move(resultChildren));
l->ShrinkToFitChildren();
r->RemoveChildren();
r->ShrinkToFitChildren();
return l;
}
} // nmespace
@ -109,17 +114,18 @@ void PrintTree(Node::Ptr node, std::ostream & stream = std::cout, std::string pr
auto const & d = node->GetData();
auto const point = d.GetCenter();
auto const center = MercatorBounds::ToLatLon({point.get<0>(), point.get<1>()});
stream << d.GetName() << "<" << d.GetEnglishOrTransliteratedName() << "> ("
<< d.GetId()
<< DebugPrint(d.GetId())
<< ";" << d.GetLabel()
<< ";" << static_cast<size_t>(d.GetRank())
<< ";[" << point.get<0>() << "," << point.get<1>() << "])"
<< ";[" << std::fixed << std::setprecision(7) << center.lat << "," << center.lon << "])"
<< std::endl;
for (size_t i = 0, size = children.size(); i < size; ++i)
PrintTree(children[i], stream, prefix, i == size - 1);
}
void DebugPrintTree(Node::Ptr tree, std::ostream & stream)
void DebugPrintTree(Node::Ptr const & tree, std::ostream & stream)
{
stream << "ROOT NAME: " << tree->GetData().GetName() << std::endl;
stream << "MAX DEPTH: " << MaxDepth(tree) << std::endl;

2
generator/regions/node.hpp
View file

@ -15,7 +15,7 @@ size_t TreeSize(Node::Ptr node);
size_t MaxDepth(Node::Ptr node);
void DebugPrintTree(Node::Ptr tree, std::ostream & stream = std::cout);
void DebugPrintTree(Node::Ptr const & tree, std::ostream & stream = std::cout);
// This function merges two trees if the roots have the same ids.
Node::Ptr MergeTree(Node::Ptr l, Node::Ptr r);

112
generator/regions/region.cpp
View file

@ -4,6 +4,8 @@
#include "generator/regions/city.hpp"
#include "generator/regions/collector_region_info.hpp"
#include "geometry/mercator.hpp"
#include "base/assert.hpp"
#include <algorithm>
@ -15,17 +17,66 @@ namespace generator
{
namespace regions
{
BoostPolygon MakePolygonWithRadius(BoostPoint const & point, double radius, size_t numPoints = 16)
{
boost::geometry::strategy::buffer::point_circle point_strategy(numPoints);
boost::geometry::strategy::buffer::distance_symmetric<double> distance_strategy(radius);
static boost::geometry::strategy::buffer::join_round const join_strategy;
static boost::geometry::strategy::buffer::end_round const end_strategy;
static boost::geometry::strategy::buffer::side_straight const side_strategy;
boost::geometry::model::multi_polygon<BoostPolygon> result;
boost::geometry::buffer(point, result, distance_strategy, side_strategy, join_strategy,
end_strategy, point_strategy);
CHECK_EQUAL(result.size(), 1, ());
return std::move(result.front());
}
Region::Region(FeatureBuilder1 const & fb, RegionDataProxy const & rd)
: RegionWithName(fb.GetParams().name),
RegionWithData(rd),
m_polygon(std::make_shared<BoostPolygon>())
: RegionWithName(fb.GetParams().name)
, RegionWithData(rd)
, m_polygon(std::make_shared<BoostPolygon>())
{
FillPolygon(fb);
auto rect = fb.GetLimitRect();
m_rect = BoostRect({{rect.minX(), rect.minY()}, {rect.maxX(), rect.maxY()}});
boost::geometry::envelope(*m_polygon, m_rect);
m_area = boost::geometry::area(*m_polygon);
}
Region::Region(City const & city)
: RegionWithName(city.GetMultilangName())
, RegionWithData(city.GetRegionData())
, m_polygon(std::make_shared<BoostPolygon>())
{
auto const radius = GetRadiusByPlaceType(city.GetPlaceType());
*m_polygon = MakePolygonWithRadius(city.GetCenter(), radius);
boost::geometry::envelope(*m_polygon, m_rect);
m_area = boost::geometry::area(*m_polygon);
}
// static
double Region::GetRadiusByPlaceType(PlaceType place)
{
// Based on average radiuses of OSM place polygons.
switch (place)
{
case PlaceType::City:
return 0.078;
case PlaceType::Town:
return 0.033;
case PlaceType::Village:
return 0.013;
case PlaceType::Hamlet:
return 0.0067;
case PlaceType::Suburb:
return 0.016;
case PlaceType::Neighbourhood:
case PlaceType::IsolatedDwelling:
return 0.0035;
}
UNREACHABLE();
}
void Region::DeletePolygon()
{
m_polygon = nullptr;
@ -43,12 +94,18 @@ bool Region::IsCountry() const
return !HasPlaceType() && GetAdminLevel() == kAdminLevelCountry;
}
bool Region::IsLocality() const
{
return HasPlaceType();
}
bool Region::Contains(Region const & smaller) const
{
CHECK(m_polygon, ());
CHECK(smaller.m_polygon, ());
return boost::geometry::covered_by(*smaller.m_polygon, *m_polygon);
return boost::geometry::covered_by(smaller.m_rect, m_rect) &&
boost::geometry::covered_by(*smaller.m_polygon, *m_polygon);
}
double Region::CalculateOverlapPercentage(Region const & other) const
@ -56,6 +113,9 @@ double Region::CalculateOverlapPercentage(Region const & other) const
CHECK(m_polygon, ());
CHECK(other.m_polygon, ());
if (!boost::geometry::intersects(other.m_rect, m_rect))
return 0.0;
std::vector<BoostPolygon> coll;
boost::geometry::intersection(*other.m_polygon, *m_polygon, coll);
auto const min = std::min(boost::geometry::area(*other.m_polygon),
@ -81,14 +141,44 @@ bool Region::Contains(City const & cityPoint) const
{
CHECK(m_polygon, ());
return boost::geometry::covered_by(cityPoint.GetCenter(), *m_polygon);
return Contains(cityPoint.GetCenter());
}
void Region::SetInfo(City const & cityPoint)
bool Region::Contains(BoostPoint const & point) const
{
SetStringUtf8MultilangName(cityPoint.GetStringUtf8MultilangName());
SetAdminLevel(cityPoint.GetAdminLevel());
SetPlaceType(cityPoint.GetPlaceType());
CHECK(m_polygon, ());
return boost::geometry::covered_by(point, m_rect) &&
boost::geometry::covered_by(point, *m_polygon);
}
bool FeatureCityPointToRegion(RegionInfo const & regionInfo, FeatureBuilder1 & feature)
{
if (!feature.IsPoint())
return false;
auto const center = feature.GetKeyPoint();
BoostPolygon polygon;
auto info = regionInfo.Get(feature.GetMostGenericOsmId());
if (!info.HasPlaceType())
return false;
auto const placeType = info.GetPlaceType();
if (placeType == PlaceType::Locality || placeType == PlaceType::Unknown)
return false;
auto const radius = Region::GetRadiusByPlaceType(placeType);
polygon = MakePolygonWithRadius({center.x, center.y}, radius);
auto const & outer = polygon.outer();
FeatureBuilder1::PointSeq seq;
std::transform(std::begin(outer), std::end(outer), std::back_inserter(seq), [](BoostPoint const & p) {
return m2::PointD(p.get<0>(), p.get<1>());
});
feature.ResetGeometry();
feature.AddPolygon(seq);
feature.SetAreaAddHoles({});
feature.SetRank(0);
return true;
}
} // namespace regions
} // namespace generator

21
generator/regions/region.hpp
View file

@ -13,25 +13,32 @@ class RegionDataProxy;
namespace regions
{
struct City;
class City;
// This is a helper class that is needed to represent the region.
// With this view, further processing is simplified.
struct Region : public RegionWithName, public RegionWithData
class Region : public RegionWithName, public RegionWithData
{
public:
explicit Region(FeatureBuilder1 const & fb, RegionDataProxy const & rd);
// Build a region and its boundary based on the heuristic.
explicit Region(City const & city);
// After calling DeletePolygon, you cannot use Contains, ContainsRect, CalculateOverlapPercentage.
void DeletePolygon();
bool IsCountry() const;
bool Contains(Region const & smaller) const;
bool ContainsRect(Region const & smaller) const;
bool Contains(City const & cityPoint) const;
bool Contains(BoostPoint const & point) const;
double CalculateOverlapPercentage(Region const & other) const;
BoostPoint GetCenter() const;
std::shared_ptr<BoostPolygon> const GetPolygon() const { return m_polygon; }
bool IsCountry() const;
bool IsLocality() const;
BoostRect const & GetRect() const { return m_rect; }
double GetArea() const { return m_area; }
bool Contains(City const & cityPoint) const;
void SetInfo(City const & cityPoint);
// This function uses heuristics and assigns a radius according to the tag place.
// The radius will be returned in mercator units.
static double GetRadiusByPlaceType(PlaceType place);
private:
void FillPolygon(FeatureBuilder1 const & fb);
@ -40,5 +47,7 @@ private:
BoostRect m_rect;
double m_area;
};
bool FeatureCityPointToRegion(RegionInfo const & regionInfo, FeatureBuilder1 & feature);
} // namespace regions
} // namespace generator

90
generator/regions/region_base.cpp
View file

@ -22,8 +22,7 @@ std::string RegionWithName::GetEnglishOrTransliteratedName() const
if (!s.empty())
return s;
auto const fn = [&s](int8_t code, std::string const & name)
{
auto const fn = [&s](int8_t code, std::string const & name) {
if (code != StringUtf8Multilang::kDefaultCode &&
Transliteration::Instance().Transliterate(name, code, s))
{
@ -37,12 +36,12 @@ std::string RegionWithName::GetEnglishOrTransliteratedName() const
return s;
}
StringUtf8Multilang const & RegionWithName::GetStringUtf8MultilangName() const
StringUtf8Multilang const & RegionWithName::GetMultilangName() const
{
return m_name;
}
void RegionWithName::SetStringUtf8MultilangName(StringUtf8Multilang const & name)
void RegionWithName::SetMultilangName(StringUtf8Multilang const & name)
{
m_name = name;
}
@ -52,16 +51,6 @@ base::GeoObjectId RegionWithData::GetId() const
return m_regionData.GetOsmId();
}
bool RegionWithData::HasAdminCenter() const
{
return m_regionData.HasAdminCenter();
}
base::GeoObjectId RegionWithData::GetAdminCenterId() const
{
return m_regionData.GetAdminCenter();
}
bool RegionWithData::HasIsoCode() const
{
return m_regionData.HasIsoCodeAlpha2();
@ -88,16 +77,20 @@ uint8_t RegionWithData::GetRank() const
case PlaceType::Suburb:
case PlaceType::Neighbourhood:
case PlaceType::Locality:
case PlaceType::IsolatedDwelling: return static_cast<uint8_t>(placeType);
default: break;
case PlaceType::IsolatedDwelling:
return static_cast<uint8_t>(placeType);
default:
break;
}
switch (adminLevel)
{
case AdminLevel::Two:
case AdminLevel::Four:
case AdminLevel::Six: return static_cast<uint8_t>(adminLevel);
default: break;
case AdminLevel::Six:
return static_cast<uint8_t>(adminLevel);
default:
break;
}
return kNoRank;
@ -113,23 +106,68 @@ std::string RegionWithData::GetLabel() const
case PlaceType::City:
case PlaceType::Town:
case PlaceType::Village:
case PlaceType::Hamlet: return "locality";
case PlaceType::Hamlet:
return "locality";
case PlaceType::Suburb:
case PlaceType::Neighbourhood: return "suburb";
case PlaceType::Neighbourhood:
return "suburb";
case PlaceType::Locality:
case PlaceType::IsolatedDwelling: return "sublocality";
default: break;
case PlaceType::IsolatedDwelling:
return "sublocality";
default:
break;
}
switch (adminLevel)
{
case AdminLevel::Two: return "country";
case AdminLevel::Four: return "region";
case AdminLevel::Six: return "subregion";
default: break;
case AdminLevel::Two:
return "country";
case AdminLevel::Four:
return "region";
case AdminLevel::Six:
return "subregion";
default:
break;
}
return "";
}
size_t RegionWithData::GetWeight() const
{
auto const adminLevel = GetAdminLevel();
auto const placeType = GetPlaceType();
switch (placeType)
{
case PlaceType::City:
case PlaceType::Town:
case PlaceType::Village:
case PlaceType::Hamlet:
return 3;
case PlaceType::Suburb:
case PlaceType::Neighbourhood:
return 2;
case PlaceType::Locality:
case PlaceType::IsolatedDwelling:
return 1;
default:
break;
}
switch (adminLevel)
{
case AdminLevel::Two:
return 6;
case AdminLevel::Four:
return 5;
case AdminLevel::Six:
return 4;
default:
break;
}
return 0;
}
} // namespace regions
} // namespace generator

17
generator/regions/region_base.hpp
View file

@ -1,7 +1,7 @@
#pragma once
#include "generator/feature_builder.hpp"
#include "generator/regions/collector_region_info.hpp"
#include "generator/regions/region_info.hpp"
#include "geometry/rect2d.hpp"
@ -23,8 +23,9 @@ using BoostPoint = boost::geometry::model::point<double, 2, boost::geometry::cs:
using BoostPolygon = boost::geometry::model::polygon<BoostPoint>;
using BoostRect = boost::geometry::model::box<BoostPoint>;
struct RegionWithName
class RegionWithName
{
public:
RegionWithName(StringUtf8Multilang const & name) : m_name(name) {}
// This function will take the following steps:
@ -33,22 +34,21 @@ struct RegionWithName
// 3. Otherwise, return empty string.
std::string GetEnglishOrTransliteratedName() const;
std::string GetName(int8_t lang = StringUtf8Multilang::kDefaultCode) const;
StringUtf8Multilang const & GetStringUtf8MultilangName() const;
void SetStringUtf8MultilangName(StringUtf8Multilang const & name);
StringUtf8Multilang const & GetMultilangName() const;
void SetMultilangName(StringUtf8Multilang const & name);
protected:
StringUtf8Multilang m_name;
};
struct RegionWithData
class RegionWithData
{
public:
static uint8_t constexpr kNoRank = 0;
RegionWithData(RegionDataProxy const & regionData) : m_regionData(regionData) {}
base::GeoObjectId GetId() const;
bool HasAdminCenter() const;
base::GeoObjectId GetAdminCenterId() const;
bool HasIsoCode() const;
std::string GetIsoCode() const;
@ -56,6 +56,7 @@ struct RegionWithData
// rank of the second object, then the first object is considered more nested.
uint8_t GetRank() const;
std::string GetLabel() const;
size_t GetWeight() const;
AdminLevel GetAdminLevel() const { return m_regionData.GetAdminLevel(); }
PlaceType GetPlaceType() const { return m_regionData.GetPlaceType(); }
@ -66,6 +67,8 @@ struct RegionWithData
bool HasAdminLevel() const { return m_regionData.HasAdminLevel(); }
bool HasPlaceType() const { return m_regionData.HasPlaceType(); }
RegionDataProxy const & GetRegionData() const { return m_regionData; }
protected:
RegionDataProxy m_regionData;
};

166
generator/regions/region_info.cpp Normal file
View file

@ -0,0 +1,166 @@
#include "generator/regions/region_info.hpp"
#include "generator/regions/collector_region_info.hpp"
#include "coding/file_reader.hpp"
#include "base/assert.hpp"
#include "base/logging.hpp"
#include "base/macros.hpp"
namespace generator
{
namespace regions
{
RegionInfo::RegionInfo(std::string const & filename)
{
ParseFile(filename);
}
RegionInfo::RegionInfo(Platform::FilesList const & filenames)
{
for (auto const & filename : filenames)
ParseFile(filename);
}
void RegionInfo::ParseFile(std::string const & filename)
{
FileReader reader(filename);
ReaderSource<FileReader> src(reader);
uint8_t version;
ReadPrimitiveFromSource(src, version);
CHECK_EQUAL(version, CollectorRegionInfo::kVersion, ());
ReadMap(src, m_mapRegionData);
ReadMap(src, m_mapIsoCode);
}
RegionDataProxy RegionInfo::Get(base::GeoObjectId const & osmId)
{
return RegionDataProxy(*this, osmId);
}
ConstRegionDataProxy RegionInfo::Get(base::GeoObjectId const & osmId) const
{
return ConstRegionDataProxy(*this, osmId);
}
RegionInfo & RegionDataProxy::GetCollector()
{
return m_regionInfoCollector;
}
MapRegionData & RegionDataProxy::GetMapRegionData()
{
return GetCollector().m_mapRegionData;
}
void RegionDataProxy::SetAdminLevel(AdminLevel adminLevel)
{
GetMapRegionData().at(m_osmId).m_adminLevel = adminLevel;
}
void RegionDataProxy::SetPlaceType(PlaceType placeType)
{
GetMapRegionData().at(m_osmId).m_place = placeType;
}
template <typename T>
BaseRegionDataProxy<T>::BaseRegionDataProxy(T & regionInfoCollector, base::GeoObjectId const & osmId)
: m_regionInfoCollector(regionInfoCollector), m_osmId(osmId) {}
template <typename T>
RegionInfo const & BaseRegionDataProxy<T>::GetCollector() const
{
return m_regionInfoCollector;
}
template <typename T>
MapRegionData const & BaseRegionDataProxy<T>::GetMapRegionData() const
{
return GetCollector().m_mapRegionData;
}
template <typename T>
MapIsoCode const & BaseRegionDataProxy<T>::GetMapIsoCode() const
{
return GetCollector().m_mapIsoCode;
}
template <typename T>
base::GeoObjectId const & BaseRegionDataProxy<T>::GetOsmId() const
{
return m_osmId;
}
template <typename T>
AdminLevel BaseRegionDataProxy<T>::GetAdminLevel() const
{
return GetMapRegionData().at(m_osmId).m_adminLevel;
}
template <typename T>
PlaceType BaseRegionDataProxy<T>::GetPlaceType() const
{
return GetMapRegionData().at(m_osmId).m_place;
}
template <typename T>
bool BaseRegionDataProxy<T>::HasAdminLevel() const
{
return (GetMapRegionData().count(m_osmId) != 0) &&
(GetMapRegionData().at(m_osmId).m_adminLevel != AdminLevel::Unknown);
}
template <typename T>
bool BaseRegionDataProxy<T>::HasPlaceType() const
{
return (GetMapRegionData().count(m_osmId) != 0) &&
(GetMapRegionData().at(m_osmId).m_place != PlaceType::Unknown);
}
template <typename T>
bool BaseRegionDataProxy<T>::HasIsoCode() const
{
return GetMapIsoCode().count(m_osmId) != 0;
}
template <typename T>
bool BaseRegionDataProxy<T>::HasIsoCodeAlpha2() const
{
return HasIsoCode() && GetMapIsoCode().at(m_osmId).HasAlpha2();
}
template <typename T>
bool BaseRegionDataProxy<T>::HasIsoCodeAlpha3() const
{
return HasIsoCode() && GetMapIsoCode().at(m_osmId).HasAlpha3();
}
template <typename T>
bool BaseRegionDataProxy<T>::HasIsoCodeAlphaNumeric() const
{
return HasIsoCode() && GetMapIsoCode().at(m_osmId).HasNumeric();
}
template <typename T>
std::string BaseRegionDataProxy<T>::GetIsoCodeAlpha2() const
{
return GetMapIsoCode().at(m_osmId).GetAlpha2();
}
template <typename T>
std::string BaseRegionDataProxy<T>::GetIsoCodeAlpha3() const
{
return GetMapIsoCode().at(m_osmId).GetAlpha3();
}
template <typename T>
std::string BaseRegionDataProxy<T>::GetIsoCodeAlphaNumeric() const
{
return GetMapIsoCode().at(m_osmId).GetNumeric();
}
template class BaseRegionDataProxy<RegionInfo>;
template class BaseRegionDataProxy<RegionInfo const>;
} // namespace regions
} // namespace generator

111
generator/regions/region_info.hpp Normal file
View file

@ -0,0 +1,111 @@
#pragma once
#include "generator/regions/collector_region_info.hpp"
#include "platform/platform.hpp"
#include "coding/reader.hpp"
#include "base/geo_object_id.hpp"
#include <cstdint>
#include <functional>
#include <string>
#include <utility>
namespace generator
{
namespace regions
{
template <typename T>
class BaseRegionDataProxy;
class RegionDataProxy;
class ConstRegionDataProxy;
// RegionInfo class is responsible for reading and accessing additional information about the regions.
class RegionInfo
{
public:
RegionInfo() = default;
explicit RegionInfo(std::string const & filename);
explicit RegionInfo(Platform::FilesList const & filenames);
RegionDataProxy Get(base::GeoObjectId const & osmId);
ConstRegionDataProxy Get(base::GeoObjectId const & osmId) const;
private:
friend class BaseRegionDataProxy<RegionInfo>;
friend class BaseRegionDataProxy<RegionInfo const>;
friend class RegionDataProxy;
friend class ConstRegionDataProxy;
template <typename Source, typename Map>
void ReadMap(Source & src, Map & seq)
{
uint32_t size = 0;
ReadPrimitiveFromSource(src, size);
typename Map::mapped_type data;
for (uint32_t i = 0; i < size; ++i)
{
ReadPrimitiveFromSource(src, data);
seq.emplace(data.m_osmId, std::move(data));
}
}
void ParseFile(std::string const & filename);
MapRegionData m_mapRegionData;
MapIsoCode m_mapIsoCode;
};
template <typename T>
class BaseRegionDataProxy
{
public:
BaseRegionDataProxy(T & regionInfoCollector, base::GeoObjectId const & osmId);
base::GeoObjectId const & GetOsmId() const;
AdminLevel GetAdminLevel() const;
PlaceType GetPlaceType() const;
bool HasAdminLevel() const;
bool HasPlaceType() const;
bool HasIsoCodeAlpha2() const;
bool HasIsoCodeAlpha3() const;
bool HasIsoCodeAlphaNumeric() const;
std::string GetIsoCodeAlpha2() const;
std::string GetIsoCodeAlpha3() const;
std::string GetIsoCodeAlphaNumeric() const;
protected:
bool HasIsoCode() const;
RegionInfo const & GetCollector() const;
MapRegionData const & GetMapRegionData() const;
MapIsoCode const & GetMapIsoCode() const;
std::reference_wrapper<T> m_regionInfoCollector;
base::GeoObjectId m_osmId;
};
class ConstRegionDataProxy : public BaseRegionDataProxy<RegionInfo const>
{
public:
using BaseRegionDataProxy<RegionInfo const>::BaseRegionDataProxy;
};
class RegionDataProxy : public BaseRegionDataProxy<RegionInfo>
{
public:
using BaseRegionDataProxy<RegionInfo>::BaseRegionDataProxy;
void SetAdminLevel(AdminLevel adminLevel);
void SetPlaceType(PlaceType placeType);
private:
RegionInfo & GetCollector();
MapRegionData & GetMapRegionData();
};
} // namespace regions
} // namespace generator

148
generator/regions/regions.cpp
View file

@ -4,8 +4,10 @@
#include "generator/feature_generator.hpp"
#include "generator/generate_info.hpp"
#include "generator/regions/city.hpp"
#include "generator/regions/regions.hpp"
#include "generator/regions/node.hpp"
#include "generator/regions/regions_builder.hpp"
#include "generator/regions/regions_fixer.hpp"
#include "generator/regions/to_string_policy.hpp"
#include "platform/platform.hpp"
@ -13,6 +15,7 @@
#include "coding/file_name_utils.hpp"
#include "coding/transliteration.hpp"
#include "base/assert.hpp"
#include "base/logging.hpp"
#include "base/stl_helpers.hpp"
#include "base/timer.hpp"
@ -37,109 +40,12 @@ namespace regions
{
namespace
{
using PointCitiesMap = std::unordered_map<base::GeoObjectId, City>;
struct RegionsFixer
{
RegionsFixer(RegionsBuilder::Regions & regions, PointCitiesMap const & pointCitiesMap)
: m_regions(regions), m_pointCitiesMap(pointCitiesMap)
{
SplitRegionsByAdminCenter();
CreateNameRegionMap();
}
RegionsBuilder::Regions & FixRegions()
{
SortRegionsByArea();
std::vector<bool> unsuitable;
unsuitable.resize(m_regionsWithAdminCenter.size());
for (size_t i = 0; i < m_regionsWithAdminCenter.size(); ++i)
{
if (unsuitable[i])
continue;
auto & regionWithAdminCenter = m_regionsWithAdminCenter[i];
if (regionWithAdminCenter.IsCountry())
continue;
auto const id = regionWithAdminCenter.GetAdminCenterId();
if (!m_pointCitiesMap.count(id))
continue;
auto const & adminCenter = m_pointCitiesMap.at(id);
auto const placeType = adminCenter.GetPlaceType();
if (placeType == PlaceType::Town || placeType == PlaceType::City)
{
for (size_t j = i + 1; j + 1 < m_regionsWithAdminCenter.size(); ++j)
{
if (m_regionsWithAdminCenter[j].ContainsRect(regionWithAdminCenter))
unsuitable[j] = true;
}
}
if (RegionExistsAsCity(adminCenter))
continue;
regionWithAdminCenter.SetInfo(adminCenter);
}
std::move(std::begin(m_regionsWithAdminCenter), std::end(m_regionsWithAdminCenter),
std::back_inserter(m_regions));
m_regionsWithAdminCenter = {};
return m_regions;
}
private:
bool RegionExistsAsCity(City const & city)
{
auto const range = m_nameRegionMap.equal_range(city.GetName());
for (auto it = range.first; it != range.second; ++it)
{
Region const & r = it->second;
if (city.GetRank() == r.GetRank() && r.Contains(city))
return true;
}
return false;
}
void SplitRegionsByAdminCenter()
{
auto const pred = [](Region const & region) { return region.HasAdminCenter(); };
std::copy_if(std::begin(m_regions), std::end(m_regions),
std::back_inserter(m_regionsWithAdminCenter), pred);
base::EraseIf(m_regions, pred);
}
void CreateNameRegionMap()
{
for (auto const & region : m_regions)
{
auto const name = region.GetName();
if (region.GetLabel() == "locality" && !name.empty())
m_nameRegionMap.emplace(name, region);
}
}
void SortRegionsByArea()
{
auto const cmp = [](Region const & l, Region const & r) { return l.GetArea() < r.GetArea(); };
std::sort(std::begin(m_regions), std::end(m_regions), cmp);
}
RegionsBuilder::Regions & m_regions;
PointCitiesMap const & m_pointCitiesMap;
RegionsBuilder::Regions m_regionsWithAdminCenter;
std::multimap<std::string, std::reference_wrapper<Region const>> m_nameRegionMap;
};
std::tuple<RegionsBuilder::Regions, PointCitiesMap>
ReadDatasetFromTmpMwm(std::string const & tmpMwmFilename, RegionInfo & collector)
{
RegionsBuilder::Regions regions;
PointCitiesMap pointCitiesMap;
auto const toDo = [&regions, &pointCitiesMap, &collector](FeatureBuilder1 const & fb, uint64_t /* currPos */)
{
auto const toDo = [&](FeatureBuilder1 const & fb, uint64_t /* currPos */) {
if (fb.IsArea() && fb.IsGeometryClosed())
{
auto const id = fb.GetMostGenericOsmId();
@ -159,36 +65,39 @@ ReadDatasetFromTmpMwm(std::string const & tmpMwmFilename, RegionInfo & collector
void FilterRegions(RegionsBuilder::Regions & regions)
{
auto const pred = [](Region const & region)
{
auto const pred = [](Region const & region) {
auto const & label = region.GetLabel();
auto const & name = region.GetName();
return label.empty() || name.empty();
};
auto const it = std::remove_if(std::begin(regions), std::end(regions), pred);
regions.erase(it, std::end(regions));
base::EraseIf(regions, pred);
}
RegionsBuilder::Regions ReadData(std::string const & tmpMwmFilename,
RegionInfo & regionsInfoCollector)
RegionsBuilder::Regions ReadAndFixData(std::string const & tmpMwmFilename,
RegionInfo & regionsInfoCollector)
{
RegionsBuilder::Regions regions;
PointCitiesMap pointCitiesMap;
std::tie(regions, pointCitiesMap) = ReadDatasetFromTmpMwm(tmpMwmFilename, regionsInfoCollector);
RegionsFixer fixer(regions, pointCitiesMap);
regions = fixer.FixRegions();
FixRegionsWithPlacePointApproximation(pointCitiesMap, regions);
FilterRegions(regions);
return regions;
}
void RepackTmpMwm(std::string const & srcFilename, std::string const & repackedFilename,
std::set<base::GeoObjectId> const & ids)
std::set<base::GeoObjectId> const & ids, RegionInfo const & regionInfo)
{
feature::FeaturesCollector collector(repackedFilename);
auto const toDo = [&collector, &ids](FeatureBuilder1 const & fb, uint64_t /* currPos */)
{
if (ids.find(fb.GetMostGenericOsmId()) != std::end(ids))
collector(fb);
auto const toDo = [&collector, &ids, &regionInfo](FeatureBuilder1 & fb, uint64_t /* currPos */) {
if (ids.count(fb.GetMostGenericOsmId()) == 0 ||
(fb.IsPoint() && !FeatureCityPointToRegion(regionInfo, fb)))
{
return;
}
CHECK(fb.IsArea(), ());
collector(fb);
};
feature::ForEachFromDatRawFormat(srcFilename, toDo);
@ -207,23 +116,21 @@ bool GenerateRegions(std::string const & pathInRegionsTmpMwm,
Transliteration::Instance().Init(GetPlatform().ResourcesDir());
RegionInfo regionsInfoCollector(pathInRegionsCollector);
RegionsBuilder::Regions regions = ReadData(pathInRegionsTmpMwm, regionsInfoCollector);
RegionsBuilder::Regions regions = ReadAndFixData(pathInRegionsTmpMwm, regionsInfoCollector);
auto jsonPolicy = std::make_unique<JsonPolicy>(verbose);
auto kvBuilder = std::make_unique<RegionsBuilder>(std::move(regions), std::move(jsonPolicy));
auto const countryTrees = kvBuilder->GetCountryTrees();
std::ofstream ofs(pathOutRegionsKv, std::ofstream::out);
std::set<base::GeoObjectId> setIds;
size_t countIds = 0;
for (auto const & countryName : kvBuilder->GetCountryNames())
{
auto const tree = kvBuilder->GetNormalizedCountryTree(countryName);
kvBuilder->ForEachNormalizedCountry([&](std::string const & name, Node::Ptr const & tree) {
if (!tree)
continue;
return;
if (verbose)
DebugPrintTree(tree);
LOG(LINFO, ("Processing country", name));
auto const idStringList = kvBuilder->ToIdStringList(tree);
for (auto const & s : idStringList)
{
@ -232,16 +139,17 @@ bool GenerateRegions(std::string const & pathInRegionsTmpMwm,
if (!setIds.insert(s.first).second)
LOG(LWARNING, ("Id alredy exists:", s.first));
}
}
});
// todo(maksimandrianov1): Perhaps this is not the best solution. This is a hot fix. Perhaps it
// is better to transfer this to index generation(function GenerateRegionsData),
// or to combine index generation and key-value storage generation in
// generator_tool(generator_tool.cpp).
if (!pathOutRepackedRegionsTmpMwm.empty())
RepackTmpMwm(pathInRegionsTmpMwm, pathOutRepackedRegionsTmpMwm, setIds);
RepackTmpMwm(pathInRegionsTmpMwm, pathOutRepackedRegionsTmpMwm, setIds, regionsInfoCollector);
LOG(LINFO, ("Regions objects key-value storage saved to", pathOutRegionsKv));
LOG(LINFO, ("Regions objects key-value for", kvBuilder->GetCountryNames().size(),
"countries storage saved to", pathOutRegionsKv));
LOG(LINFO, ("Repacked regions temprory mwm saved to", pathOutRepackedRegionsTmpMwm));
LOG(LINFO, (countIds, "total ids.", setIds.size(), "unique ids."));
LOG(LINFO, ("Finish generating regions.", timer.ElapsedSeconds(), "seconds."));

113
generator/regions/regions_builder.cpp
View file

@ -18,22 +18,34 @@ namespace generator
{
namespace regions
{
namespace
{
Node::Ptr ShrinkToFit(Node::Ptr p)
{
p->ShrinkToFitChildren();
for (auto ptr : p->GetChildren())
ShrinkToFit(ptr);
return p;
}
} // namespace
RegionsBuilder::RegionsBuilder(Regions && regions,
std::unique_ptr<ToStringPolicyInterface> toStringPolicy,
int cpuCount)
: m_toStringPolicy(std::move(toStringPolicy)),
m_cpuCount(cpuCount)
: m_toStringPolicy(std::move(toStringPolicy))
, m_regions(std::move(regions))
, m_cpuCount(cpuCount)
{
ASSERT(m_toStringPolicy, ());
ASSERT(m_cpuCount != 0, ());
auto const isCountry = [](Region const & r) { return r.IsCountry(); };
std::copy_if(std::begin(regions), std::end(regions), std::back_inserter(m_countries), isCountry);
base::EraseIf(regions, isCountry);
std::copy_if(std::begin(m_regions), std::end(m_regions), std::back_inserter(m_countries), isCountry);
base::EraseIf(m_regions, isCountry);
auto const cmp = [](Region const & l, Region const & r) { return l.GetArea() > r.GetArea(); };
std::sort(std::begin(m_countries), std::end(m_countries), cmp);
MakeCountryTrees(regions);
}
RegionsBuilder::RegionsBuilder(Regions && regions, int cpuCount)
@ -58,12 +70,7 @@ RegionsBuilder::StringsList RegionsBuilder::GetCountryNames() const
return result;
}
RegionsBuilder::CountryTrees const & RegionsBuilder::GetCountryTrees() const
{
return m_countryTrees;
}
RegionsBuilder::IdStringList RegionsBuilder::ToIdStringList(Node::Ptr tree) const
RegionsBuilder::IdStringList RegionsBuilder::ToIdStringList(Node::Ptr const & tree) const
{
IdStringList result;
std::queue<Node::Ptr> queue;
@ -99,8 +106,7 @@ Node::PtrList RegionsBuilder::MakeSelectedRegionsByCountry(Region const & countr
std::back_inserter(regionsInCountry), filterCopy);
regionsInCountry.emplace_back(country);
auto const comp = [](const Region & l, const Region & r)
{
auto const comp = [](const Region & l, const Region & r) {
auto const lArea = l.GetArea();
auto const rArea = r.GetArea();
return lArea != rArea ? lArea > rArea : l.GetRank() < r.GetRank();
@ -127,26 +133,13 @@ Node::Ptr RegionsBuilder::BuildCountryRegionTree(Region const & country,
for (; itCurr != std::rend(nodes); ++itCurr)
{
auto const & currRegion = (*itCurr)->GetData();
// If Contains returns false, then we calculate the percent overlap of polygons.
// We believe that if one polygon overlaps by 98 percent, then we can assume that one
// contains another.
auto const kAvaliableOverlapPercentage = 98;
if (currRegion.ContainsRect(firstRegion) &&
(currRegion.Contains(firstRegion) ||
currRegion.CalculateOverlapPercentage(firstRegion) > kAvaliableOverlapPercentage))
if (currRegion.Contains(firstRegion) ||
(firstRegion.GetWeight() < currRegion.GetWeight() &&
currRegion.Contains(firstRegion.GetCenter()) &&
currRegion.CalculateOverlapPercentage(firstRegion) > 50.0))
{
// In general, we assume that a region with the larger rank has the larger area.
// But sometimes it does not. In this case, we will make an inversion.
if (firstRegion.GetRank() < currRegion.GetRank())
{
(*itCurr)->SetParent(*itFirstNode);
(*itFirstNode)->AddChild(*itCurr);
}
else
{
(*itFirstNode)->SetParent(*itCurr);
(*itCurr)->AddChild(*itFirstNode);
}
(*itFirstNode)->SetParent(*itCurr);
(*itCurr)->AddChild(*itFirstNode);
// We want to free up memory.
firstRegion.DeletePolygon();
nodes.pop_back();
@ -158,40 +151,44 @@ Node::Ptr RegionsBuilder::BuildCountryRegionTree(Region const & country,
nodes.pop_back();
}
return nodes.empty() ? std::shared_ptr<Node>() : nodes.front();
return nodes.empty() ? std::shared_ptr<Node>() : ShrinkToFit(nodes.front());
}
void RegionsBuilder::MakeCountryTrees(Regions const & regions)
void RegionsBuilder::ForEachNormalizedCountry(NormalizedCountryFn fn)
{
std::vector<std::future<Node::Ptr>> results;
for (auto const & countryName : GetCountryNames())
{
int const cpuCount = m_cpuCount > 0 ? m_cpuCount : std::thread::hardware_concurrency();
RegionsBuilder::Regions country;
auto const & countries = GetCountries();
auto const pred = [&](const Region & r) { return countryName == r.GetName(); };
std::copy_if(std::begin(countries), std::end(countries), std::back_inserter(country), pred);
auto const countryTrees = BuildCountryRegionTrees(country);
auto mergedTree = std::accumulate(std::begin(countryTrees), std::end(countryTrees),
Node::Ptr(), MergeTree);
NormalizeTree(mergedTree);
fn(countryName, mergedTree);
}
}
std::vector<Node::Ptr> RegionsBuilder::BuildCountryRegionTrees(RegionsBuilder::Regions const & countries)
{
std::vector<std::future<Node::Ptr>> tmp;
{
size_t const cpuCount = m_cpuCount > 0 ? static_cast<size_t>(m_cpuCount)
: std::thread::hardware_concurrency();
ASSERT_GREATER(cpuCount, 0, ());
ThreadPool threadPool(cpuCount);
for (auto const & country : GetCountries())
for (auto const & country : countries)
{
auto result = threadPool.enqueue(&RegionsBuilder::BuildCountryRegionTree, country, regions);
results.emplace_back(std::move(result));
auto result = threadPool.enqueue(&RegionsBuilder::BuildCountryRegionTree, country, m_regions);
tmp.emplace_back(std::move(result));
}
}
for (auto & result : results)
{
auto tree = result.get();
m_countryTrees.emplace(tree->GetData().GetName(), std::move(tree));
}
}
Node::Ptr RegionsBuilder::GetNormalizedCountryTree(std::string const & name)
{
Node::Ptr mergedTree;
CountryTrees const & countryTrees = GetCountryTrees();
auto const keyRange = countryTrees.equal_range(name);
using countryTreeItem = typename RegionsBuilder::CountryTrees::value_type;
auto const binOp = [](Node::Ptr l, countryTreeItem r) { return MergeTree(l, r.second); };
mergedTree = std::accumulate(keyRange.first, keyRange.second, Node::Ptr(), binOp);
NormalizeTree(mergedTree);
return mergedTree;
std::vector<Node::Ptr> res;
res.reserve(tmp.size());
std::transform(std::begin(tmp), std::end(tmp),
std::back_inserter(res), [](auto & f) { return f.get(); });
return res;
}
} // namespace regions
} // namespace generator

12
generator/regions/regions_builder.hpp
View file

@ -4,6 +4,7 @@
#include "generator/regions/region.hpp"
#include "generator/regions/to_string_policy.hpp"
#include <functional>
#include <map>
#include <memory>
#include <string>
@ -22,6 +23,7 @@ public:
using StringsList = std::vector<std::string>;
using IdStringList = std::vector<std::pair<base::GeoObjectId, std::string>>;
using CountryTrees = std::multimap<std::string, Node::Ptr>;
using NormalizedCountryFn = std::function<void(std::string const &, Node::Ptr const &)>;
explicit RegionsBuilder(Regions && regions,
std::unique_ptr<ToStringPolicyInterface> toStringPolicy,
@ -30,19 +32,17 @@ public:
Regions const & GetCountries() const;
StringsList GetCountryNames() const;
CountryTrees const & GetCountryTrees() const;
IdStringList ToIdStringList(Node::Ptr tree) const;
Node::Ptr GetNormalizedCountryTree(std::string const & name);
void ForEachNormalizedCountry(NormalizedCountryFn fn);
IdStringList ToIdStringList(Node::Ptr const & tree) const;
private:
static Node::PtrList MakeSelectedRegionsByCountry(Region const & country,
Regions const & allRegions);
static Node::Ptr BuildCountryRegionTree(Region const & country, Regions const & allRegions);
void MakeCountryTrees(Regions const & regions);
std::vector<Node::Ptr> BuildCountryRegionTrees(RegionsBuilder::Regions const & countries);
std::unique_ptr<ToStringPolicyInterface> m_toStringPolicy;
CountryTrees m_countryTrees;
Regions m_countries;
Regions m_regions;
int m_cpuCount;
};
} // namespace regions

100
generator/regions/regions_fixer.cpp Normal file
View file

@ -0,0 +1,100 @@
#include "generator/regions/regions_fixer.hpp"
#include "base/logging.hpp"
#include <algorithm>
#include <cmath>
#include <functional>
#include <iterator>
#include <map>
#include <set>
#include <string>
#include <utility>
#include <boost/optional.hpp>
namespace generator
{
namespace regions
{
namespace
{
class RegionLocalityChecker
{
public:
RegionLocalityChecker() = default;
explicit RegionLocalityChecker(RegionsBuilder::Regions const & regions)
{
for (auto const & region : regions)
{
auto const name = region.GetName();
if (region.IsLocality() && !name.empty())
m_nameRegionMap.emplace(std::move(name), region);
}
}
bool CityExistsAsRegion(City const & city)
{
auto const range = m_nameRegionMap.equal_range(city.GetName());
for (auto it = range.first; it != range.second; ++it)
{
Region const & r = it->second;
if (city.GetRank() == r.GetRank() && r.Contains(city))
return true;
}
return false;
}
private:
std::multimap<std::string, std::reference_wrapper<Region const>> m_nameRegionMap;
};
class RegionsFixerWithPlacePointApproximation
{
public:
explicit RegionsFixerWithPlacePointApproximation(RegionsBuilder::Regions && regions,
PointCitiesMap const & pointCitiesMap)
: m_regions(std::move(regions)), m_pointCitiesMap(pointCitiesMap) {}
RegionsBuilder::Regions && GetFixedRegions()
{
RegionLocalityChecker regionsChecker(m_regions);
RegionsBuilder::Regions approximatedRegions;
size_t countOfFixedRegions = 0;
for (auto const & cityKeyValue : m_pointCitiesMap)
{
auto const & city = cityKeyValue.second;
if (!regionsChecker.CityExistsAsRegion(city) && NeedCity(city))
{
approximatedRegions.push_back(Region(city));
++countOfFixedRegions;
}
}
LOG(LINFO, ("City boundaries restored by approximation:", countOfFixedRegions));
std::move(std::begin(approximatedRegions), std::end(approximatedRegions),
std::back_inserter(m_regions));
return std::move(m_regions);
}
private:
bool NeedCity(const City & city)
{
return city.HasPlaceType() && city.GetPlaceType() != PlaceType::Locality;
}
RegionsBuilder::Regions m_regions;
PointCitiesMap const & m_pointCitiesMap;
};
} // namespace
void FixRegionsWithPlacePointApproximation(PointCitiesMap const & pointCitiesMap,
RegionsBuilder::Regions & regions)
{
RegionsFixerWithPlacePointApproximation fixer(std::move(regions), pointCitiesMap);
regions = fixer.GetFixedRegions();
}
} // namespace regions
} // namespace generator

18
generator/regions/regions_fixer.hpp Normal file
View file

@ -0,0 +1,18 @@
#pragma once
#include "generator/regions/city.hpp"
#include "generator/regions/regions_builder.hpp"
#include "base/geo_object_id.hpp"
#include <vector>
namespace generator
{
namespace regions
{
// This function will build a boundary from point based on place.
void FixRegionsWithPlacePointApproximation(PointCitiesMap const & pointCitiesMap,
RegionsBuilder::Regions & regions);
} // namespace regions
} // namespace generator

24
generator/regions/to_string_policy.cpp
View file

@ -1,7 +1,11 @@
#include "generator/regions/to_string_policy.hpp"
#include "geometry/mercator.hpp"
#include <cstdint>
#include <memory>
#include <boost/optional.hpp>
#include <boost/range/adaptor/reversed.hpp>
#include "3party/jansson/myjansson.hpp"
@ -10,7 +14,7 @@ namespace generator
{
namespace regions
{
std::string JsonPolicy::ToString(Node::PtrList const & nodePtrList)
std::string JsonPolicy::ToString(Node::PtrList const & nodePtrList) const
{
auto const & main = nodePtrList.front()->GetData();
auto const & country = nodePtrList.back()->GetData();
@ -18,13 +22,16 @@ std::string JsonPolicy::ToString(Node::PtrList const & nodePtrList)
auto geometry = base::NewJSONObject();
ToJSONObject(*geometry, "type", "Point");
auto coordinates = base::NewJSONArray();
auto const center = main.GetCenter();
ToJSONArray(*coordinates, center.get<0>());
ToJSONArray(*coordinates, center.get<1>());
auto const tmpCenter = main.GetCenter();
auto const center = MercatorBounds::ToLatLon({tmpCenter.get<0>(), tmpCenter.get<1>()});
ToJSONArray(*coordinates, center.lat);
ToJSONArray(*coordinates, center.lon);
ToJSONObject(*geometry, "coordinates", coordinates);
auto localeEn = base::NewJSONObject();
auto address = base::NewJSONObject();
auto const mainLabel = main.GetLabel();
boost::optional<int64_t> pid;
for (auto const & p : boost::adaptors::reverse(nodePtrList))
{
@ -33,12 +40,14 @@ std::string JsonPolicy::ToString(Node::PtrList const & nodePtrList)
ToJSONObject(*address, label, region.GetName());
if (m_extendedOutput)
{
ToJSONObject(*address, label + "_i", region.GetId().GetSerialId());
ToJSONObject(*address, label + "_i", DebugPrint(region.GetId()));
ToJSONObject(*address, label + "_a", region.GetArea());
ToJSONObject(*address, label + "_r", region.GetRank());
}
ToJSONObject(*localeEn, label, region.GetEnglishOrTransliteratedName());
if (label != mainLabel)
pid = static_cast<int64_t>(region.GetId().GetEncodedId());
}
auto locales = base::NewJSONObject();
@ -49,6 +58,11 @@ std::string JsonPolicy::ToString(Node::PtrList const & nodePtrList)
ToJSONObject(*properties, "rank", main.GetRank());
ToJSONObject(*properties, "address", address);
ToJSONObject(*properties, "locales", locales);
if (pid)
ToJSONObject(*properties, "pid", *pid);
else
ToJSONObject(*properties, "pid", base::NewJSONNull());
if (country.HasIsoCode())
ToJSONObject(*properties, "code", country.GetIsoCode());

4
generator/regions/to_string_policy.hpp
View file

@ -13,7 +13,7 @@ class ToStringPolicyInterface
public:
virtual ~ToStringPolicyInterface() = default;
virtual std::string ToString(Node::PtrList const & nodePtrList) = 0;
virtual std::string ToString(Node::PtrList const & nodePtrList) const = 0;
};
class JsonPolicy : public ToStringPolicyInterface
@ -21,7 +21,7 @@ class JsonPolicy : public ToStringPolicyInterface
public:
JsonPolicy(bool extendedOutput = false) : m_extendedOutput(extendedOutput) {}
std::string ToString(Node::PtrList const & nodePtrList) override;
std::string ToString(Node::PtrList const & nodePtrList) const override;
private:
bool m_extendedOutput;

6
generator/translator_region.cpp
View file

@ -30,12 +30,6 @@ bool TranslatorRegion::IsSuitableElement(OsmElement const * p) const
if (t.key == "place" && places.find(t.value) != places.end())
return true;
auto const & members = p->Members();
auto const pred = [](OsmElement::Member const & m) { return m.role == "admin_centre"; };
if (t.key == "boundary" && t.value == "political" &&
std::find_if(std::begin(members), std::end(members), pred) != std::end(members))
return true;
if (t.key == "boundary" && t.value == "administrative")
return true;
}