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

Build in m4::Tree to feature polygonizer by countries.

Browse source
This commit is contained in:
vng 2011-01-27 02:00:48 +02:00 • committed by Alex Zolotarev
parent a13b24206a
commit cdc8e9d229
6 changed files with 135 additions and 131 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
indexer/feature.hpp
View file

@ -88,9 +88,14 @@ public:
template <class ToDo>
void ForEachTruePointRef(ToDo & toDo) const
{
for (points_t::const_iterator it = m_Geometry.begin(); it != m_Geometry.end(); ++it)
if (!toDo(*it))
return;
if (m_bPoint)
toDo(m_Center);
else
{
for (points_t::const_iterator it = m_Geometry.begin(); it != m_Geometry.end(); ++it)
if (!toDo(*it))
return;
}
}
m2::PointD CenterPoint() const { return m_Center; }

23
indexer/indexer_tool/feature_bucketer.hpp
View file

@ -23,11 +23,7 @@ class CellFeatureBucketer
{
typedef typename FeatureClipperT::feature_builder_t feature_builder_t;
public:
CellFeatureBucketer(int level, typename FeatureOutT::InitDataType const & featureOutInitData,
int maxWorldZoom = -1, bool worldOnly = false)
: m_Level(level), m_FeatureOutInitData(featureOutInitData), m_maxWorldZoom(maxWorldZoom),
m_worldOnly(worldOnly)
void Init()
{
if (!m_worldOnly)
{
@ -42,10 +38,25 @@ public:
}
}
// create separate world bucket if necessary
if (maxWorldZoom >= 0)
if (m_maxWorldZoom >= 0)
m_worldBucket.reset(new FeatureOutT(WORLD_FILE_NAME, m_FeatureOutInitData));
}
public:
template <class TInfo>
explicit CellFeatureBucketer(TInfo & info)
: m_Level(info.cellBucketingLevel), m_FeatureOutInitData(info.datFilePrefix, info.datFileSuffix),
m_maxWorldZoom(info.m_maxScaleForWorldFeatures), m_worldOnly(info.m_worldOnly)
{
Init();
}
CellFeatureBucketer(int level, typename FeatureOutT::InitDataType const & initData)
: m_Level(level), m_FeatureOutInitData(initData), m_maxWorldZoom(-1), m_worldOnly(false)
{
Init();
}
void operator () (feature_builder_t const & fb)
{
// separately store features needed for world map

12
indexer/indexer_tool/feature_generator.cpp
View file

@ -295,31 +295,25 @@ bool GenerateImpl(GenerateInfo & info)
holder.LoadIndex();
FeaturesCollector::InitDataType collectorInitData(info.datFilePrefix, info.datFileSuffix);
if (info.m_splitByPolygons)
{
typedef Polygonizer<FeaturesCollector, MercatorBounds, RectId> FeaturePolygonizerType;
// prefix is data dir
FeaturePolygonizerType bucketer(info.datFilePrefix, collectorInitData, info.m_simplifyCountriesLevel);
FeaturePolygonizerType bucketer(info);
TParser<FeaturePolygonizerType, holder_t> parser(bucketer, holder);
ParseXMLFromStdIn(parser);
bucketer.GetBucketNames(MakeBackInsertFunctor(info.bucketNames));
}
else
{
CHECK_GREATER_OR_EQUAL(info.cellBucketingLevel, 0, ());
CHECK_LESS(info.cellBucketingLevel, 10, ());
typedef CellFeatureBucketer<FeaturesCollector, SimpleFeatureClipper, MercatorBounds, RectId>
FeatureBucketerType;
FeatureBucketerType bucketer(info.cellBucketingLevel, collectorInitData,
info.m_maxScaleForWorldFeatures, info.m_worldOnly);
typedef CellFeatureBucketer<FeaturesCollector, SimpleFeatureClipper, MercatorBounds, RectId> FeatureBucketerType;
FeatureBucketerType bucketer(info);
TParser<FeatureBucketerType, holder_t> parser(bucketer, holder);
ParseXMLFromStdIn(parser);
bucketer.GetBucketNames(MakeBackInsertFunctor(info.bucketNames));
}
}
catch (Reader::Exception const & e)
{

100
indexer/indexer_tool/kml_parser.cpp
View file

@ -22,6 +22,7 @@
namespace kml
{
typedef vector<Region> PolygonsContainerT;
class KmlParser
{
@ -29,11 +30,11 @@ namespace kml
/// buffer for text with points
string m_data;
CountryPolygons & m_country;
int m_simplifyCountriesLevel;
PolygonsContainerT & m_country;
int m_level;
public:
KmlParser(CountryPolygons & country, int simplifyCountriesLevel);
KmlParser(PolygonsContainerT & country, int level);
bool Push(string const & element);
void Pop(string const & element);
@ -41,8 +42,8 @@ namespace kml
void CharData(string const & data);
};
KmlParser::KmlParser(CountryPolygons & country, int simplifyCountriesLevel)
: m_country(country), m_simplifyCountriesLevel(simplifyCountriesLevel)
KmlParser::KmlParser(PolygonsContainerT & country, int level)
: m_country(country), m_level(level)
{
}
@ -57,11 +58,11 @@ namespace kml
class PointsCollector
{
PointsContainerT & m_container;
m2::RectD & m_rect;
public:
PointsCollector(PointsContainerT & container, m2::RectD & rect)
: m_container(container), m_rect(rect) {}
PointsCollector(PointsContainerT & container) : m_container(container)
{
}
void operator()(string const & latLon)
{
@ -80,7 +81,6 @@ namespace kml
CHECK(utils::to_double(latStr, lat), ("invalid lon", latStr));
// to mercator
m2::PointD const mercPoint(MercatorBounds::LonToX(lon), MercatorBounds::LatToY(lat));
m_rect.Add(mercPoint);
m_container.push_back(mercPoint);
}
};
@ -109,8 +109,7 @@ namespace kml
// first, collect points in Mercator
typedef vector<m2::PointD> MercPointsContainerT;
MercPointsContainerT points;
m2::RectD rect;
PointsCollector<MercPointsContainerT> collector(points, rect);
PointsCollector<MercPointsContainerT> collector(points);
utils::TokenizeString(m_data, " \n\r\a", collector);
size_t const numPoints = points.size();
if (numPoints > 3 && points[numPoints - 1] == points[0])
@ -119,28 +118,28 @@ namespace kml
points.pop_back();
// second, simplify points if necessary
if (m_simplifyCountriesLevel > 0)
if (m_level > 0)
{
MercPointsContainerT simplifiedPoints;
feature::SimplifyPoints(points, simplifiedPoints, m_simplifyCountriesLevel);
feature::SimplifyPoints(points, simplifiedPoints, m_level);
if (simplifiedPoints.size() > MIN_SIMPLIFIED_POINTS_COUNT)
{
LOG_SHORT(LINFO, (m_country.m_name, numPoints, "simplified to ", simplifiedPoints.size()));
//LOG_SHORT(LINFO, (m_country.m_name, numPoints, "simplified to ", simplifiedPoints.size()));
points.swap(simplifiedPoints);
}
}
// third, convert mercator doubles to uint points
Region region;
for (MercPointsContainerT::iterator it = points.begin(); it != points.end(); ++it)
region.AddPoint(MercatorPointToPointU(*it));
m_country.m_regions.push_back(region);
m_country.m_rect.Add(rect);
if (!points.empty())
{
m_country.push_back(Region());
for (MercPointsContainerT::iterator it = points.begin(); it != points.end(); ++it)
m_country.back().AddPoint(MercatorPointToPointU(*it));
}
}
else
{
LOG(LWARNING, ("Invalid region for country", m_country.m_name));
LOG(LWARNING, ("Invalid region for country"/*, m_country.m_name*/));
}
}
else if (m_tags[size - 3] == "innerBoundaryIs")
@ -165,7 +164,9 @@ namespace kml
size_t const size = m_tags.size();
if (size > 1 && m_tags[size - 1] == "name" && m_tags[size - 2] == "Placemark")
m_country.m_name = data;
{
//m_country.m_name = data;
}
else if (size > 4 && m_tags[size - 1] == "coordinates"
&& m_tags[size - 2] == "LinearRing" && m_tags[size - 4] == "Polygon")
{
@ -174,10 +175,9 @@ namespace kml
}
}
bool LoadPolygonsFromKml(string const & kmlFile, CountryPolygons & country,
int simplifyCountriesLevel)
bool LoadPolygonsFromKml(string const & kmlFile, PolygonsContainerT & country, int level)
{
KmlParser parser(country, simplifyCountriesLevel);
KmlParser parser(country, level);
try
{
FileReader file(kmlFile);
@ -193,25 +193,31 @@ namespace kml
class PolygonLoader
{
string m_baseDir;
CountryPolygons & m_out;
int m_simplifyCountriesLevel;
int m_level;
CountryPolygons & m_polygons;
m2::RectD & m_rect;
public:
PolygonLoader(string const & basePolygonsDir, CountryPolygons & polygons,
int simplifyCountriesLevel)
: m_baseDir(basePolygonsDir), m_out(polygons),
m_simplifyCountriesLevel(simplifyCountriesLevel) {}
PolygonLoader(string const & basePolygonsDir, int level, CountryPolygons & polygons, m2::RectD & rect)
: m_baseDir(basePolygonsDir), m_level(level), m_polygons(polygons), m_rect(rect)
{
}
void operator()(string const & name)
{
if (m_out.m_name.empty())
m_out.m_name = name;
CountryPolygons current;
if (LoadPolygonsFromKml(m_baseDir + BORDERS_DIR + name + BORDERS_EXTENSION, current, m_simplifyCountriesLevel)
&& current.m_regions.size())
if (m_polygons.m_name.empty())
m_polygons.m_name = name;
PolygonsContainerT current;
if (LoadPolygonsFromKml(m_baseDir + BORDERS_DIR + name + BORDERS_EXTENSION, current, m_level))
{
m_out.m_regions.insert(m_out.m_regions.end(),
current.m_regions.begin(), current.m_regions.end());
m_out.m_rect.Add(current.m_rect);
for (size_t i = 0; i < current.size(); ++i)
{
m2::RectD const rect(current[i].GetRect());
m_rect.Add(rect);
m_polygons.m_regions.Add(current[i], rect);
}
}
}
};
@ -224,21 +230,25 @@ namespace kml
LOG_SHORT(LINFO, ("Simplificator level for country polygons:", simplifyCountriesLevel));
}
countries.clear();
countries.Clear();
ifstream stream((baseDir + POLYGONS_FILE).c_str());
std::string line;
string line;
while (stream.good())
{
std::getline(stream, line);
if (line.empty())
continue;
CountryPolygons country;
PolygonLoader loader(baseDir, country, simplifyCountriesLevel);
m2::RectD rect;
PolygonLoader loader(baseDir, simplifyCountriesLevel, country, rect);
utils::TokenizeString(line, "|", loader);
if (!country.m_regions.empty())
countries.push_back(country);
if (!country.m_regions.IsEmpty())
countries.Add(country, rect);
}
return !countries.empty();
return !countries.IsEmpty();
}
}

