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

[generator:regions] Generate features with build geometry

Browse source
This commit is contained in:
Anatoly Serdtcev 2019-06-05 13:02:10 +03:00
parent d07cd2dd15
commit 90c178a86c
10 changed files with 205 additions and 276 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

17
generator/generator_tests/regions_tests.cpp
View file

@ -185,7 +185,7 @@ UNIT_TEST(RegionsBuilderTest_GetCountryNames)
auto const filename = MakeCollectorData();
RegionInfo collector(filename);
RegionsBuilder builder(MakeTestDataSet1(collector));
auto const countryNames = builder.GetCountryNames();
auto const & countryNames = builder.GetCountryNames();
TEST_EQUAL(countryNames.size(), 2, ());
TEST(std::count(std::begin(countryNames), std::end(countryNames), "Country_1"), ());
TEST(std::count(std::begin(countryNames), std::end(countryNames), "Country_2"), ());
@ -196,7 +196,7 @@ UNIT_TEST(RegionsBuilderTest_GetCountries)
auto const filename = MakeCollectorData();
RegionInfo collector(filename);
RegionsBuilder builder(MakeTestDataSet1(collector));
auto const countries = builder.GetCountries();
auto const & countries = builder.GetCountriesOuters();
TEST_EQUAL(countries.size(), 3, ());
TEST_EQUAL(std::count_if(std::begin(countries), std::end(countries),
[](const Region & r) {return r.GetName() == "Country_1"; }), 1, ());
@ -210,11 +210,14 @@ UNIT_TEST(RegionsBuilderTest_GetCountryTrees)
RegionInfo collector(filename);
std::vector<std::string> bankOfNames;
RegionsBuilder builder(MakeTestDataSet1(collector));
builder.ForEachNormalizedCountry([&](std::string const & name, Node::Ptr const & tree) {
ForEachLevelPath(tree, [&](NodePath const & path) {
StringJoinPolicy stringifier;
bankOfNames.push_back(stringifier.ToString(path));
});
builder.ForEachCountry([&](std::string const & name, Node::PtrList const & outers) {
for (auto const & tree : outers)
{
ForEachLevelPath(tree, [&](NodePath const & path) {
StringJoinPolicy stringifier;
bankOfNames.push_back(stringifier.ToString(path));
});
}
});
TEST(NameExists(bankOfNames, "Country_2"), ());

6
generator/place_node.hpp
View file

@ -32,12 +32,6 @@ 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;

1
generator/popularity.hpp
View file

@ -53,7 +53,6 @@ public:
bool Contains(PopularityGeomPlace const & smaller) const;
bool Contains(m2::PointD const & point) const;
feature::FeatureBuilder const & GetFeature() const { return m_feature; }
void DeletePolygon() { m_polygon = nullptr; }
double GetArea() const { return m_area; }
base::GeoObjectId GetId() const { return m_id; }

100
generator/regions/node.cpp
View file

@ -11,69 +11,7 @@ namespace generator
{
namespace regions
{
namespace
{
using MergeFunc = std::function<Node::Ptr(Node::Ptr, Node::Ptr)>;
bool LessNodePtrById(Node::Ptr l, Node::Ptr r)
{
auto const & lRegion = l->GetData();
auto const & rRegion = r->GetData();
return lRegion.GetId() < rRegion.GetId();
}
Node::PtrList MergeChildren(Node::PtrList const & l, Node::PtrList const & r, Node::Ptr newParent)
{
Node::PtrList result(l);
std::copy(std::begin(r), std::end(r), std::back_inserter(result));
for (auto & p : result)
p->SetParent(newParent);
std::sort(std::begin(result), std::end(result), LessNodePtrById);
return result;
}
Node::PtrList NormalizeChildren(Node::PtrList const & children, MergeFunc mergeTree)
{
Node::PtrList uniqueChildren;
auto const pred = [](Node::Ptr l, Node::Ptr r)
{
auto const & lRegion = l->GetData();
auto const & rRegion = r->GetData();
return lRegion.GetId() == rRegion.GetId();
};
std::unique_copy(std::begin(children), std::end(children),
std::back_inserter(uniqueChildren), pred);
Node::PtrList result;
for (auto const & ch : uniqueChildren)
{
auto const bounds = std::equal_range(std::begin(children), std::end(children), ch,
LessNodePtrById);
auto merged = std::accumulate(bounds.first, bounds.second, Node::Ptr(), mergeTree);
result.emplace_back(std::move(merged));
}
return result;
}
Node::Ptr MergeHelper(Node::Ptr l, Node::Ptr r, MergeFunc mergeTree)
{
auto const & lChildren = l->GetChildren();
auto const & rChildren = r->GetChildren();
auto const children = MergeChildren(lChildren, rChildren, l);
if (children.empty())
return l;
auto resultChildren = NormalizeChildren(children, mergeTree);
l->SetChildren(std::move(resultChildren));
l->ShrinkToFitChildren();
r->RemoveChildren();
r->ShrinkToFitChildren();
return l;
}
} // nmespace
size_t TreeSize(Node::Ptr node)
size_t TreeSize(Node::Ptr const & node)
{
if (node == nullptr)
return 0;
@ -85,7 +23,7 @@ size_t TreeSize(Node::Ptr node)
return size;
}
size_t MaxDepth(Node::Ptr node)
size_t MaxDepth(Node::Ptr const & node)
{
if (node == nullptr)
return 0;
@ -133,7 +71,7 @@ NodePath MakeLevelPath(Node::Ptr const & node)
return path;
}
void PrintTree(Node::Ptr node, std::ostream & stream = std::cout, std::string prefix = "",
void PrintTree(Node::Ptr const & node, std::ostream & stream = std::cout, std::string prefix = "",
bool isTail = true)
{
auto const & children = node->GetChildren();
@ -171,37 +109,5 @@ void DebugPrintTree(Node::Ptr const & tree, std::ostream & stream)
PrintTree(tree, stream);
stream << std::endl;
}
Node::Ptr MergeTree(Node::Ptr l, Node::Ptr r)
{
if (l == nullptr)
return r;
if (r == nullptr)
return l;
auto const & lRegion = l->GetData();
auto const & rRegion = r->GetData();
if (lRegion.GetId() != rRegion.GetId())
return nullptr;
if (lRegion.GetArea() > rRegion.GetArea())
return MergeHelper(l, r, MergeTree);
else
return MergeHelper(r, l, MergeTree);
}
void NormalizeTree(Node::Ptr tree)
{
if (tree == nullptr)
return;
auto & children = tree->GetChildren();
std::sort(std::begin(children), std::end(children), LessNodePtrById);
auto newChildren = NormalizeChildren(children, MergeTree);
tree->SetChildren(std::move(newChildren));
for (auto const & ch : tree->GetChildren())
NormalizeTree(ch);
}
} // namespace regions
} // namespace generator

11
generator/regions/node.hpp
View file

@ -29,17 +29,10 @@ void ForEachLevelPath(Node::Ptr const & tree, Fn && fn)
ForEachLevelPath(subtree, fn);
}
size_t TreeSize(Node::Ptr node);
size_t TreeSize(Node::Ptr const & node);
size_t MaxDepth(Node::Ptr node);
size_t MaxDepth(Node::Ptr const & node);
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);
// This function corrects the tree. It traverses the whole node and unites children with
// the same ids.
void NormalizeTree(Node::Ptr tree);
} // namespace regions
} // namespace generator

