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

[generator] Fixed optimization with countries borders.

Browse source
This commit is contained in:
Maksim Andrianov 2019-12-27 19:16:36 +03:00 • committed by gmoryes
parent 52a14feb16
commit cc9ed5436b
4 changed files with 58 additions and 90 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
generator/affiliation.cpp
View file

@ -19,7 +19,7 @@ BOOST_GEOMETRY_REGISTER_RING(std::vector<m2::PointD>);
namespace feature
{
CountriesFilesAffiliation::CountriesFilesAffiliation(std::string const & borderPath, bool haveBordersForWholeWorld)
: m_countries(borders::PackedBorders::GetOrCreate(borderPath))
: m_countryPolygonsTree(borders::GetOrCreateCountryPolygonsTree(borderPath))
, m_haveBordersForWholeWorld(haveBordersForWholeWorld)
{
}
@ -28,7 +28,7 @@ std::vector<std::string> CountriesFilesAffiliation::GetAffiliations(FeatureBuild
{
std::vector<std::string> countries;
std::vector<std::reference_wrapper<borders::CountryPolygons const>> countriesContainer;
m_countries.ForEachInRect(fb.GetLimitRect(), [&](auto const & countryPolygons) {
m_countryPolygonsTree.ForEachPolygonInRect(fb.GetLimitRect(), [&](auto const & countryPolygons) {
countriesContainer.emplace_back(countryPolygons);
});
@ -59,7 +59,7 @@ CountriesFilesAffiliation::GetAffiliations(m2::PointD const & point) const
{
std::vector<std::string> countries;
std::vector<std::reference_wrapper<borders::CountryPolygons const>> countriesContainer;
m_countries.ForEachInRect(m2::RectD(point, point), [&](auto const & countryPolygons) {
m_countryPolygonsTree.ForEachPolygonInRect(m2::RectD(point, point), [&](auto const & countryPolygons) {
countriesContainer.emplace_back(countryPolygons);
});
@ -83,7 +83,7 @@ CountriesFilesAffiliation::GetAffiliations(m2::PointD const & point) const
bool CountriesFilesAffiliation::HasRegionByName(std::string const & name) const
{
return m_countries.HasRegionByName(name);
return m_countryPolygonsTree.HasRegionByName(name);
}
CountriesFilesIndexAffiliation::CountriesFilesIndexAffiliation(std::string const & borderPath,
@ -188,7 +188,7 @@ CountriesFilesIndexAffiliation::BuildIndex(const std::vector<m2::RectD> & net)
{
pool.SubmitWork([&, rect]() {
std::vector<std::reference_wrapper<borders::CountryPolygons const>> countries;
m_countries.ForEachInRect(rect, [&](auto const & country) {
m_countryPolygonsTree.ForEachPolygonInRect(rect, [&](auto const & country) {
countries.emplace_back(country);
});
if (m_haveBordersForWholeWorld && countries.size() == 1)
@ -203,8 +203,8 @@ CountriesFilesIndexAffiliation::BuildIndex(const std::vector<m2::RectD> & net)
std::vector<std::reference_wrapper<borders::CountryPolygons const>> interCountries;
for (borders::CountryPolygons const & cp : countries)
{
cp.ForAnyRegionGeometry([&](auto const & geometry) {
if (!boost::geometry::intersects(geometry, box))
cp.ForAnyRegion([&](auto const & region) {
if (!boost::geometry::intersects(region.Data(), box))
return false;
interCountries.emplace_back(cp);
return true;

2
generator/affiliation.hpp
View file

@ -36,7 +36,7 @@ public:
bool HasRegionByName(std::string const & name) const override;
protected:
borders::CountriesContainer const & m_countries;
borders::CountryPolygonsCollection const & m_countryPolygonsTree;
bool m_haveBordersForWholeWorld;
};

71
generator/borders.cpp
View file

@ -47,35 +47,20 @@ public:
{
RegionsContainer regions;
for (m2::RegionD const & border : borders)
{
m2::RectD const rect(border.GetRect());
m_rect.Add(rect);
regions.Add(border, rect);
}
regions.Add(border, border.GetRect());
m_polygons = CountryPolygons(name, regions);
}
CountryPolygons countryPolygons(name, regions);
void Finish()
{
if (!m_polygons.IsEmpty())
{
ASSERT_NOT_EQUAL(m_rect, m2::RectD::GetEmptyRect(), ());
m_countries.Add(std::move(m_polygons), std::move(m_rect));
}
m_polygons.Clear();
m_rect.MakeEmpty();
for (m2::RegionD const & border : borders)
m_countries.Add(countryPolygons, border.GetRect());
}
private:
m4::Tree<CountryPolygons> & m_countries;
CountryPolygons m_polygons;
m2::RectD m_rect;
};
template <class ToDo>
void ForEachCountry(std::string const & baseDir, ToDo & toDo)
void ForEachCountry(std::string const & baseDir, ToDo && toDo)
{
std::string const bordersDir = base::JoinPath(baseDir, BORDERS_DIR);
CHECK(Platform::IsFileExistsByFullPath(bordersDir),
@ -90,7 +75,6 @@ void ForEachCountry(std::string const & baseDir, ToDo & toDo)
{
base::GetNameWithoutExt(file);
toDo(file, borders);
toDo.Finish();
}
}
}
@ -133,8 +117,6 @@ public:
}
}
void Finish() {}
void WritePolygonsInfo()
{
auto w = m_writer.GetWriter(PACKED_POLYGONS_INFO_TAG);
@ -221,23 +203,22 @@ bool GetBordersRect(std::string const & baseDir, std::string const & country,
return true;
}
bool LoadCountriesList(std::string const & baseDir, CountriesContainer & countries)
CountryPolygonsCollection LoadCountriesList(std::string const & baseDir)
{
m4::Tree<CountryPolygons> regionsTree;
LOG(LINFO, ("Loading countries."));
PolygonLoader loader(regionsTree);
ForEachCountry(baseDir, loader);
CountryPolygonsCollection countryPolygonsCollection;
ForEachCountry(baseDir, [&](auto const & name, auto const & borders) {
RegionsContainer regions;
for (m2::RegionD const & border : borders)
regions.Add(border, border.GetRect());
LOG(LINFO, ("Countries loaded:", regionsTree.GetSize()));
countryPolygonsCollection.Add(CountryPolygons(name, regions));
});
if (!regionsTree.IsEmpty())
{
countries = CountriesContainer(regionsTree);
return true;
}
return false;
LOG(LINFO, ("Countries loaded:", countryPolygonsCollection.GetSize()));
CHECK_NOT_EQUAL(countryPolygonsCollection.GetSize(), 0, (baseDir));
return countryPolygonsCollection;
}
void GeneratePackedBorders(std::string const & baseDir)
@ -295,22 +276,18 @@ void UnpackBorders(std::string const & baseDir, std::string const & targetDir)
}
}
// static
std::mutex PackedBorders::m_mutex;
// static
std::unordered_map<std::string, CountriesContainer> PackedBorders::m_countries;
// static
CountriesContainer const & PackedBorders::GetOrCreate(std::string const & name)
CountryPolygonsCollection const & GetOrCreateCountryPolygonsTree(std::string const & baseDir)
{
std::lock_guard<std::mutex> lock(m_mutex);
auto const it = m_countries.find(name);
if (it != m_countries.cend())
static std::mutex mutex;
static std::unordered_map<std::string, CountryPolygonsCollection> countriesMap;
std::lock_guard<std::mutex> lock(mutex);
auto const it = countriesMap.find(baseDir);
if (it != countriesMap.cend())
return it->second;
CountriesContainer countries;
CHECK(LoadCountriesList(name, countries), ("Error loading country polygons files."));
auto const eIt = m_countries.emplace(name, countries);
auto const eIt = countriesMap.emplace(baseDir, LoadCountriesList(baseDir));
return eIt.first->second;
}
} // namespace borders

61
generator/borders.hpp
View file

@ -74,11 +74,15 @@ public:
}
template <typename Do>
bool ForAnyRegionGeometry(Do && fn) const
void ForEachRegion(Do && fn) const
{
return m_regions.ForAny([&](auto const & region) {
return fn(region.Data());
});
m_regions.ForEach(std::forward<Do>(fn));
}
template <typename Do>
bool ForAnyRegion(Do && fn) const
{
return m_regions.ForAny(std::forward<Do>(fn));
}
private:
@ -86,48 +90,43 @@ private:
RegionsContainer m_regions;
};
class CountriesContainer
class CountryPolygonsCollection
{
public:
CountriesContainer() = default;
explicit CountriesContainer(m4::Tree<CountryPolygons> const & tree)
: m_regionsTree(tree)
CountryPolygonsCollection() = default;
void Add(CountryPolygons const & countryPolygons)
{
auto const it = m_countryPolygonsMap.emplace(countryPolygons.GetName(), countryPolygons);
countryPolygons.ForEachRegion([&](auto const & region){
m_regionsTree.Add(it.first->second, region.GetRect());
return true;
});
}
size_t GetSize() const { return m_countryPolygonsMap.size(); }
template <typename ToDo>
void ForEachInRect(m2::RectD const & rect, ToDo && toDo) const
void ForEachPolygonInRect(m2::RectD const & rect, ToDo && toDo) const
{
m_regionsTree.ForEachInRect(rect, std::forward<ToDo>(toDo));
}
bool HasRegionByName(std::string const & name) const
{
return m_regionsTree.FindNode([&](auto const & countryPolygons) {
return countryPolygons.GetName() == name;
});
return m_countryPolygonsMap.count(name) != 0;
}
CountryPolygons const & GetRegionByName(std::string const & name) const
{
ASSERT(HasRegionByName(name), ());
CountryPolygons const * country = nullptr;
m_regionsTree.FindNode([&](auto const & countryPolygons) {
if (countryPolygons.GetName() == name)
{
country = &countryPolygons;
return true;
}
return false;
});
return *country;
return m_countryPolygonsMap.at(name);
}
private:
m4::Tree<CountryPolygons> m_regionsTree;
m4::Tree<std::reference_wrapper<const CountryPolygons>> m_regionsTree;
std::unordered_map<std::string, CountryPolygons> m_countryPolygonsMap;
};
/// @return false if borderFile can't be opened
@ -136,7 +135,7 @@ bool LoadBorders(std::string const & borderFile, std::vector<m2::RegionD> & outB
bool GetBordersRect(std::string const & baseDir, std::string const & country,
m2::RectD & bordersRect);
bool LoadCountriesList(std::string const & baseDir, CountriesContainer & countries);
bool LoadCountriesList(std::string const & baseDir, CountryPolygonsCollection & countries);
void GeneratePackedBorders(std::string const & baseDir);
@ -159,13 +158,5 @@ void DumpBorderToPolyFile(std::string const & filePath, storage::CountryId const
std::vector<m2::RegionD> const & polygons);
void UnpackBorders(std::string const & baseDir, std::string const & targetDir);
class PackedBorders
{
public:
static CountriesContainer const & GetOrCreate(std::string const & name);
private:
static std::mutex m_mutex;
static std::unordered_map<std::string, CountriesContainer> m_countries;
};
CountryPolygonsCollection const & GetOrCreateCountryPolygonsTree(std::string const & baseDir);
} // namespace borders