organicmaps/geocore
13
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity Actions

[generator] Update for review

Browse source
This commit is contained in:
Anatoly Serdtcev 2019-11-01 15:57:09 +03:00 • committed by Sergey Yershov
parent 3fafbb3633
commit 84a6da2745
5 changed files with 57 additions and 93 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
generator/generator_tests/streets_index_tests.cpp
View file

@ -28,9 +28,8 @@ GeoObjectsIndex<IndexReader> GenerateStreetsIndex(std::vector<OsmElementData> co
auto const locDataFile = GetFileName("streets"s + LOC_DATA_FILE_EXTENSION);
bool locDataGeneration =
feature::GenerateGeoObjectsAndStreetsData(geoObjectsFeatures.GetFullPath(),
streetsFeatures.GetFullPath(),
boost::none /* nodesFile */, locDataFile);
feature::GenerateGeoObjectsData(locDataFile, geoObjectsFeatures.GetFullPath(),
boost::none /* nodesFile */, streetsFeatures.GetFullPath());
CHECK(locDataGeneration, ());
ScopedFile const streetsIndex{"streets"s + LOC_IDX_FILE_EXTENSION, ScopedFile::Mode::DoNotCreate};

23
generator/generator_tool/generator_tool.cpp
View file

@ -311,21 +311,12 @@ int GeneratorToolMain(int argc, char ** argv)
auto const locDataFile =
base::FilenameWithoutExt(options.m_geo_objects_index) + LOC_DATA_FILE_EXTENSION;
auto nodesListPath =
auto const nodesListPath =
boost::make_optional(!options.m_nodes_list_path.empty(), options.m_nodes_list_path);
bool dataGenerated = false;
if (!options.m_streets_features.empty())
{
dataGenerated = feature::GenerateGeoObjectsAndStreetsData(options.m_geo_objects_features,
options.m_streets_features,
nodesListPath, locDataFile);
}
else
{
dataGenerated = feature::GenerateGeoObjectsData(options.m_geo_objects_features,
nodesListPath, locDataFile);
}
if (!dataGenerated)
auto const streetsFeaturesPath =
boost::make_optional(!options.m_streets_features.empty(), options.m_streets_features);
if (!feature::GenerateGeoObjectsData(locDataFile, options.m_geo_objects_features,
nodesListPath, streetsFeaturesPath))
{
LOG(LCRITICAL, ("Error generating geo objects data."));
return EXIT_FAILURE;
@ -353,7 +344,7 @@ int GeneratorToolMain(int argc, char ** argv)
auto const locDataFile =
base::FilenameWithoutExt(options.m_regions_index) + LOC_DATA_FILE_EXTENSION;
if (!feature::GenerateRegionsData(options.m_regions_features, locDataFile))
if (!feature::GenerateRegionsData(locDataFile, options.m_regions_features))
{
LOG(LCRITICAL, ("Error generating regions data."));
return EXIT_FAILURE;
@ -368,7 +359,7 @@ int GeneratorToolMain(int argc, char ** argv)
LOG(LCRITICAL, ("Error generating regions index."));
return EXIT_FAILURE;
}
if (!feature::GenerateBorders(options.m_regions_features, options.m_regions_index))
if (!feature::GenerateBorders(options.m_regions_index, options.m_regions_features))
{
LOG(LCRITICAL, ("Error generating regions borders."));
return EXIT_FAILURE;

2
generator/geo_objects/geo_objects.cpp
View file

@ -212,7 +212,7 @@ boost::optional<indexer::GeoObjectsIndex<IndexReader>> MakeTempGeoObjectsIndex(
{
auto const dataFile = GetPlatform().TmpPathForFile();
SCOPE_GUARD(removeDataFile, std::bind(Platform::RemoveFileIfExists, std::cref(dataFile)));
if (!GenerateGeoObjectsData(pathToGeoObjectsTmpMwm, boost::none /* nodesFile */, dataFile))
if (!GenerateGeoObjectsData(dataFile, pathToGeoObjectsTmpMwm))
{
LOG(LCRITICAL, ("Error generating geo objects data."));
return {};

98
generator/locality_sorter.cpp
View file

@ -196,7 +196,7 @@ using NeedSerialize = function<bool(FeatureBuilder & fb1)>;
bool GenerateLocalityDataImpl(FeaturesCollector & collector,
CalculateMidPoints::MinDrawableScalePolicy const & minDrawableScalePolicy,
NeedSerialize const & needSerialize,
string const & featuresFile, string const & /*dataFile*/)
string const & featuresFile)
{
// Transform features from raw format to LocalityObject format.
try
@ -236,97 +236,81 @@ bool GenerateLocalityDataImpl(FeaturesCollector & collector,
namespace feature
{
bool GenerateGeoObjectsData(string const & featuresFile,
NeedSerialize const & needSerialize,
string const & dataFile)
bool GenerateGeoObjectsData(string const & toDataFile, string const & featuresFile,
NeedSerialize const & needSerialize)
{
DataHeader header;
header.SetGeometryCodingParams(serial::GeometryCodingParams());
header.SetScales({scales::GetUpperScale()});
LocalityCollector localityCollector(dataFile, header,
LocalityCollector localityCollector(toDataFile, header,
static_cast<uint32_t>(base::SecondsSinceEpoch()));
return GenerateLocalityDataImpl(
localityCollector,
static_cast<int (*)(TypesHolder const & types, m2::RectD limitRect)>(GetMinDrawableScale),
needSerialize, featuresFile, dataFile);
needSerialize, featuresFile);
}
bool IsGeoObjectAccepted(FeatureBuilder & fb, bool allowStreet, set<uint64_t> const & includedPois)
bool GenerateGeoObjectsData(string const & toDataFile,
string const & geoObjectsFeaturesFile,
boost::optional<string> const & nodesFile,
boost::optional<string> const & streetsFeaturesFile)
{
using generator::geo_objects::GeoObjectsFilter;
using generator::streets::StreetsFilter;
set<uint64_t> nodeIds;
if (nodesFile && !ParseNodes(*nodesFile, nodeIds))
return false;
if (GeoObjectsFilter::IsBuilding(fb) || GeoObjectsFilter::HasHouse(fb))
return true;
bool const allowStreet = bool{streetsFeaturesFile};
bool const allowPoi = !nodeIds.empty();
auto const needSerialize = [&nodeIds, allowStreet, allowPoi](FeatureBuilder & fb) {
using generator::geo_objects::GeoObjectsFilter;
using generator::streets::StreetsFilter;
if (allowStreet && StreetsFilter::IsStreet(fb))
return true;
if (GeoObjectsFilter::IsBuilding(fb) || GeoObjectsFilter::HasHouse(fb))
return true;
if (GeoObjectsFilter::IsPoi(fb))
return 0 != includedPois.count(fb.GetMostGenericOsmId().GetEncodedId());
if (allowStreet && StreetsFilter::IsStreet(fb))
return true;
return false;
}
if (allowPoi && GeoObjectsFilter::IsPoi(fb))
return 0 != nodeIds.count(fb.GetMostGenericOsmId().GetEncodedId());
bool GenerateGeoObjectsAndStreetsData(string const & geoObjectsFeaturesFile,
string const & streetFeaturesFile,
boost::optional<string> const & nodesFile,
string const & dataFile)
{
auto featuresDirectory = base::GetDirectory(geoObjectsFeaturesFile);
auto featuresFile =
base::JoinPath(featuresDirectory,
std::string{"geo_objects_and_streets"} + DATA_FILE_EXTENSION_TMP);
return false;
};
if (!streetsFeaturesFile)
return GenerateGeoObjectsData(toDataFile, geoObjectsFeaturesFile, needSerialize);
auto const featuresDirectory = base::GetDirectory(geoObjectsFeaturesFile);
auto const featuresFile = base::JoinPath(
featuresDirectory, std::string{"geo_objects_and_streets"} + DATA_FILE_EXTENSION_TMP);
SCOPE_GUARD(featuresFileGuard, std::bind(Platform::RemoveFileIfExists, featuresFile));
base::AppendFileToFile(geoObjectsFeaturesFile, featuresFile);
base::AppendFileToFile(streetFeaturesFile, featuresFile);
base::AppendFileToFile(*streetsFeaturesFile, featuresFile);
set<uint64_t> nodeIds;
if (nodesFile && !ParseNodes(*nodesFile, nodeIds))
return false;
auto const needSerialize = [&nodeIds](FeatureBuilder & fb) {
return IsGeoObjectAccepted(fb, true /* allowStreet */, nodeIds);
};
return GenerateGeoObjectsData(featuresFile, needSerialize, dataFile);
return GenerateGeoObjectsData(toDataFile, featuresFile, needSerialize);
}
bool GenerateGeoObjectsData(string const & geoObjectsFeaturesFile,
boost::optional<string> const & nodesFile,
string const & dataFile)
{
set<uint64_t> nodeIds;
if (nodesFile && !ParseNodes(*nodesFile, nodeIds))
return false;
auto const needSerialize = [&nodeIds](FeatureBuilder & fb) {
return IsGeoObjectAccepted(fb, false /* allowStreet */, nodeIds);
};
return GenerateGeoObjectsData(geoObjectsFeaturesFile, needSerialize, dataFile);
}
bool GenerateRegionsData(string const & featuresFile, string const & dataFile)
bool GenerateRegionsData(std::string const & toDataFile, string const & featuresFile)
{
DataHeader header;
header.SetGeometryCodingParams(serial::GeometryCodingParams());
header.SetScales({scales::GetUpperScale()});
LocalityCollector regionsCollector(dataFile, header,
LocalityCollector regionsCollector(toDataFile, header,
static_cast<uint32_t>(base::SecondsSinceEpoch()));
auto const needSerialize = [](FeatureBuilder const & fb) { return fb.IsArea(); };
return GenerateLocalityDataImpl(regionsCollector, GetMinDrawableScaleGeometryOnly,
needSerialize, featuresFile, dataFile);
needSerialize, featuresFile);
}
bool GenerateBorders(string const & featuresFile, string const & dataFile)
bool GenerateBorders(std::string const & toDataFile, string const & featuresFile)
{
BordersCollector bordersCollector(dataFile);
BordersCollector bordersCollector(toDataFile);
auto const needSerialize = [](FeatureBuilder const & fb) { return fb.IsArea(); };
return GenerateLocalityDataImpl(bordersCollector, GetMinDrawableScaleGeometryOnly,
needSerialize, featuresFile, dataFile);
needSerialize, featuresFile);
}
} // namespace feature

22
generator/locality_sorter.hpp
View file

@ -7,24 +7,14 @@
namespace feature
{
// Generates data for GeoObjectsIndexBuilder from input feature-dat-files.
// @param featuresDir - path to folder with pregenerated features data;
// @param nodesFile - path to file with list of node ids we need to add to output;
// @param out - output file name;
bool GenerateGeoObjectsData(std::string const & geoObjectsFeaturesFile,
boost::optional<std::string> const & nodesFile,
std::string const & out);
bool GenerateGeoObjectsAndStreetsData(std::string const & geoObjectsFeaturesFile,
std::string const & streetFeaturesFile,
boost::optional<std::string> const & nodesFile,
std::string const & out);
bool GenerateGeoObjectsData(std::string const & toDataFile,
std::string const & geoObjectsFeaturesFile,
boost::optional<std::string> const & nodesFile = {},
boost::optional<std::string> const & streetsFeaturesFile = {});
// Generates data for RegionsIndexBuilder from input feature-dat-files.
// @param featuresDir - path to folder with pregenerated features data;
// @param out - output file name;
bool GenerateRegionsData(std::string const & featuresFile, std::string const & out);
bool GenerateRegionsData(std::string const & toDataFile, std::string const & featuresFile);
// Generates borders section for server-side reverse geocoder from input feature-dat-files.
// @param featuresDir - path to folder with pregenerated features data;
// @param out - output file to add borders section;
bool GenerateBorders(std::string const & featuresDir, std::string const & out);
bool GenerateBorders(std::string const & toDataFile, std::string const & featuresDir);
} // namespace feature