47
generator/regions/region.cpp
View file

@ -19,7 +19,6 @@ namespace generator
{
namespace regions
{
BoostPolygon MakePolygonWithRadius(BoostPoint const & point, double radius, size_t numPoints = 16)
{
boost::geometry::strategy::buffer::point_circle point_strategy(numPoints);
@ -35,6 +34,7 @@ BoostPolygon MakePolygonWithRadius(BoostPoint const & point, double radius, size
CHECK_EQUAL(result.size(), 1, ());
return std::move(result.front());
}
Region::Region(FeatureBuilder const & fb, RegionDataProxy const & rd)
: RegionWithName(fb.GetParams().name)
, RegionWithData(rd)
@ -81,26 +81,15 @@ double Region::GetRadiusByPlaceType(PlaceType place)
UNREACHABLE();
}
void Region::DeletePolygon()
{
m_polygon = nullptr;
}
void Region::FillPolygon(FeatureBuilder const & fb)
{
CHECK(m_polygon, ());
boost_helpers::FillPolygon(*m_polygon, fb);
}
bool Region::IsCountry() const
{
static auto const kAdminLevelCountry = AdminLevel::Two;
return GetPlaceType() == PlaceType::Unknown && GetAdminLevel() == kAdminLevelCountry;
}
bool Region::IsLocality() const
{
return GetPlaceType() != PlaceType::Unknown;
return GetPlaceType() >= PlaceType::City;
}
bool Region::Contains(Region const & smaller) const
@ -156,33 +145,15 @@ bool Region::Contains(BoostPoint const & point) const
boost::geometry::covered_by(point, *m_polygon);
}
bool FeaturePlacePointToRegion(RegionInfo const & regionInfo, FeatureBuilder & feature)
std::string GetRegionNotation(Region const & region)
{
if (!feature.IsPoint())
return false;
auto notation = region.GetEnglishOrTransliteratedName();
if (notation.empty())
return region.GetName();
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::Unknown)
return false;
auto const radius = Region::GetRadiusByPlaceType(placeType);
polygon = MakePolygonWithRadius({center.x, center.y}, radius);
auto const & outer = polygon.outer();
FeatureBuilder::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.SetRank(0);
feature.SetArea();
return true;
if (notation != region.GetName())
notation += " / " + region.GetName();
return notation;
}
} // namespace regions
} // namespace generator