13
indexer/indexer_tool/kml_parser.hpp
View file

@ -1,25 +1,26 @@
#pragma once
#include "../../geometry/region2d.hpp"
#include "../../geometry/tree4d.hpp"
#include "../../std/string.hpp"
#include "../../std/vector.hpp"
namespace kml
{
typedef m2::RegionU Region;
typedef std::vector<Region> RegionsContainerT;
typedef m4::Tree<Region> RegionsContainerT;
struct CountryPolygons
{
CountryPolygons(string const & name = "") : m_name(name) {}
CountryPolygons(string const & name = "") : m_name(name), m_index(-1) {}
RegionsContainerT m_regions;
string m_name;
/// limit rect for all country polygons
m2::RectD m_rect;
mutable int m_index;
};
typedef vector<CountryPolygons> CountriesContainerT;
typedef m4::Tree<CountryPolygons> CountriesContainerT;
/// @param[in] simplifyCountriesLevel if positive, used as a level for simplificator
bool LoadCountriesList(string const & baseDir, CountriesContainerT & countries,

107
indexer/indexer_tool/polygonizer.hpp
View file

@ -23,18 +23,22 @@ namespace feature
class Polygonizer
{
public:
Polygonizer(string const & dir, typename FeatureOutT::InitDataType const & featureOutInitData,
int simplifyCountriesLevel)
: m_FeatureOutInitData(featureOutInitData)
template <class TInfo>
Polygonizer(TInfo & info)
: m_FeatureOutInitData(info.datFilePrefix, info.datFileSuffix), m_Names(info.bucketNames)
{
CHECK(kml::LoadCountriesList(dir, m_countries, simplifyCountriesLevel), ("Error loading polygons"));
LOG_SHORT(LINFO, ("Loaded polygons count for regions:"));
for (size_t i = 0; i < m_countries.size(); ++i)
{
LOG_SHORT(LINFO, (m_countries[i].m_name, m_countries[i].m_regions.size()));
}
CHECK(kml::LoadCountriesList(info.datFilePrefix, m_countries, info.m_simplifyCountriesLevel),
("Error loading polygons"));
m_Buckets.resize(m_countries.size());
//LOG_SHORT(LINFO, ("Loaded polygons count for regions:"));
//for (size_t i = 0; i < m_countries.size(); ++i)
//{
// LOG_SHORT(LINFO, (m_countries[i].m_name, m_countries[i].m_regions.size()));
//}
}
~Polygonizer()
{
for_each(m_Buckets.begin(), m_Buckets.end(), DeleteFunctor());
}
struct PointChecker
@ -49,71 +53,50 @@ namespace feature
bool operator()(m2::PointD const & pt)
{
for (size_t i = 0; i < m_regions.size(); ++i)
{
kml::Region::value_type const point(static_cast<uint32_t>(CellIdConverterType::XToCellIdX(pt.x)),
static_cast<uint32_t>(CellIdConverterType::YToCellIdY(pt.y)));
if (m_regions[i].Contains(point))
{
m_belongs = true;
// stop points processing
return false;
}
}
// continue with next point
return true;
kml::Region::value_type const point(
static_cast<uint32_t>(CellIdConverterType::XToCellIdX(pt.x)),
static_cast<uint32_t>(CellIdConverterType::YToCellIdY(pt.y)));
m_regions.ForEachInRect(m2::RectD(point, point), bind<void>(ref(*this), _1, cref(point)));
return m_belongs;
}
void operator() (kml::Region const & rgn, kml::Region::value_type const & point)
{
m_belongs = rgn.Contains(point);
}
};
void operator () (FeatureBuilder1 const & fb)
{
m2::RectD const limitRect = fb.GetLimitRect();
for (uint32_t i = 0; i < m_Buckets.size(); ++i)
m_countries.ForEachInRect(fb.GetLimitRect(), bind<void>(ref(*this), _1, cref(fb)));
}
void operator() (kml::CountryPolygons const & country, FeatureBuilder1 const & fb)
{
PointChecker doCheck(country.m_regions);
fb.ForEachTruePointRef(doCheck);
if (doCheck.m_belongs)
{
// First quick and dirty limit rect intersection.
if (m_countries[i].m_rect.IsIntersect(limitRect))
if (country.m_index == -1)
{
PointChecker isPointContained(m_countries[i].m_regions);
// feature can be without geometry but with only center point
if (fb.GetPointsCount())
fb.ForEachTruePointRef(isPointContained);
else
isPointContained.operator ()(fb.CenterPoint());
if (isPointContained.m_belongs)
{
if (!m_Buckets[i].m_pOut)
m_Buckets[i].m_pOut = new FeatureOutT(BucketName(i), m_FeatureOutInitData);
(*(m_Buckets[i].m_pOut))(fb);
}
m_Names.push_back(country.m_name);
m_Buckets.push_back(new FeatureOutT(country.m_name, m_FeatureOutInitData));
country.m_index = m_Buckets.size()-1;
}
(*(m_Buckets[country.m_index]))(fb);
}
}
template <typename F> void GetBucketNames(F f) const
{
for (uint32_t i = 0; i < m_Buckets.size(); ++i)
if (m_Buckets[i].m_pOut)
f(BucketName(i));
}
private:
inline string BucketName(uint32_t i) const
{
return m_countries[i].m_name;
}
struct Bucket
{
Bucket() : m_pOut(NULL) {}
~Bucket() { delete m_pOut; }
FeatureOutT * m_pOut;
};
typename FeatureOutT::InitDataType m_FeatureOutInitData;
vector<Bucket> m_Buckets;
vector<FeatureOutT*> m_Buckets;
vector<string> m_Names;
kml::CountriesContainerT m_countries;
};
}