6
generator/regions/region.hpp
View file

@ -27,17 +27,15 @@ public:
// Build a region and its boundary based on the heuristic.
explicit Region(PlacePoint const & place);
// After calling DeletePolygon, you cannot use Contains, ContainsRect, CalculateOverlapPercentage.
void DeletePolygon();
bool Contains(Region const & smaller) const;
bool ContainsRect(Region const & smaller) const;
bool Contains(PlacePoint const & place) const;
bool Contains(BoostPoint const & point) const;
double CalculateOverlapPercentage(Region const & other) const;
BoostPoint GetCenter() const;
bool IsCountry() const;
bool IsLocality() const;
BoostRect const & GetRect() const { return m_rect; }
std::shared_ptr<BoostPolygon> const & GetPolygon() const noexcept { return m_polygon; }
double GetArea() const { return m_area; }
// This function uses heuristics and assigns a radius according to the tag place.
// The radius will be returned in mercator units.
@ -51,6 +49,6 @@ private:
double m_area;
};
bool FeaturePlacePointToRegion(RegionInfo const & regionInfo, feature::FeatureBuilder & feature);
std::string GetRegionNotation(Region const & region);
} // namespace regions
} // namespace generator

164
generator/regions/regions.cpp
View file

@ -23,6 +23,7 @@
#include <algorithm>
#include <fstream>
#include <numeric>
#include <map>
#include <memory>
#include <queue>
#include <set>
@ -53,6 +54,7 @@ public:
, m_pathOutRepackedRegionsTmpMwm{pathOutRepackedRegionsTmpMwm}
, m_verbose{verbose}
, m_regionsInfoCollector{pathInRegionsCollector}
, m_regionsKv{pathOutRegionsKv, std::ofstream::out}
{
LOG(LINFO, ("Start generating regions from", m_pathInRegionsTmpMwm));
auto timer = base::Timer{};
@ -68,38 +70,62 @@ public:
private:
void GenerateRegions(RegionsBuilder & builder)
{
std::ofstream regionsKv{m_pathOutRegionsKv, std::ofstream::out};
std::set<base::GeoObjectId> setIds;
size_t countIds = 0;
builder.ForEachNormalizedCountry([&](std::string const & name, Node::Ptr const & tree) {
if (!tree)
return;
if (m_verbose)
DebugPrintTree(tree);
LOG(LINFO, ("Processing country", name));
auto jsonPolicy = JsonPolicy{m_verbose};
ForEachLevelPath(tree, [&](auto && path) {
auto const & node = path.back();
auto const id = node->GetData().GetId();
regionsKv << static_cast<int64_t>(id.GetEncodedId()) << " " << jsonPolicy.ToString(path) << "\n";
++countIds;
if (!setIds.insert(id).second)
LOG(LWARNING, ("Id alredy exists:", id));
});
builder.ForEachCountry([&](std::string const & name, Node::PtrList const & outers) {
auto const & countryPlace = outers.front()->GetData();
auto const & countryName = countryPlace.GetEnglishOrTransliteratedName();
GenerateKv(countryName, outers);
});
LOG(LINFO, ("Regions objects key-value for", builder.GetCountryNames().size(),
"countries storage saved to", m_pathOutRegionsKv));
LOG(LINFO, (countIds, "total ids.", setIds.size(), "unique ids."));
LOG(LINFO, (m_objectsRegions.size(), "total regions.",
m_regionsCountries.size(), "total objects."));
// 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).
RepackTmpMwm(setIds);
RepackTmpMwm();
}
void GenerateKv(std::string const & countryName, Node::PtrList const & outers)
{
LOG(LINFO, ("Generate country", countryName));
auto country = std::make_shared<std::string>(countryName);
size_t countryRegionsCount = 0;
size_t countryObjectCount = 0;
auto jsonPolicy = std::make_unique<JsonPolicy>(m_verbose);
for (auto const & tree : outers)
{
if (m_verbose)
DebugPrintTree(tree);
ForEachLevelPath(tree, [&] (NodePath const & path) {
auto const & node = path.back();
auto const & region = node->GetData();
auto const & objectId = region.GetId();
auto const & regionCountryEmplace = m_regionsCountries.emplace(objectId, country);
if (!regionCountryEmplace.second && regionCountryEmplace.first->second != country)
{
LOG(LWARNING, ("Failed to place", GetLabel(region.GetLevel()), "region", objectId,
"(", GetRegionNotation(region), ")",
"into", *country,
": region already exists in", *regionCountryEmplace.first->second));
return;
}
m_objectsRegions.emplace(objectId, node);
++countryRegionsCount;
if (regionCountryEmplace.second)
{
m_regionsKv << static_cast<int64_t>(objectId.GetEncodedId()) << " " << jsonPolicy->ToString(path)
<< "\n";
++countryObjectCount;
}
});
}
LOG(LINFO, ("Country regions of", *country, "has built:", countryRegionsCount, "total regions.",
countryObjectCount, "objects."));
}
std::tuple<RegionsBuilder::Regions, PlacePointsMap>
@ -112,12 +138,25 @@ private:
{
auto const id = fb.GetMostGenericOsmId();
auto region = Region(fb, collector.Get(id));
auto const & name = region.GetName();
auto const level = RegionsBuilder::GetLevel(region);
if (name.empty() || level == PlaceLevel::Unknown)
return;
regions.emplace_back(std::move(region));
}
else if (fb.IsPoint())
{
auto const id = fb.GetMostGenericOsmId();
placePointsMap.emplace(id, PlacePoint{fb, collector.Get(id)});
auto place = PlacePoint{fb, collector.Get(id)};
auto const & name = place.GetName();
auto const placeType = place.GetPlaceType();
if (name.empty() || placeType == PlaceType::Unknown)
return;
placePointsMap.emplace(id, std::move(place));
}
};
@ -131,41 +170,61 @@ private:
PlacePointsMap placePointsMap;
std::tie(regions, placePointsMap) = ReadDatasetFromTmpMwm(m_pathInRegionsTmpMwm, m_regionsInfoCollector);
FixRegionsWithPlacePointApproximation(placePointsMap, regions);
FilterRegions(regions);
return regions;
}
void FilterRegions(RegionsBuilder::Regions & regions)
void RepackTmpMwm()
{
auto const pred = [](Region const & region) {
auto const & name = region.GetName();
if (name.empty())
return false;
feature::FeaturesCollector featuresCollector{m_pathOutRepackedRegionsTmpMwm};
std::set<base::GeoObjectId> processedObjects;
auto const toDo = [&](FeatureBuilder & fb, uint64_t /* currPos */) {
auto const id = fb.GetMostGenericOsmId();
auto objectRegions = m_objectsRegions.equal_range(id);
if (objectRegions.first == objectRegions.second)
return;
if (!processedObjects.insert(id).second)
return;
auto const level = RegionsBuilder::GetLevel(region);
return level != PlaceLevel::Unknown;
for (auto item = objectRegions.first; item != objectRegions.second; ++item)
{
auto const & region = item->second->GetData();
ResetGeometry(fb, region);
fb.SetOsmId(region.GetId());
fb.SetRank(0);
featuresCollector.Collect(fb);
}
};
base::EraseIf(regions, pred);
LOG(LINFO, ("Start regions repacking from", m_pathInRegionsTmpMwm));
feature::ForEachFromDatRawFormat(m_pathInRegionsTmpMwm, toDo);
LOG(LINFO, ("Repacked regions temporary mwm saved to", m_pathOutRepackedRegionsTmpMwm));
}
void RepackTmpMwm(std::set<base::GeoObjectId> const & ids)
void ResetGeometry(FeatureBuilder & fb, Region const & region)
{
FeaturesCollector collector(m_pathOutRepackedRegionsTmpMwm);
auto const toDo = [this, &collector, &ids](FeatureBuilder & fb, uint64_t /* currPos */) {
if (ids.count(fb.GetMostGenericOsmId()) == 0 ||
(fb.IsPoint() && !FeaturePlacePointToRegion(m_regionsInfoCollector, fb)))
{
return;
}
fb.ResetGeometry();
CHECK(fb.IsArea(), ());
collector.Collect(fb);
};
auto const & polygon = region.GetPolygon();
auto outer = GetPointSeq(polygon->outer());
fb.AddPolygon(outer);
FeatureBuilder::Geometry holes;
auto const & inners = polygon->inners();
std::transform(std::begin(inners), std::end(inners), std::back_inserter(holes),
[this](auto && polygon) { return this->GetPointSeq(polygon); });
fb.SetHoles(std::move(holes));
fb.SetArea();
ForEachFromDatRawFormat(m_pathInRegionsTmpMwm, toDo);
CHECK(fb.IsArea(), ());
CHECK(fb.IsGeometryClosed(), ());
}
LOG(LINFO, ("Repacked regions temporary mwm saved to", m_pathOutRepackedRegionsTmpMwm));
template <typename Polygon>
FeatureBuilder::PointSeq GetPointSeq(Polygon const & polygon)
{
FeatureBuilder::PointSeq seq;
std::transform(std::begin(polygon), std::end(polygon), std::back_inserter(seq),
[] (BoostPoint const & p) { return m2::PointD(p.get<0>(), p.get<1>()); });
return seq;
}
std::string m_pathInRegionsTmpMwm;
@ -175,6 +234,11 @@ private:
bool m_verbose{false};
RegionInfo m_regionsInfoCollector;
std::ofstream m_regionsKv;
std::multimap<base::GeoObjectId, Node::Ptr> m_objectsRegions;
std::map<base::GeoObjectId, std::shared_ptr<std::string>> m_regionsCountries;
};
} // namespace

109
generator/regions/regions_builder.cpp
View file

@ -18,43 +18,49 @@ 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, size_t threadsCount)
: m_regions(std::move(regions))
, m_threadsCount(threadsCount)
: m_threadsCount(threadsCount)
{
ASSERT(m_threadsCount != 0, ());
auto const isCountry = [](Region const & r) { return r.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);
m_regionsInAreaOrder = FormRegionsInAreaOrder(std::move(regions));
m_countriesOuters = ExtractCountriesOuters(m_regionsInAreaOrder);
}
RegionsBuilder::Regions const & RegionsBuilder::GetCountries() const
RegionsBuilder::Regions RegionsBuilder::FormRegionsInAreaOrder(Regions && regions)
{
return m_countries;
auto const cmp = [](Region const & l, Region const & r) { return l.GetArea() > r.GetArea(); };
std::sort(std::begin(regions), std::end(regions), cmp);
return std::move(regions);
}
RegionsBuilder::Regions RegionsBuilder::ExtractCountriesOuters(Regions & regions)
{
Regions countriesOuters;
auto const isCountry = [](Region const & region) {
return AdminLevel::Two == region.GetAdminLevel();
};
std::copy_if(std::begin(regions), std::end(regions), std::back_inserter(countriesOuters),
isCountry);
base::EraseIf(regions, isCountry);
return countriesOuters;
}
RegionsBuilder::Regions const & RegionsBuilder::GetCountriesOuters() const
{
return m_countriesOuters;
}
RegionsBuilder::StringsList RegionsBuilder::GetCountryNames() const
{
StringsList result;
std::unordered_set<std::string> set;
for (auto const & c : GetCountries())
for (auto const & c : GetCountriesOuters())
{
auto name = c.GetName();
auto const & name = c.GetName();
if (set.insert(name).second)
result.emplace_back(std::move(name));
}
@ -62,13 +68,13 @@ RegionsBuilder::StringsList RegionsBuilder::GetCountryNames() const
return result;
}
Node::PtrList RegionsBuilder::MakeSelectedRegionsByCountry(Region const & country,
Node::PtrList RegionsBuilder::MakeSelectedRegionsByCountry(Region const & outer,
Regions const & allRegions)
{
std::vector<LevelRegion> regionsInCountry{{PlaceLevel::Country, country}};
std::vector<LevelRegion> regionsInCountry{{PlaceLevel::Country, outer}};
for (auto const & region : allRegions)
{
if (country.ContainsRect(region))
if (outer.ContainsRect(region))
regionsInCountry.emplace_back(GetLevel(region), region);
}
@ -87,10 +93,10 @@ Node::PtrList RegionsBuilder::MakeSelectedRegionsByCountry(Region const & countr
return nodes;
}
Node::Ptr RegionsBuilder::BuildCountryRegionTree(Region const & country,
Node::Ptr RegionsBuilder::BuildCountryRegionTree(Region const & outer,
Regions const & allRegions)
{
auto nodes = MakeSelectedRegionsByCountry(country, allRegions);
auto nodes = MakeSelectedRegionsByCountry(outer, allRegions);
while (nodes.size() > 1)
{
auto itFirstNode = std::rbegin(nodes);
@ -106,52 +112,47 @@ Node::Ptr RegionsBuilder::BuildCountryRegionTree(Region const & country,
{
(*itFirstNode)->SetParent(*itCurr);
(*itCurr)->AddChild(*itFirstNode);
// We want to free up memory.
firstRegion.DeletePolygon();
nodes.pop_back();
break;
}
}
if (itCurr == std::rend(nodes))
nodes.pop_back();
nodes.pop_back();
}
return nodes.empty() ? std::shared_ptr<Node>() : ShrinkToFit(nodes.front());
return nodes.front();
}
void RegionsBuilder::ForEachNormalizedCountry(NormalizedCountryFn fn)
void RegionsBuilder::ForEachCountry(CountryFn fn)
{
for (auto const & countryName : GetCountryNames())
{
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);
Regions outers;
auto const & countries = GetCountriesOuters();
auto const pred = [&](Region const & country) { return countryName == country.GetName(); };
std::copy_if(std::begin(countries), std::end(countries), std::back_inserter(outers), pred);
auto countryTrees = BuildCountryRegionTrees(outers);
fn(countryName, countryTrees);
}
}
std::vector<Node::Ptr> RegionsBuilder::BuildCountryRegionTrees(RegionsBuilder::Regions const & countries)
Node::PtrList RegionsBuilder::BuildCountryRegionTrees(Regions const & outers)
{
std::vector<std::future<Node::Ptr>> tmp;
std::vector<std::future<Node::Ptr>> buildingTasks;
{
base::thread_pool::computational::ThreadPool threadPool(m_threadsCount);
for (auto const & country : countries)
for (auto const & outer : outers)
{
auto result = threadPool.Submit(&RegionsBuilder::BuildCountryRegionTree, country, m_regions);
tmp.emplace_back(std::move(result));
auto result = threadPool.Submit(
&RegionsBuilder::BuildCountryRegionTree, std::cref(outer), std::cref(m_regionsInAreaOrder));
buildingTasks.emplace_back(std::move(result));
}
}
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;
std::vector<Node::Ptr> trees;
trees.reserve(buildingTasks.size());
std::transform(std::begin(buildingTasks), std::end(buildingTasks),
std::back_inserter(trees), [](auto & f) { return f.get(); });
return trees;
}
// static

20
generator/regions/regions_builder.hpp
View file

@ -21,27 +21,27 @@ class RegionsBuilder
public:
using Regions = std::vector<Region>;
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 &)>;
using CountryFn = std::function<void(std::string const &, Node::PtrList const &)>;
explicit RegionsBuilder(Regions && regions, size_t threadsCount = 1);
Regions const & GetCountries() const;
Regions const & GetCountriesOuters() const;
StringsList GetCountryNames() const;
void ForEachNormalizedCountry(NormalizedCountryFn fn);
void ForEachCountry(CountryFn fn);
static PlaceLevel GetLevel(Region const & region);
static size_t GetWeight(Region const & region);
private:
static Node::PtrList MakeSelectedRegionsByCountry(Region const & country,
Regions FormRegionsInAreaOrder(Regions && regions);
Regions ExtractCountriesOuters(Regions & regions);
Node::PtrList BuildCountryRegionTrees(Regions const & outers);
static Node::Ptr BuildCountryRegionTree(Region const & outer, Regions const & allRegions);
static Node::PtrList MakeSelectedRegionsByCountry(Region const & outer,
Regions const & allRegions);
static Node::Ptr BuildCountryRegionTree(Region const & country, Regions const & allRegions);
std::vector<Node::Ptr> BuildCountryRegionTrees(RegionsBuilder::Regions const & countries);
Regions m_countries;
Regions m_regions;
Regions m_countriesOuters;
Regions m_regionsInAreaOrder;
size_t m_threadsCount;
};
} // namespace regions