forked from organicmaps/organicmaps
Add data generation for LocalityIndexBuilder
This commit is contained in:
tatiana-kondakova
Ilya Zverev
parent
85c35c8cb5
commit
a3b711966b
18 changed files with 772 additions and 384 deletions
|
|
@ -11,6 +11,8 @@
|
|||
#define EXTENSION_TMP ".tmp"
|
||||
#define ADDR_FILE_EXTENSION ".addr"
|
||||
#define RAW_GEOM_FILE_EXTENSION ".rawgeom"
|
||||
#define LOC_IDX_FILE_EXTENSION ".locidx"
|
||||
#define LOC_DATA_FILE_EXTENSION ".locdata"
|
||||
|
||||
#define NODES_FILE "nodes.dat"
|
||||
#define WAYS_FILE "ways.dat"
|
||||
|
|
|
|||
|
|
@ -30,14 +30,19 @@ set(SRC
|
|||
feature_emitter_iface.hpp
|
||||
feature_generator.cpp
|
||||
feature_generator.hpp
|
||||
feature_helpers.cpp
|
||||
feature_helpers.hpp
|
||||
feature_merger.cpp
|
||||
feature_merger.hpp
|
||||
feature_sorter.cpp
|
||||
feature_sorter.hpp
|
||||
gen_mwm_info.hpp
|
||||
generate_info.hpp
|
||||
geometry_holder.hpp
|
||||
intermediate_data.hpp
|
||||
intermediate_elements.hpp
|
||||
locality_sorter.cpp
|
||||
locality_sorter.hpp
|
||||
metalines_builder.cpp
|
||||
metalines_builder.hpp
|
||||
node_mixer.hpp
|
||||
|
|
|
|||
|
|
@ -6,10 +6,10 @@
|
|||
#include "routing_common/car_model.hpp"
|
||||
#include "routing_common/pedestrian_model.hpp"
|
||||
|
||||
#include "indexer/coding_params.hpp"
|
||||
#include "indexer/feature_impl.hpp"
|
||||
#include "indexer/feature_visibility.hpp"
|
||||
#include "indexer/geometry_serialization.hpp"
|
||||
#include "indexer/coding_params.hpp"
|
||||
|
||||
#include "geometry/region2d.hpp"
|
||||
|
||||
|
|
@ -21,8 +21,10 @@
|
|||
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
#include <vector>
|
||||
|
||||
using namespace feature;
|
||||
using namespace std;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// FeatureBuilder1 implementation
|
||||
|
|
@ -79,14 +81,14 @@ void FeatureBuilder1::SetRank(uint8_t rank)
|
|||
m_params.rank = rank;
|
||||
}
|
||||
|
||||
void FeatureBuilder1::AddHouseNumber(std::string const & houseNumber)
|
||||
void FeatureBuilder1::AddHouseNumber(string const & houseNumber)
|
||||
{
|
||||
m_params.AddHouseNumber(houseNumber);
|
||||
}
|
||||
|
||||
void FeatureBuilder1::AddStreet(std::string const & streetName) { m_params.AddStreet(streetName); }
|
||||
void FeatureBuilder1::AddStreet(string const & streetName) { m_params.AddStreet(streetName); }
|
||||
|
||||
void FeatureBuilder1::AddPostcode(std::string const & postcode)
|
||||
void FeatureBuilder1::AddPostcode(string const & postcode)
|
||||
{
|
||||
m_params.GetMetadata().Set(Metadata::FMD_POSTCODE, postcode);
|
||||
}
|
||||
|
|
@ -106,7 +108,7 @@ void FeatureBuilder1::SetLinear(bool reverseGeometry)
|
|||
{
|
||||
auto & cont = m_polygons.front();
|
||||
ASSERT(!cont.empty(), ());
|
||||
std::reverse(cont.begin(), cont.end());
|
||||
reverse(cont.begin(), cont.end());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -169,7 +171,7 @@ bool FeatureBuilder1::RemoveInvalidTypes()
|
|||
m_params.IsEmptyNames());
|
||||
}
|
||||
|
||||
bool FeatureBuilder1::FormatFullAddress(std::string & res) const
|
||||
bool FeatureBuilder1::FormatFullAddress(string & res) const
|
||||
{
|
||||
return m_params.FormatFullAddress(m_limitRect.Center(), res);
|
||||
}
|
||||
|
|
@ -491,7 +493,7 @@ bool FeatureBuilder1::HasOsmId(osm::Id const & id) const
|
|||
return false;
|
||||
}
|
||||
|
||||
std::string FeatureBuilder1::GetOsmIdsString() const
|
||||
string FeatureBuilder1::GetOsmIdsString() const
|
||||
{
|
||||
if (m_osmIds.empty())
|
||||
return "(NOT AN OSM FEATURE)";
|
||||
|
|
@ -510,14 +512,14 @@ int FeatureBuilder1::GetMinFeatureDrawScale() const
|
|||
return (minScale == -1 ? 1000 : minScale);
|
||||
}
|
||||
|
||||
bool FeatureBuilder1::AddName(std::string const & lang, std::string const & name)
|
||||
bool FeatureBuilder1::AddName(string const & lang, string const & name)
|
||||
{
|
||||
return m_params.AddName(lang, name);
|
||||
}
|
||||
|
||||
std::string FeatureBuilder1::GetName(int8_t lang) const
|
||||
string FeatureBuilder1::GetName(int8_t lang) const
|
||||
{
|
||||
std::string s;
|
||||
string s;
|
||||
VERIFY(m_params.name.GetString(lang, s) != s.empty(), ());
|
||||
return s;
|
||||
}
|
||||
|
|
@ -530,7 +532,7 @@ size_t FeatureBuilder1::GetPointsCount() const
|
|||
return counter;
|
||||
}
|
||||
|
||||
std::string DebugPrint(FeatureBuilder1 const & f)
|
||||
string DebugPrint(FeatureBuilder1 const & f)
|
||||
{
|
||||
ostringstream out;
|
||||
|
||||
|
|
@ -569,7 +571,7 @@ uint64_t FeatureBuilder1::GetWayIDForRouting() const
|
|||
return 0;
|
||||
}
|
||||
|
||||
std::string DebugPrint(FeatureBuilder2 const & f)
|
||||
string DebugPrint(FeatureBuilder2 const & f)
|
||||
{
|
||||
return DebugPrint(static_cast<FeatureBuilder1 const &>(f));
|
||||
}
|
||||
|
|
@ -593,6 +595,39 @@ bool FeatureBuilder2::PreSerialize(SupportingData const & data)
|
|||
return TBase::PreSerialize();
|
||||
}
|
||||
|
||||
bool FeatureBuilder2::IsLocalityObject()
|
||||
{
|
||||
return (m_params.GetGeomType() == GEOM_POINT || m_params.GetGeomType() == GEOM_AREA) &&
|
||||
!m_params.house.IsEmpty();
|
||||
}
|
||||
|
||||
void FeatureBuilder2::SerializeLocalityObject(serial::CodingParams const & params,
|
||||
SupportingData & data)
|
||||
{
|
||||
data.m_buffer.clear();
|
||||
|
||||
PushBackByteSink<TBuffer> sink(data.m_buffer);
|
||||
WriteToSink(sink, GetMostGenericOsmId().EncodedId());
|
||||
|
||||
auto const type = m_params.GetGeomType();
|
||||
WriteToSink(sink, static_cast<uint8_t>(type));
|
||||
|
||||
if (type == GEOM_POINT)
|
||||
{
|
||||
serial::SavePoint(sink, m_center, params);
|
||||
return;
|
||||
}
|
||||
|
||||
CHECK_EQUAL(type, GEOM_AREA, ("Supported types are GEOM_POINT and GEOM_AREA"));
|
||||
|
||||
uint32_t trgCount = base::asserted_cast<uint32_t>(data.m_innerTrg.size());
|
||||
CHECK_GREATER(trgCount, 2, ());
|
||||
trgCount -= 2;
|
||||
|
||||
WriteToSink(sink, trgCount);
|
||||
serial::SaveInnerTriangles(data.m_innerTrg, params, sink);
|
||||
}
|
||||
|
||||
void FeatureBuilder2::Serialize(SupportingData & data, serial::CodingParams const & params)
|
||||
{
|
||||
data.m_buffer.clear();
|
||||
|
|
@ -602,8 +637,8 @@ void FeatureBuilder2::Serialize(SupportingData & data, serial::CodingParams cons
|
|||
|
||||
PushBackByteSink<TBuffer> sink(data.m_buffer);
|
||||
|
||||
uint8_t const ptsCount = static_cast<uint8_t>(data.m_innerPts.size());
|
||||
uint8_t trgCount = static_cast<uint8_t>(data.m_innerTrg.size());
|
||||
uint8_t const ptsCount = base::asserted_cast<uint8_t>(data.m_innerPts.size());
|
||||
uint8_t trgCount = base::asserted_cast<uint8_t>(data.m_innerTrg.size());
|
||||
if (trgCount > 0)
|
||||
{
|
||||
ASSERT_GREATER ( trgCount, 2, () );
|
||||
|
|
@ -654,7 +689,7 @@ void FeatureBuilder2::Serialize(SupportingData & data, serial::CodingParams cons
|
|||
serial::SavePoint(sink, GetOuterGeometry()[0], params);
|
||||
|
||||
// offsets was pushed from high scale index to low
|
||||
std::reverse(data.m_ptsOffset.begin(), data.m_ptsOffset.end());
|
||||
reverse(data.m_ptsOffset.begin(), data.m_ptsOffset.end());
|
||||
serial::WriteVarUintArray(data.m_ptsOffset, sink);
|
||||
}
|
||||
}
|
||||
|
|
@ -665,7 +700,7 @@ void FeatureBuilder2::Serialize(SupportingData & data, serial::CodingParams cons
|
|||
else
|
||||
{
|
||||
// offsets was pushed from high scale index to low
|
||||
std::reverse(data.m_trgOffset.begin(), data.m_trgOffset.end());
|
||||
reverse(data.m_trgOffset.begin(), data.m_trgOffset.end());
|
||||
serial::WriteVarUintArray(data.m_trgOffset, sink);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@
|
|||
|
||||
#include <functional>
|
||||
#include <list>
|
||||
|
||||
#include <string>
|
||||
|
||||
namespace serial { class CodingParams; }
|
||||
|
||||
|
|
@ -254,6 +254,8 @@ public:
|
|||
/// @name Overwrite from base_type.
|
||||
//@{
|
||||
bool PreSerialize(SupportingData const & data);
|
||||
bool IsLocalityObject();
|
||||
void SerializeLocalityObject(serial::CodingParams const & params, SupportingData & data);
|
||||
void Serialize(SupportingData & data, serial::CodingParams const & params);
|
||||
//@}
|
||||
|
||||
|
|
|
|||
|
|
@ -37,6 +37,7 @@ FeaturesCollector::~FeaturesCollector()
|
|||
(void)GetFileSize(m_datFile);
|
||||
}
|
||||
|
||||
// static
|
||||
uint32_t FeaturesCollector::GetFileSize(FileWriter const & f)
|
||||
{
|
||||
// .dat file should be less than 4Gb
|
||||
|
|
|
|||
|
|
@ -30,7 +30,6 @@ private:
|
|||
void FlushBuffer();
|
||||
|
||||
protected:
|
||||
static uint32_t GetFileSize(FileWriter const & f);
|
||||
|
||||
/// @return feature offset in the file, which is used as an ID later
|
||||
uint32_t WriteFeatureBase(std::vector<char> const & bytes, FeatureBuilder1 const & fb);
|
||||
|
|
@ -41,6 +40,7 @@ public:
|
|||
FeaturesCollector(std::string const & fName);
|
||||
virtual ~FeaturesCollector();
|
||||
|
||||
static uint32_t GetFileSize(FileWriter const & f);
|
||||
std::string const & GetFilePath() const { return m_datFile.GetName(); }
|
||||
/// \brief Serializes |f|.
|
||||
/// \returns feature id of serialized feature if |f| is serialized after the call
|
||||
|
|
|
|||
58
generator/feature_helpers.cpp
Normal file
58
generator/feature_helpers.cpp
Normal file
|
|
@ -0,0 +1,58 @@
|
|||
#include "generator/feature_helpers.hpp"
|
||||
|
||||
#include "generator/feature_builder.hpp"
|
||||
|
||||
#include "indexer/feature_visibility.hpp"
|
||||
|
||||
#include "base/stl_helpers.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
using namespace std;
|
||||
|
||||
namespace feature
|
||||
{
|
||||
void CalculateMidPoints::operator()(FeatureBuilder1 const & ft, uint64_t pos)
|
||||
{
|
||||
// Reset state.
|
||||
m_midLoc = m2::PointD::Zero();;
|
||||
m_locCount = 0;
|
||||
|
||||
ft.ForEachGeometryPoint(*this);
|
||||
ASSERT_NOT_EQUAL(m_locCount, 0, ());
|
||||
m_midLoc = m_midLoc / m_locCount;
|
||||
|
||||
uint64_t const pointAsInt64 = PointToInt64(m_midLoc, m_coordBits);
|
||||
int const minScale = feature::GetMinDrawableScale(ft.GetFeatureBase());
|
||||
|
||||
/// May be invisible if it's small area object with [0-9] scales.
|
||||
/// @todo Probably, we need to keep that objects if 9 scale (as we do in 17 scale).
|
||||
if (minScale != -1 || feature::RequireGeometryInIndex(ft.GetFeatureBase()))
|
||||
{
|
||||
uint64_t const order = (static_cast<uint64_t>(minScale) << 59) | (pointAsInt64 >> 5);
|
||||
m_vec.push_back(make_pair(order, pos));
|
||||
}
|
||||
}
|
||||
|
||||
bool CalculateMidPoints::operator()(m2::PointD const & p)
|
||||
{
|
||||
m_midLoc += p;
|
||||
m_midAll += p;
|
||||
++m_locCount;
|
||||
++m_allCount;
|
||||
return true;
|
||||
}
|
||||
|
||||
m2::PointD CalculateMidPoints::GetCenter() const
|
||||
{
|
||||
if (m_allCount == 0)
|
||||
return {};
|
||||
|
||||
return m_midAll / m_allCount;
|
||||
}
|
||||
|
||||
void CalculateMidPoints::Sort()
|
||||
{
|
||||
sort(m_vec.begin(), m_vec.end(), my::LessBy(&CellAndOffset::first));
|
||||
}
|
||||
} // namespace feature
|
||||
101
generator/feature_helpers.hpp
Normal file
101
generator/feature_helpers.hpp
Normal file
|
|
@ -0,0 +1,101 @@
|
|||
#pragma once
|
||||
|
||||
#include "geometry/distance.hpp"
|
||||
#include "geometry/point2d.hpp"
|
||||
#include "geometry/simplification.hpp"
|
||||
|
||||
#include "indexer/coding_params.hpp"
|
||||
#include "indexer/scales.hpp"
|
||||
|
||||
#include "base/assert.hpp"
|
||||
#include "base/math.hpp"
|
||||
|
||||
#include <cstdint>
|
||||
#include <limits>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
class FeatureBuilder1;
|
||||
|
||||
namespace feature
|
||||
{
|
||||
class CalculateMidPoints
|
||||
{
|
||||
public:
|
||||
using CellAndOffset = std::pair<uint64_t, uint64_t>;
|
||||
|
||||
CalculateMidPoints() = default;
|
||||
|
||||
void operator()(FeatureBuilder1 const & ft, uint64_t pos);
|
||||
bool operator()(m2::PointD const & p);
|
||||
|
||||
m2::PointD GetCenter() const;
|
||||
std::vector<CellAndOffset> const & GetVector() const { return m_vec; }
|
||||
|
||||
void Sort();
|
||||
|
||||
private:
|
||||
m2::PointD m_midLoc;
|
||||
m2::PointD m_midAll;
|
||||
size_t m_locCount = 0;
|
||||
size_t m_allCount = 0;
|
||||
uint32_t m_coordBits = serial::CodingParams().GetCoordBits();
|
||||
std::vector<CellAndOffset> m_vec;
|
||||
};
|
||||
|
||||
template <class Point>
|
||||
inline bool ArePointsEqual(Point const & p1, Point const & p2)
|
||||
{
|
||||
return p1 == p2;
|
||||
}
|
||||
|
||||
template <>
|
||||
inline bool ArePointsEqual<m2::PointD>(m2::PointD const & p1, m2::PointD const & p2)
|
||||
{
|
||||
return AlmostEqualULPs(p1, p2);
|
||||
}
|
||||
|
||||
class BoundsDistance : public m2::DistanceToLineSquare<m2::PointD>
|
||||
{
|
||||
public:
|
||||
explicit BoundsDistance(m2::RectD const & rect) : m_rect(rect) {}
|
||||
|
||||
double GetEpsilon() const { return m_eps; }
|
||||
|
||||
double operator()(m2::PointD const & p) const
|
||||
{
|
||||
if (my::AlmostEqualAbs(p.x, m_rect.minX(), m_eps) ||
|
||||
my::AlmostEqualAbs(p.x, m_rect.maxX(), m_eps) ||
|
||||
my::AlmostEqualAbs(p.y, m_rect.minY(), m_eps) ||
|
||||
my::AlmostEqualAbs(p.y, m_rect.maxY(), m_eps))
|
||||
{
|
||||
// Points near rect should be in a result simplified vector.
|
||||
return std::numeric_limits<double>::max();
|
||||
}
|
||||
|
||||
return m2::DistanceToLineSquare<m2::PointD>::operator()(p);
|
||||
}
|
||||
|
||||
private:
|
||||
m2::RectD const & m_rect;
|
||||
// 5.0E-7 is near with minimal epsilon when integer points are different
|
||||
// PointD2PointU(x, y) != PointD2PointU(x + m_eps, y + m_eps)
|
||||
double m_eps = 5.0E-7;
|
||||
};
|
||||
|
||||
template <class Distance, class PointsContainer>
|
||||
void SimplifyPoints(Distance dist, int level, PointsContainer const & in, PointsContainer & out)
|
||||
{
|
||||
if (in.size() < 2)
|
||||
return;
|
||||
|
||||
double const eps = my::sq(scales::GetEpsilonForSimplify(level));
|
||||
|
||||
SimplifyNearOptimal(20, in.begin(), in.end(), eps, dist,
|
||||
AccumulateSkipSmallTrg<Distance, m2::PointD>(dist, out, eps));
|
||||
|
||||
CHECK_GREATER(out.size(), 1, ());
|
||||
CHECK(ArePointsEqual(in.front(), out.front()), ());
|
||||
CHECK(ArePointsEqual(in.back(), out.back()), ());
|
||||
}
|
||||
} // namespace feature
|
||||
|
|
@ -1,7 +1,9 @@
|
|||
#include "generator/feature_sorter.hpp"
|
||||
|
||||
#include "generator/feature_builder.hpp"
|
||||
#include "generator/feature_generator.hpp"
|
||||
#include "generator/gen_mwm_info.hpp"
|
||||
#include "generator/geometry_holder.hpp"
|
||||
#include "generator/region_meta.hpp"
|
||||
#include "generator/tesselator.hpp"
|
||||
|
||||
|
|
@ -28,62 +30,11 @@
|
|||
#include "base/scope_guard.hpp"
|
||||
#include "base/string_utils.hpp"
|
||||
|
||||
namespace
|
||||
{
|
||||
typedef pair<uint64_t, uint64_t> CellAndOffsetT;
|
||||
#include <list>
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
|
||||
class CalculateMidPoints
|
||||
{
|
||||
m2::PointD m_midLoc, m_midAll;
|
||||
size_t m_locCount, m_allCount;
|
||||
uint32_t m_coordBits;
|
||||
|
||||
public:
|
||||
CalculateMidPoints()
|
||||
: m_midAll(0, 0), m_allCount(0), m_coordBits(serial::CodingParams().GetCoordBits())
|
||||
{
|
||||
}
|
||||
|
||||
vector<CellAndOffsetT> m_vec;
|
||||
|
||||
void operator()(FeatureBuilder1 const & ft, uint64_t pos)
|
||||
{
|
||||
// reset state
|
||||
m_midLoc = m2::PointD(0, 0);
|
||||
m_locCount = 0;
|
||||
|
||||
ft.ForEachGeometryPoint(*this);
|
||||
m_midLoc = m_midLoc / m_locCount;
|
||||
|
||||
uint64_t const pointAsInt64 = PointToInt64(m_midLoc, m_coordBits);
|
||||
int const minScale = feature::GetMinDrawableScale(ft.GetFeatureBase());
|
||||
|
||||
/// May be invisible if it's small area object with [0-9] scales.
|
||||
/// @todo Probably, we need to keep that objects if 9 scale (as we do in 17 scale).
|
||||
if (minScale != -1 || feature::RequireGeometryInIndex(ft.GetFeatureBase()))
|
||||
{
|
||||
uint64_t const order = (static_cast<uint64_t>(minScale) << 59) | (pointAsInt64 >> 5);
|
||||
m_vec.push_back(make_pair(order, pos));
|
||||
}
|
||||
}
|
||||
|
||||
bool operator()(m2::PointD const & p)
|
||||
{
|
||||
m_midLoc += p;
|
||||
m_midAll += p;
|
||||
++m_locCount;
|
||||
++m_allCount;
|
||||
return true;
|
||||
}
|
||||
|
||||
m2::PointD GetCenter() const { return m_midAll / m_allCount; }
|
||||
};
|
||||
|
||||
bool SortMidPointsFunc(CellAndOffsetT const & c1, CellAndOffsetT const & c2)
|
||||
{
|
||||
return c1.first < c2.first;
|
||||
}
|
||||
} // namespace
|
||||
using namespace std;
|
||||
|
||||
namespace feature
|
||||
{
|
||||
|
|
@ -96,7 +47,7 @@ class FeaturesCollector2 : public FeaturesCollector
|
|||
class TmpFile : public FileWriter
|
||||
{
|
||||
public:
|
||||
explicit TmpFile(std::string const & filePath) : FileWriter(filePath) {}
|
||||
explicit TmpFile(string const & filePath) : FileWriter(filePath) {}
|
||||
~TmpFile() { DeleteFileX(GetName()); }
|
||||
};
|
||||
|
||||
|
|
@ -112,7 +63,7 @@ class FeaturesCollector2 : public FeaturesCollector
|
|||
TmpFiles m_helperFile;
|
||||
|
||||
// Mapping from feature id to offset in file section with the correspondent metadata.
|
||||
vector<pair<uint32_t, uint32_t>> m_metadataIndex;
|
||||
vector<pair<uint32_t, uint32_t>> m_metadataOffset;
|
||||
|
||||
DataHeader m_header;
|
||||
RegionData m_regionData;
|
||||
|
|
@ -121,8 +72,8 @@ class FeaturesCollector2 : public FeaturesCollector
|
|||
gen::OsmID2FeatureID m_osm2ft;
|
||||
|
||||
public:
|
||||
FeaturesCollector2(std::string const & fName, DataHeader const & header,
|
||||
RegionData const & regionData, uint32_t versionDate)
|
||||
FeaturesCollector2(string const & fName, DataHeader const & header, RegionData const & regionData,
|
||||
uint32_t versionDate)
|
||||
: FeaturesCollector(fName + DATA_FILE_TAG)
|
||||
, m_writer(fName)
|
||||
, m_header(header)
|
||||
|
|
@ -131,7 +82,7 @@ public:
|
|||
{
|
||||
for (size_t i = 0; i < m_header.GetScalesCount(); ++i)
|
||||
{
|
||||
std::string const postfix = strings::to_string(i);
|
||||
string const postfix = strings::to_string(i);
|
||||
m_geoFile.push_back(make_unique<TmpFile>(fName + GEOMETRY_FILE_TAG + postfix));
|
||||
m_trgFile.push_back(make_unique<TmpFile>(fName + TRIANGLE_FILE_TAG + postfix));
|
||||
}
|
||||
|
|
@ -168,15 +119,15 @@ public:
|
|||
m_writer.Write(m_datFile.GetName(), DATA_FILE_TAG);
|
||||
|
||||
// File Writer finalization function with appending to the main mwm file.
|
||||
auto const finalizeFn = [this](unique_ptr<TmpFile> w, std::string const & tag,
|
||||
std::string const & postfix = std::string()) {
|
||||
auto const finalizeFn = [this](unique_ptr<TmpFile> w, string const & tag,
|
||||
string const & postfix = string()) {
|
||||
w->Flush();
|
||||
m_writer.Write(w->GetName(), tag + postfix);
|
||||
};
|
||||
|
||||
for (size_t i = 0; i < m_header.GetScalesCount(); ++i)
|
||||
{
|
||||
std::string const postfix = strings::to_string(i);
|
||||
string const postfix = strings::to_string(i);
|
||||
finalizeFn(move(m_geoFile[i]), GEOMETRY_FILE_TAG, postfix);
|
||||
finalizeFn(move(m_trgFile[i]), TRIANGLE_FILE_TAG, postfix);
|
||||
}
|
||||
|
|
@ -184,7 +135,7 @@ public:
|
|||
{
|
||||
/// @todo Replace this mapping vector with succint structure.
|
||||
FileWriter w = m_writer.GetWriter(METADATA_INDEX_FILE_TAG);
|
||||
for (auto const & v : m_metadataIndex)
|
||||
for (auto const & v : m_metadataOffset)
|
||||
{
|
||||
WriteToSink(w, v.first);
|
||||
WriteToSink(w, v.second);
|
||||
|
|
@ -207,211 +158,18 @@ private:
|
|||
typedef vector<m2::PointD> points_t;
|
||||
typedef list<points_t> polygons_t;
|
||||
|
||||
class GeometryHolder
|
||||
{
|
||||
public:
|
||||
FeatureBuilder2::SupportingData m_buffer;
|
||||
|
||||
private:
|
||||
FeaturesCollector2 & m_rMain;
|
||||
FeatureBuilder2 & m_rFB;
|
||||
|
||||
points_t m_current;
|
||||
|
||||
DataHeader const & m_header;
|
||||
|
||||
void WriteOuterPoints(points_t const & points, int i)
|
||||
{
|
||||
// outer path can have 2 points in small scale levels
|
||||
ASSERT_GREATER(points.size(), 1, ());
|
||||
|
||||
serial::CodingParams cp = m_header.GetCodingParams(i);
|
||||
|
||||
// Optimization: Store first point once in header for outer linear features.
|
||||
cp.SetBasePoint(points[0]);
|
||||
// Can optimize here, but ... Make copy of vector.
|
||||
points_t toSave(points.begin() + 1, points.end());
|
||||
|
||||
m_buffer.m_ptsMask |= (1 << i);
|
||||
m_buffer.m_ptsOffset.push_back(m_rMain.GetFileSize(*m_rMain.m_geoFile[i]));
|
||||
serial::SaveOuterPath(toSave, cp, *m_rMain.m_geoFile[i]);
|
||||
}
|
||||
|
||||
void WriteOuterTriangles(polygons_t const & polys, int i)
|
||||
{
|
||||
// tesselation
|
||||
tesselator::TrianglesInfo info;
|
||||
if (0 == tesselator::TesselateInterior(polys, info))
|
||||
{
|
||||
LOG(LINFO, ("NO TRIANGLES in", polys));
|
||||
return;
|
||||
}
|
||||
|
||||
serial::CodingParams const cp = m_header.GetCodingParams(i);
|
||||
|
||||
serial::TrianglesChainSaver saver(cp);
|
||||
|
||||
// points conversion
|
||||
tesselator::PointsInfo points;
|
||||
m2::PointU (*D2U)(m2::PointD const &, uint32_t) = &PointD2PointU;
|
||||
info.GetPointsInfo(saver.GetBasePoint(), saver.GetMaxPoint(),
|
||||
std::bind(D2U, std::placeholders::_1, cp.GetCoordBits()), points);
|
||||
|
||||
// triangles processing (should be optimal)
|
||||
info.ProcessPortions(points, saver, true);
|
||||
|
||||
// check triangles processing (to compare with optimal)
|
||||
// serial::TrianglesChainSaver checkSaver(cp);
|
||||
// info.ProcessPortions(points, checkSaver, false);
|
||||
|
||||
// CHECK_LESS_OR_EQUAL(saver.GetBufferSize(), checkSaver.GetBufferSize(), ());
|
||||
|
||||
// saving to file
|
||||
m_buffer.m_trgMask |= (1 << i);
|
||||
m_buffer.m_trgOffset.push_back(m_rMain.GetFileSize(*m_rMain.m_trgFile[i]));
|
||||
saver.Save(*m_rMain.m_trgFile[i]);
|
||||
}
|
||||
|
||||
void FillInnerPointsMask(points_t const & points, uint32_t scaleIndex)
|
||||
{
|
||||
points_t const & src = m_buffer.m_innerPts;
|
||||
CHECK(!src.empty(), ());
|
||||
|
||||
CHECK(are_points_equal(src.front(), points.front()), ());
|
||||
CHECK(are_points_equal(src.back(), points.back()), ());
|
||||
|
||||
size_t j = 1;
|
||||
for (size_t i = 1; i < points.size() - 1; ++i)
|
||||
{
|
||||
for (; j < src.size() - 1; ++j)
|
||||
{
|
||||
if (are_points_equal(src[j], points[i]))
|
||||
{
|
||||
// set corresponding 2 bits for source point [j] to scaleIndex
|
||||
uint32_t mask = 0x3;
|
||||
m_buffer.m_ptsSimpMask &= ~(mask << (2 * (j - 1)));
|
||||
m_buffer.m_ptsSimpMask |= (scaleIndex << (2 * (j - 1)));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
CHECK_LESS(j, src.size() - 1, ("Simplified point not found in source point array"));
|
||||
}
|
||||
}
|
||||
|
||||
bool m_ptsInner, m_trgInner;
|
||||
|
||||
class strip_emitter
|
||||
{
|
||||
points_t const & m_src;
|
||||
points_t & m_dest;
|
||||
|
||||
public:
|
||||
strip_emitter(points_t const & src, points_t & dest) : m_src(src), m_dest(dest)
|
||||
{
|
||||
m_dest.reserve(m_src.size());
|
||||
}
|
||||
void operator()(size_t i) { m_dest.push_back(m_src[i]); }
|
||||
};
|
||||
|
||||
public:
|
||||
GeometryHolder(FeaturesCollector2 & rMain, FeatureBuilder2 & fb, DataHeader const & header)
|
||||
: m_rMain(rMain), m_rFB(fb), m_header(header), m_ptsInner(true), m_trgInner(true)
|
||||
{
|
||||
}
|
||||
|
||||
points_t const & GetSourcePoints()
|
||||
{
|
||||
return (!m_current.empty() ? m_current : m_rFB.GetOuterGeometry());
|
||||
}
|
||||
|
||||
void AddPoints(points_t const & points, int scaleIndex)
|
||||
{
|
||||
if (m_ptsInner && points.size() < 15)
|
||||
{
|
||||
if (m_buffer.m_innerPts.empty())
|
||||
m_buffer.m_innerPts = points;
|
||||
else
|
||||
FillInnerPointsMask(points, scaleIndex);
|
||||
m_current = points;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_ptsInner = false;
|
||||
WriteOuterPoints(points, scaleIndex);
|
||||
}
|
||||
}
|
||||
|
||||
bool NeedProcessTriangles() const { return (!m_trgInner || m_buffer.m_innerTrg.empty()); }
|
||||
|
||||
bool TryToMakeStrip(points_t & points)
|
||||
{
|
||||
size_t const count = points.size();
|
||||
if (!m_trgInner || count > 15 + 2)
|
||||
{
|
||||
// too many points for strip
|
||||
m_trgInner = false;
|
||||
return false;
|
||||
}
|
||||
|
||||
if (m2::robust::CheckPolygonSelfIntersections(points.begin(), points.end()))
|
||||
{
|
||||
// polygon has self-intersectios
|
||||
m_trgInner = false;
|
||||
return false;
|
||||
}
|
||||
|
||||
CHECK(m_buffer.m_innerTrg.empty(), ());
|
||||
|
||||
// make CCW orientation for polygon
|
||||
if (!IsPolygonCCW(points.begin(), points.end()))
|
||||
{
|
||||
reverse(points.begin(), points.end());
|
||||
|
||||
// Actually this check doesn't work for some degenerate polygons.
|
||||
// See IsPolygonCCW_DataSet tests for more details.
|
||||
// ASSERT(IsPolygonCCW(points.begin(), points.end()), (points));
|
||||
if (!IsPolygonCCW(points.begin(), points.end()))
|
||||
return false;
|
||||
}
|
||||
|
||||
size_t const index = FindSingleStrip(
|
||||
count, IsDiagonalVisibleFunctor<points_t::const_iterator>(points.begin(), points.end()));
|
||||
|
||||
if (index == count)
|
||||
{
|
||||
// can't find strip
|
||||
m_trgInner = false;
|
||||
return false;
|
||||
}
|
||||
|
||||
MakeSingleStripFromIndex(index, count, strip_emitter(points, m_buffer.m_innerTrg));
|
||||
|
||||
CHECK_EQUAL(count, m_buffer.m_innerTrg.size(), ());
|
||||
return true;
|
||||
}
|
||||
|
||||
void AddTriangles(polygons_t const & polys, int scaleIndex)
|
||||
{
|
||||
CHECK(m_buffer.m_innerTrg.empty(), ());
|
||||
m_trgInner = false;
|
||||
|
||||
WriteOuterTriangles(polys, scaleIndex);
|
||||
}
|
||||
};
|
||||
|
||||
void SimplifyPoints(points_t const & in, points_t & out, int level, bool isCoast,
|
||||
m2::RectD const & rect)
|
||||
void SimplifyPoints(int level, bool isCoast, m2::RectD const & rect, points_t const & in,
|
||||
points_t & out)
|
||||
{
|
||||
if (isCoast)
|
||||
{
|
||||
BoundsDistance dist(rect);
|
||||
feature::SimplifyPoints(dist, in, out, level);
|
||||
feature::SimplifyPoints(dist, level, in, out);
|
||||
}
|
||||
else
|
||||
{
|
||||
m2::DistanceToLineSquare<m2::PointD> dist;
|
||||
feature::SimplifyPoints(dist, in, out, level);
|
||||
feature::SimplifyPoints(dist, level, in, out);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -419,16 +177,16 @@ private:
|
|||
{
|
||||
ASSERT(poly.front() == poly.back(), ());
|
||||
|
||||
double res = 0;
|
||||
double res = 0.0;
|
||||
for (size_t i = 0; i < poly.size() - 1; ++i)
|
||||
{
|
||||
res += (poly[i + 1].x - poly[i].x) * (poly[i + 1].y + poly[i].y) / 2.0;
|
||||
}
|
||||
return fabs(res);
|
||||
}
|
||||
|
||||
static bool IsGoodArea(points_t const & poly, int level)
|
||||
{
|
||||
// Area has the same first and last points. That's why minimal number of points for
|
||||
// area is 4.
|
||||
if (poly.size() < 4)
|
||||
return false;
|
||||
|
||||
|
|
@ -443,7 +201,8 @@ private:
|
|||
public:
|
||||
uint32_t operator()(FeatureBuilder2 & fb)
|
||||
{
|
||||
GeometryHolder holder(*this, fb, m_header);
|
||||
GeometryHolder holder([this](int i) -> FileWriter & { return *m_geoFile[i]; },
|
||||
[this](int i) -> FileWriter & { return *m_trgFile[i]; }, fb, m_header);
|
||||
|
||||
bool const isLine = fb.IsLine();
|
||||
bool const isArea = fb.IsArea();
|
||||
|
|
@ -464,7 +223,7 @@ public:
|
|||
if (isLine && i == scalesStart && IsCountry() && fb.IsRoad())
|
||||
points = holder.GetSourcePoints();
|
||||
else
|
||||
SimplifyPoints(holder.GetSourcePoints(), points, level, isCoast, rect);
|
||||
SimplifyPoints(level, isCoast, rect, holder.GetSourcePoints(), points);
|
||||
|
||||
if (isLine)
|
||||
holder.AddPoints(points, i);
|
||||
|
|
@ -475,6 +234,7 @@ public:
|
|||
bool const good = isCoast || IsGoodArea(points, level);
|
||||
|
||||
// At this point we don't need last point equal to first.
|
||||
CHECK_GREATER(points.size(), 0, ());
|
||||
points.pop_back();
|
||||
|
||||
polygons_t const & polys = fb.GetGeometry();
|
||||
|
|
@ -493,13 +253,14 @@ public:
|
|||
{
|
||||
simplified.push_back(points_t());
|
||||
|
||||
SimplifyPoints(*iH, simplified.back(), level, isCoast, rect);
|
||||
SimplifyPoints(level, isCoast, rect, *iH, simplified.back());
|
||||
|
||||
// Increment level check for coastline polygons for the first scale level.
|
||||
// This is used for better coastlines quality.
|
||||
if (IsGoodArea(simplified.back(), (isCoast && i == 0) ? level + 1 : level))
|
||||
{
|
||||
// At this point we don't need last point equal to first.
|
||||
CHECK_GREATER(simplified.back().size(), 0, ());
|
||||
simplified.back().pop_back();
|
||||
}
|
||||
else
|
||||
|
|
@ -516,11 +277,12 @@ public:
|
|||
}
|
||||
|
||||
uint32_t featureId = kInvalidFeatureId;
|
||||
if (fb.PreSerialize(holder.m_buffer))
|
||||
auto & buffer = holder.GetBuffer();
|
||||
if (fb.PreSerialize(buffer))
|
||||
{
|
||||
fb.Serialize(holder.m_buffer, m_header.GetDefCodingParams());
|
||||
fb.Serialize(buffer, m_header.GetDefCodingParams());
|
||||
|
||||
featureId = WriteFeatureBase(holder.m_buffer.m_buffer, fb);
|
||||
featureId = WriteFeatureBase(buffer.m_buffer, fb);
|
||||
|
||||
fb.GetAddressData().Serialize(*(m_helperFile[SEARCH_TOKENS]));
|
||||
|
||||
|
|
@ -531,7 +293,7 @@ public:
|
|||
uint64_t const offset = w->Pos();
|
||||
ASSERT_LESS_OR_EQUAL(offset, numeric_limits<uint32_t>::max(), ());
|
||||
|
||||
m_metadataIndex.emplace_back(featureId, static_cast<uint32_t>(offset));
|
||||
m_metadataOffset.emplace_back(featureId, static_cast<uint32_t>(offset));
|
||||
fb.GetMetadata().Serialize(*w);
|
||||
}
|
||||
|
||||
|
|
@ -551,18 +313,17 @@ FeatureBuilder2 & GetFeatureBuilder2(FeatureBuilder1 & fb)
|
|||
return static_cast<FeatureBuilder2 &>(fb);
|
||||
}
|
||||
|
||||
bool GenerateFinalFeatures(feature::GenerateInfo const & info, std::string const & name,
|
||||
int mapType)
|
||||
bool GenerateFinalFeatures(feature::GenerateInfo const & info, string const & name, int mapType)
|
||||
{
|
||||
std::string const srcFilePath = info.GetTmpFileName(name);
|
||||
std::string const datFilePath = info.GetTargetFileName(name);
|
||||
string const srcFilePath = info.GetTmpFileName(name);
|
||||
string const datFilePath = info.GetTargetFileName(name);
|
||||
|
||||
// stores cellIds for middle points
|
||||
CalculateMidPoints midPoints;
|
||||
ForEachFromDatRawFormat(srcFilePath, midPoints);
|
||||
|
||||
// sort features by their middle point
|
||||
sort(midPoints.m_vec.begin(), midPoints.m_vec.end(), &SortMidPointsFunc);
|
||||
midPoints.Sort();
|
||||
|
||||
// store sorted features
|
||||
{
|
||||
|
|
@ -599,10 +360,10 @@ bool GenerateFinalFeatures(feature::GenerateInfo const & info, std::string const
|
|||
{
|
||||
FeaturesCollector2 collector(datFilePath, header, regionData, info.m_versionDate);
|
||||
|
||||
for (size_t i = 0; i < midPoints.m_vec.size(); ++i)
|
||||
for (auto const & point : midPoints.GetVector())
|
||||
{
|
||||
ReaderSource<FileReader> src(reader);
|
||||
src.Skip(midPoints.m_vec[i].second);
|
||||
src.Skip(point.second);
|
||||
|
||||
FeatureBuilder1 f;
|
||||
ReadFromSourceRowFormat(src, f);
|
||||
|
|
|
|||
|
|
@ -1,12 +1,6 @@
|
|||
#pragma once
|
||||
#include "generator/generate_info.hpp"
|
||||
|
||||
#include "geometry/distance.hpp"
|
||||
#include "geometry/point2d.hpp"
|
||||
#include "geometry/simplification.hpp"
|
||||
|
||||
#include "indexer/scales.hpp"
|
||||
|
||||
#include <string>
|
||||
|
||||
namespace feature
|
||||
|
|
@ -16,59 +10,4 @@ namespace feature
|
|||
/// @param name - name of generated country;
|
||||
bool GenerateFinalFeatures(feature::GenerateInfo const & info, std::string const & name,
|
||||
int mapType);
|
||||
|
||||
template <class PointT>
|
||||
inline bool are_points_equal(PointT const & p1, PointT const & p2)
|
||||
{
|
||||
return p1 == p2;
|
||||
}
|
||||
|
||||
template <>
|
||||
inline bool are_points_equal<m2::PointD>(m2::PointD const & p1, m2::PointD const & p2)
|
||||
{
|
||||
return AlmostEqualULPs(p1, p2);
|
||||
}
|
||||
|
||||
class BoundsDistance : public m2::DistanceToLineSquare<m2::PointD>
|
||||
{
|
||||
m2::RectD const & m_rect;
|
||||
double m_eps;
|
||||
|
||||
public:
|
||||
BoundsDistance(m2::RectD const & rect) : m_rect(rect), m_eps(5.0E-7)
|
||||
{
|
||||
// 5.0E-7 is near with minimal epsilon when integer points are different
|
||||
// PointD2PointU(x, y) != PointD2PointU(x + m_eps, y + m_eps)
|
||||
}
|
||||
|
||||
double GetEpsilon() const { return m_eps; }
|
||||
|
||||
double operator()(m2::PointD const & p) const
|
||||
{
|
||||
if (fabs(p.x - m_rect.minX()) <= m_eps || fabs(p.x - m_rect.maxX()) <= m_eps ||
|
||||
fabs(p.y - m_rect.minY()) <= m_eps || fabs(p.y - m_rect.maxY()) <= m_eps)
|
||||
{
|
||||
// points near rect should be in a result simplified vector
|
||||
return std::numeric_limits<double>::max();
|
||||
}
|
||||
|
||||
return m2::DistanceToLineSquare<m2::PointD>::operator()(p);
|
||||
}
|
||||
};
|
||||
|
||||
template <class DistanceT, class PointsContainerT>
|
||||
void SimplifyPoints(DistanceT dist, PointsContainerT const & in, PointsContainerT & out, int level)
|
||||
{
|
||||
if (in.size() >= 2)
|
||||
{
|
||||
double const eps = my::sq(scales::GetEpsilonForSimplify(level));
|
||||
|
||||
SimplifyNearOptimal(20, in.begin(), in.end(), eps, dist,
|
||||
AccumulateSkipSmallTrg<DistanceT, m2::PointD>(dist, out, eps));
|
||||
|
||||
CHECK_GREATER(out.size(), 1, ());
|
||||
CHECK(are_points_equal(in.front(), out.front()), ());
|
||||
CHECK(are_points_equal(in.back(), out.back()), ());
|
||||
}
|
||||
}
|
||||
} // namespace feature
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
#include "testing/testing.hpp"
|
||||
|
||||
#include "generator/feature_builder.hpp"
|
||||
#include "generator/feature_sorter.hpp"
|
||||
#include "generator/feature_generator.hpp"
|
||||
#include "generator/feature_helpers.hpp"
|
||||
|
||||
#include "geometry/mercator.hpp"
|
||||
#include "indexer/cell_id.hpp"
|
||||
|
|
@ -148,7 +148,7 @@ namespace
|
|||
for (PolygonsT::const_iterator i = poly.begin(); i != poly.end(); ++i)
|
||||
{
|
||||
PointsT pts;
|
||||
feature::SimplifyPoints(dist, *i, pts, level);
|
||||
feature::SimplifyPoints(dist, level, *i, pts);
|
||||
|
||||
LOG(LINFO, ("Simplified. Level = ", level, "Points = ", pts));
|
||||
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@
|
|||
#include "generator/feature_generator.hpp"
|
||||
#include "generator/feature_sorter.hpp"
|
||||
#include "generator/generate_info.hpp"
|
||||
#include "generator/locality_sorter.hpp"
|
||||
#include "generator/metalines_builder.hpp"
|
||||
#include "generator/osm_source.hpp"
|
||||
#include "generator/restriction_generator.hpp"
|
||||
|
|
@ -29,6 +30,7 @@
|
|||
#include "indexer/features_offsets_table.hpp"
|
||||
#include "indexer/features_vector.hpp"
|
||||
#include "indexer/index_builder.hpp"
|
||||
#include "indexer/locality_index_builder.hpp"
|
||||
#include "indexer/map_style_reader.hpp"
|
||||
#include "indexer/rank_table.hpp"
|
||||
|
||||
|
|
@ -40,20 +42,21 @@
|
|||
|
||||
#include "base/timer.hpp"
|
||||
|
||||
#include "std/unique_ptr.hpp"
|
||||
|
||||
#include <cstdlib>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
|
||||
#include "defines.hpp"
|
||||
|
||||
#include "3party/gflags/src/gflags/gflags.h"
|
||||
|
||||
using namespace std;
|
||||
|
||||
namespace
|
||||
{
|
||||
char const * GetDataPathHelp()
|
||||
{
|
||||
static std::string const kHelp =
|
||||
static string const kHelp =
|
||||
"Directory where the generated mwms are put into. Also used as the path for helper "
|
||||
"functions, such as those that calculate statistics and regenerate sections. "
|
||||
"Default: " +
|
||||
|
|
@ -88,6 +91,7 @@ DEFINE_bool(generate_geometry, false,
|
|||
"3rd pass - split and simplify geometry and triangles for features.");
|
||||
DEFINE_bool(generate_index, false, "4rd pass - generate index.");
|
||||
DEFINE_bool(generate_search_index, false, "5th pass - generate search index.");
|
||||
DEFINE_bool(generate_locality_index, false, "3rd pass - generate locality objects and locality index.");
|
||||
|
||||
DEFINE_bool(dump_cities_boundaries, false, "Dump cities boundaries to a file");
|
||||
DEFINE_bool(generate_cities_boundaries, false, "Generate cities boundaries section");
|
||||
|
|
@ -155,7 +159,7 @@ int main(int argc, char ** argv)
|
|||
pl.SetSettingsDir(FLAGS_user_resource_path);
|
||||
}
|
||||
|
||||
std::string const path =
|
||||
string const path =
|
||||
FLAGS_data_path.empty() ? pl.WritableDir() : my::AddSlashIfNeeded(FLAGS_data_path);
|
||||
|
||||
// So that stray GetWritablePathForFile calls do not crash the generator.
|
||||
|
|
@ -169,7 +173,7 @@ int main(int argc, char ** argv)
|
|||
/// @todo Probably, it's better to add separate option for .mwm.tmp files.
|
||||
if (!FLAGS_intermediate_data_path.empty())
|
||||
{
|
||||
std::string const tmpPath = genInfo.m_intermediateDir + "tmp" + my::GetNativeSeparator();
|
||||
string const tmpPath = my::JoinPath(genInfo.m_intermediateDir, "tmp");
|
||||
if (Platform::MkDir(tmpPath) != Platform::ERR_UNKNOWN)
|
||||
genInfo.m_tmpDir = tmpPath;
|
||||
}
|
||||
|
|
@ -205,7 +209,7 @@ int main(int argc, char ** argv)
|
|||
GetStyleReader().SetCurrentStyle(MapStyleMerged);
|
||||
|
||||
// Load classificator only when necessary.
|
||||
if (FLAGS_make_coasts || FLAGS_generate_features || FLAGS_generate_geometry ||
|
||||
if (FLAGS_make_coasts || FLAGS_generate_features || FLAGS_generate_geometry || FLAGS_generate_locality_index ||
|
||||
FLAGS_generate_index || FLAGS_generate_search_index || FLAGS_generate_cities_boundaries ||
|
||||
FLAGS_calc_statistics || FLAGS_type_statistics || FLAGS_dump_types || FLAGS_dump_prefixes ||
|
||||
FLAGS_dump_feature_names != "" || FLAGS_check_mwm || FLAGS_srtm_path != "" ||
|
||||
|
|
@ -217,7 +221,7 @@ int main(int argc, char ** argv)
|
|||
}
|
||||
|
||||
// Load mwm tree only if we need it
|
||||
std::unique_ptr<storage::CountryParentGetter> countryParentGetter;
|
||||
unique_ptr<storage::CountryParentGetter> countryParentGetter;
|
||||
if (FLAGS_make_routing_index || FLAGS_make_cross_mwm || FLAGS_make_transit_cross_mwm)
|
||||
countryParentGetter = make_unique<storage::CountryParentGetter>();
|
||||
|
||||
|
|
@ -259,13 +263,39 @@ int main(int argc, char ** argv)
|
|||
genInfo.m_bucketNames.push_back(FLAGS_output);
|
||||
}
|
||||
|
||||
if (FLAGS_generate_locality_index)
|
||||
{
|
||||
if (FLAGS_output.empty() || FLAGS_intermediate_data_path.empty())
|
||||
{
|
||||
LOG(LCRITICAL, ("Bad output or intermediate_data_path. Output:", FLAGS_output,
|
||||
"intermediate_data_path:", FLAGS_intermediate_data_path));
|
||||
return -1;
|
||||
}
|
||||
|
||||
auto const locDataFile = my::JoinPath(path, FLAGS_output + LOC_DATA_FILE_EXTENSION);
|
||||
auto const outFile = my::JoinPath(path, FLAGS_output + LOC_IDX_FILE_EXTENSION);
|
||||
if (!feature::GenerateLocalityData(genInfo.m_tmpDir, locDataFile))
|
||||
{
|
||||
LOG(LCRITICAL, ("Error generating locality data."));
|
||||
return -1;
|
||||
}
|
||||
|
||||
LOG(LINFO, ("Saving locality index to", outFile));
|
||||
|
||||
if (!indexer::BuildLocalityIndexFromDataFile(locDataFile, outFile))
|
||||
{
|
||||
LOG(LCRITICAL, ("Error generating locality index."));
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
// Enumerate over all dat files that were created.
|
||||
size_t const count = genInfo.m_bucketNames.size();
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
{
|
||||
std::string const & country = genInfo.m_bucketNames[i];
|
||||
std::string const datFile = my::JoinFoldersToPath(path, country + DATA_FILE_EXTENSION);
|
||||
std::string const osmToFeatureFilename =
|
||||
string const & country = genInfo.m_bucketNames[i];
|
||||
string const datFile = my::JoinPath(path, country + DATA_FILE_EXTENSION);
|
||||
string const osmToFeatureFilename =
|
||||
genInfo.GetTargetFileName(country) + OSM2FEATURE_FILE_EXTENSION;
|
||||
|
||||
if (FLAGS_generate_geometry)
|
||||
|
|
@ -288,7 +318,7 @@ int main(int argc, char ** argv)
|
|||
|
||||
if (mapType == feature::DataHeader::country)
|
||||
{
|
||||
std::string const metalinesFilename =
|
||||
string const metalinesFilename =
|
||||
genInfo.GetIntermediateFileName(METALINES_FILENAME, "" /* extension */);
|
||||
|
||||
LOG(LINFO, ("Processing metalines from", metalinesFilename));
|
||||
|
|
@ -348,9 +378,9 @@ int main(int argc, char ** argv)
|
|||
return -1;
|
||||
}
|
||||
|
||||
std::string const restrictionsFilename =
|
||||
string const restrictionsFilename =
|
||||
genInfo.GetIntermediateFileName(RESTRICTIONS_FILENAME, "" /* extension */);
|
||||
std::string const roadAccessFilename =
|
||||
string const roadAccessFilename =
|
||||
genInfo.GetIntermediateFileName(ROAD_ACCESS_FILENAME, "" /* extension */);
|
||||
|
||||
routing::BuildRoadRestrictions(datFile, restrictionsFilename, osmToFeatureFilename);
|
||||
|
|
@ -393,7 +423,7 @@ int main(int argc, char ** argv)
|
|||
}
|
||||
}
|
||||
|
||||
std::string const datFile = my::JoinFoldersToPath(path, FLAGS_output + DATA_FILE_EXTENSION);
|
||||
string const datFile = my::JoinPath(path, FLAGS_output + DATA_FILE_EXTENSION);
|
||||
|
||||
if (FLAGS_calc_statistics)
|
||||
{
|
||||
|
|
|
|||
249
generator/geometry_holder.hpp
Normal file
249
generator/geometry_holder.hpp
Normal file
|
|
@ -0,0 +1,249 @@
|
|||
#pragma once
|
||||
|
||||
#include "generator/feature_builder.hpp"
|
||||
#include "generator/feature_generator.hpp"
|
||||
#include "generator/feature_helpers.hpp"
|
||||
#include "generator/tesselator.hpp"
|
||||
|
||||
#include "geometry/distance.hpp"
|
||||
#include "geometry/point2d.hpp"
|
||||
#include "geometry/polygon.hpp"
|
||||
#include "geometry/simplification.hpp"
|
||||
|
||||
#include "indexer/data_header.hpp"
|
||||
#include "indexer/geometry_serialization.hpp"
|
||||
|
||||
#include <cstdint>
|
||||
#include <functional>
|
||||
#include <list>
|
||||
#include <vector>
|
||||
|
||||
namespace feature
|
||||
{
|
||||
class GeometryHolder
|
||||
{
|
||||
public:
|
||||
using FileGetter = std::function<FileWriter &(int i)>;
|
||||
using Points = std::vector<m2::PointD>;
|
||||
using Polygons = std::list<Points>;
|
||||
|
||||
// For FeatureType serialization maxNumTriangles should be less than numeric_limits<uint8_t>::max
|
||||
// because FeatureType format uses uint8_t to encode the number of triangles.
|
||||
GeometryHolder(FileGetter geoFileGetter, FileGetter trgFileGetter, FeatureBuilder2 & fb,
|
||||
feature::DataHeader const & header, size_t maxNumTriangles = 14)
|
||||
: m_geoFileGetter(geoFileGetter)
|
||||
, m_trgFileGetter(trgFileGetter)
|
||||
, m_fb(fb)
|
||||
, m_ptsInner(true)
|
||||
, m_trgInner(true)
|
||||
, m_header(header)
|
||||
, m_maxNumTriangles(maxNumTriangles)
|
||||
{
|
||||
}
|
||||
|
||||
GeometryHolder(FeatureBuilder2 & fb, feature::DataHeader const & header,
|
||||
size_t maxNumTriangles = 14)
|
||||
: m_fb(fb)
|
||||
, m_ptsInner(true)
|
||||
, m_trgInner(true)
|
||||
, m_header(header)
|
||||
, m_maxNumTriangles(maxNumTriangles)
|
||||
{
|
||||
}
|
||||
|
||||
void SetInner() { m_trgInner = true; }
|
||||
|
||||
FeatureBuilder2::SupportingData & GetBuffer() { return m_buffer; }
|
||||
|
||||
Points const & GetSourcePoints()
|
||||
{
|
||||
return !m_current.empty() ? m_current : m_fb.GetOuterGeometry();
|
||||
}
|
||||
|
||||
void AddPoints(Points const & points, int scaleIndex)
|
||||
{
|
||||
if (m_ptsInner && points.size() <= m_maxNumTriangles)
|
||||
{
|
||||
if (m_buffer.m_innerPts.empty())
|
||||
m_buffer.m_innerPts = points;
|
||||
else
|
||||
FillInnerPointsMask(points, scaleIndex);
|
||||
m_current = points;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_ptsInner = false;
|
||||
WriteOuterPoints(points, scaleIndex);
|
||||
}
|
||||
}
|
||||
|
||||
bool NeedProcessTriangles() const { return !m_trgInner || m_buffer.m_innerTrg.empty(); }
|
||||
|
||||
bool TryToMakeStrip(Points & points)
|
||||
{
|
||||
size_t const count = points.size();
|
||||
if (!m_trgInner || (count >= 2 && count - 2 > m_maxNumTriangles))
|
||||
{
|
||||
// too many points for strip
|
||||
m_trgInner = false;
|
||||
return false;
|
||||
}
|
||||
|
||||
if (m2::robust::CheckPolygonSelfIntersections(points.begin(), points.end()))
|
||||
{
|
||||
// polygon has self-intersectios
|
||||
m_trgInner = false;
|
||||
return false;
|
||||
}
|
||||
|
||||
CHECK(m_buffer.m_innerTrg.empty(), ());
|
||||
|
||||
// make CCW orientation for polygon
|
||||
if (!IsPolygonCCW(points.begin(), points.end()))
|
||||
{
|
||||
reverse(points.begin(), points.end());
|
||||
|
||||
// Actually this check doesn't work for some degenerate polygons.
|
||||
// See IsPolygonCCW_DataSet tests for more details.
|
||||
// ASSERT(IsPolygonCCW(points.begin(), points.end()), (points));
|
||||
if (!IsPolygonCCW(points.begin(), points.end()))
|
||||
return false;
|
||||
}
|
||||
|
||||
size_t const index = FindSingleStrip(
|
||||
count, IsDiagonalVisibleFunctor<Points::const_iterator>(points.begin(), points.end()));
|
||||
|
||||
if (index == count)
|
||||
{
|
||||
// can't find strip
|
||||
m_trgInner = false;
|
||||
return false;
|
||||
}
|
||||
|
||||
MakeSingleStripFromIndex(index, count, StripEmitter(points, m_buffer.m_innerTrg));
|
||||
|
||||
CHECK_EQUAL(count, m_buffer.m_innerTrg.size(), ());
|
||||
return true;
|
||||
}
|
||||
|
||||
void AddTriangles(Polygons const & polys, int scaleIndex)
|
||||
{
|
||||
CHECK(m_buffer.m_innerTrg.empty(), ());
|
||||
m_trgInner = false;
|
||||
|
||||
WriteOuterTriangles(polys, scaleIndex);
|
||||
}
|
||||
|
||||
private:
|
||||
class StripEmitter
|
||||
{
|
||||
public:
|
||||
StripEmitter(Points const & src, Points & dest) : m_src(src), m_dest(dest)
|
||||
{
|
||||
m_dest.reserve(m_src.size());
|
||||
}
|
||||
void operator()(size_t i) { m_dest.push_back(m_src[i]); }
|
||||
|
||||
private:
|
||||
Points const & m_src;
|
||||
Points & m_dest;
|
||||
};
|
||||
|
||||
void WriteOuterPoints(Points const & points, int i)
|
||||
{
|
||||
CHECK(m_geoFileGetter, ("m_geoFileGetter must be set to write outer points."));
|
||||
|
||||
// outer path can have 2 points in small scale levels
|
||||
ASSERT_GREATER(points.size(), 1, ());
|
||||
|
||||
auto cp = m_header.GetCodingParams(i);
|
||||
|
||||
// Optimization: Store first point once in header for outer linear features.
|
||||
cp.SetBasePoint(points[0]);
|
||||
// Can optimize here, but ... Make copy of vector.
|
||||
Points toSave(points.begin() + 1, points.end());
|
||||
|
||||
m_buffer.m_ptsMask |= (1 << i);
|
||||
m_buffer.m_ptsOffset.push_back(feature::FeaturesCollector::GetFileSize(m_geoFileGetter(i)));
|
||||
serial::SaveOuterPath(toSave, cp, m_geoFileGetter(i));
|
||||
}
|
||||
|
||||
void WriteOuterTriangles(Polygons const & polys, int i)
|
||||
{
|
||||
CHECK(m_trgFileGetter, ("m_trgFileGetter must be set to write outer triangles."));
|
||||
|
||||
// tesselation
|
||||
tesselator::TrianglesInfo info;
|
||||
if (0 == tesselator::TesselateInterior(polys, info))
|
||||
{
|
||||
LOG(LINFO, ("NO TRIANGLES in", polys));
|
||||
return;
|
||||
}
|
||||
|
||||
auto const cp = m_header.GetCodingParams(i);
|
||||
|
||||
serial::TrianglesChainSaver saver(cp);
|
||||
|
||||
// points conversion
|
||||
tesselator::PointsInfo points;
|
||||
m2::PointU (*D2U)(m2::PointD const &, uint32_t) = &PointD2PointU;
|
||||
info.GetPointsInfo(saver.GetBasePoint(), saver.GetMaxPoint(),
|
||||
std::bind(D2U, std::placeholders::_1, cp.GetCoordBits()), points);
|
||||
|
||||
// triangles processing (should be optimal)
|
||||
info.ProcessPortions(points, saver, true);
|
||||
|
||||
// check triangles processing (to compare with optimal)
|
||||
// serial::TrianglesChainSaver checkSaver(cp);
|
||||
// info.ProcessPortions(points, checkSaver, false);
|
||||
|
||||
// CHECK_LESS_OR_EQUAL(saver.GetBufferSize(), checkSaver.GetBufferSize(), ());
|
||||
|
||||
// saving to file
|
||||
m_buffer.m_trgMask |= (1 << i);
|
||||
m_buffer.m_trgOffset.push_back(feature::FeaturesCollector::GetFileSize(m_trgFileGetter(i)));
|
||||
saver.Save(m_trgFileGetter(i));
|
||||
}
|
||||
|
||||
void FillInnerPointsMask(Points const & points, uint32_t scaleIndex)
|
||||
{
|
||||
auto const & src = m_buffer.m_innerPts;
|
||||
CHECK(!src.empty(), ());
|
||||
|
||||
CHECK(feature::ArePointsEqual(src.front(), points.front()), ());
|
||||
CHECK(feature::ArePointsEqual(src.back(), points.back()), ());
|
||||
|
||||
size_t j = 1;
|
||||
for (size_t i = 1; i < points.size() - 1; ++i)
|
||||
{
|
||||
for (; j < src.size() - 1; ++j)
|
||||
{
|
||||
if (feature::ArePointsEqual(src[j], points[i]))
|
||||
{
|
||||
// set corresponding 2 bits for source point [j] to scaleIndex
|
||||
uint32_t mask = 0x3;
|
||||
m_buffer.m_ptsSimpMask &= ~(mask << (2 * (j - 1)));
|
||||
m_buffer.m_ptsSimpMask |= (scaleIndex << (2 * (j - 1)));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
CHECK_LESS(j, src.size() - 1, ("Simplified point is not found in the source point array."));
|
||||
}
|
||||
}
|
||||
|
||||
FileGetter m_geoFileGetter = {};
|
||||
FileGetter m_trgFileGetter = {};
|
||||
|
||||
FeatureBuilder2 & m_fb;
|
||||
|
||||
FeatureBuilder2::SupportingData m_buffer;
|
||||
|
||||
Points m_current;
|
||||
bool m_ptsInner, m_trgInner;
|
||||
|
||||
feature::DataHeader const & m_header;
|
||||
// max triangles number to store in innerTriangles
|
||||
size_t m_maxNumTriangles;
|
||||
};
|
||||
} // namespace feature
|
||||
176
generator/locality_sorter.cpp
Normal file
176
generator/locality_sorter.cpp
Normal file
|
|
@ -0,0 +1,176 @@
|
|||
#include "generator/locality_sorter.hpp"
|
||||
|
||||
#include "generator/geometry_holder.hpp"
|
||||
|
||||
#include "indexer/data_header.hpp"
|
||||
#include "indexer/geometry_serialization.hpp"
|
||||
#include "indexer/scales.hpp"
|
||||
#include "indexer/scales_patch.hpp"
|
||||
|
||||
#include "coding/file_container.hpp"
|
||||
#include "coding/file_name_utils.hpp"
|
||||
#include "coding/internal/file_data.hpp"
|
||||
|
||||
#include "geometry/convex_hull.hpp"
|
||||
|
||||
#include "platform/platform.hpp"
|
||||
|
||||
#include "base/assert.hpp"
|
||||
#include "base/logging.hpp"
|
||||
#include "base/scope_guard.hpp"
|
||||
#include "base/timer.hpp"
|
||||
|
||||
#include "defines.hpp"
|
||||
|
||||
#include <limits>
|
||||
#include <vector>
|
||||
|
||||
using namespace feature;
|
||||
using namespace std;
|
||||
|
||||
class LocalityCollector : public FeaturesCollector
|
||||
{
|
||||
DISALLOW_COPY_AND_MOVE(LocalityCollector);
|
||||
|
||||
FilesContainerW m_writer;
|
||||
DataHeader m_header;
|
||||
uint32_t m_versionDate;
|
||||
|
||||
public:
|
||||
LocalityCollector(string const & fName, DataHeader const & header, uint32_t versionDate)
|
||||
: FeaturesCollector(fName + EXTENSION_TMP)
|
||||
, m_writer(fName)
|
||||
, m_header(header)
|
||||
, m_versionDate(versionDate)
|
||||
{
|
||||
}
|
||||
|
||||
void Finish()
|
||||
{
|
||||
{
|
||||
FileWriter w = m_writer.GetWriter(VERSION_FILE_TAG);
|
||||
version::WriteVersion(w, m_versionDate);
|
||||
}
|
||||
|
||||
m_header.SetBounds(m_bounds);
|
||||
{
|
||||
FileWriter w = m_writer.GetWriter(HEADER_FILE_TAG);
|
||||
m_header.Save(w);
|
||||
}
|
||||
|
||||
Flush();
|
||||
|
||||
m_writer.Write(m_datFile.GetName(), LOCALITY_DATA_FILE_TAG);
|
||||
m_writer.Finish();
|
||||
}
|
||||
|
||||
void operator()(FeatureBuilder2 & fb)
|
||||
{
|
||||
if (!fb.IsLocalityObject())
|
||||
return;
|
||||
|
||||
// Do not limit inner triangles number to save all geometry without additional sections.
|
||||
GeometryHolder holder(fb, m_header, numeric_limits<uint32_t>::max() /* maxTrianglesNumber */);
|
||||
|
||||
// Simplify and serialize geometry.
|
||||
vector<m2::PointD> points;
|
||||
m2::DistanceToLineSquare<m2::PointD> dist;
|
||||
|
||||
SimplifyPoints(dist, scales::GetUpperScale(), holder.GetSourcePoints(), points);
|
||||
|
||||
// For areas we save outer geometry only.
|
||||
if (fb.IsArea() && holder.NeedProcessTriangles())
|
||||
{
|
||||
// At this point we don't need last point equal to first.
|
||||
points.pop_back();
|
||||
auto const & polys = fb.GetGeometry();
|
||||
if (polys.size() != 1)
|
||||
{
|
||||
points.clear();
|
||||
for (auto const & poly : polys)
|
||||
points.insert(points.end(), poly.begin(), poly.end());
|
||||
}
|
||||
|
||||
if (points.size() > 2)
|
||||
{
|
||||
if (!holder.TryToMakeStrip(points))
|
||||
{
|
||||
m2::ConvexHull hull(points, 1e-16);
|
||||
vector<m2::PointD> hullPoints = hull.Points();
|
||||
holder.SetInner();
|
||||
auto const id = fb.GetMostGenericOsmId();
|
||||
CHECK(holder.TryToMakeStrip(hullPoints),
|
||||
("Error while building tringles for object with OSM Id:", id.OsmId(),
|
||||
"Type:", id.IsRelation() ? "Relation" : "Way", "points:", points,
|
||||
"hull:", hull.Points()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
auto & buffer = holder.GetBuffer();
|
||||
if (fb.PreSerialize(buffer))
|
||||
{
|
||||
fb.SerializeLocalityObject(serial::CodingParams(), buffer);
|
||||
WriteFeatureBase(buffer.m_buffer, fb);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// Simplify geometry for the upper scale.
|
||||
FeatureBuilder2 & GetFeatureBuilder2(FeatureBuilder1 & fb)
|
||||
{
|
||||
return static_cast<FeatureBuilder2 &>(fb);
|
||||
}
|
||||
|
||||
namespace feature
|
||||
{
|
||||
bool GenerateLocalityData(string const & featuresDir, string const & dataFilePath)
|
||||
{
|
||||
DataHeader header;
|
||||
header.SetCodingParams(serial::CodingParams());
|
||||
header.SetScales({scales::GetUpperScale()});
|
||||
|
||||
// Transform features from raw format to LocalityObject format.
|
||||
try
|
||||
{
|
||||
LocalityCollector collector(dataFilePath, header,
|
||||
static_cast<uint32_t>(my::SecondsSinceEpoch()));
|
||||
|
||||
Platform::FilesList files;
|
||||
Platform::GetFilesByExt(featuresDir, DATA_FILE_EXTENSION_TMP, files);
|
||||
|
||||
for (auto const & fileName : files)
|
||||
{
|
||||
auto const file = my::JoinFoldersToPath(featuresDir, fileName);
|
||||
LOG(LINFO, ("Processing", file));
|
||||
|
||||
CalculateMidPoints midPoints;
|
||||
ForEachFromDatRawFormat(file, midPoints);
|
||||
|
||||
// Sort features by their middle point.
|
||||
midPoints.Sort();
|
||||
|
||||
FileReader reader(file);
|
||||
for (auto const & point : midPoints.GetVector())
|
||||
{
|
||||
ReaderSource<FileReader> src(reader);
|
||||
src.Skip(point.second);
|
||||
|
||||
FeatureBuilder1 f;
|
||||
ReadFromSourceRowFormat(src, f);
|
||||
// Emit object.
|
||||
collector(GetFeatureBuilder2(f));
|
||||
}
|
||||
}
|
||||
|
||||
collector.Finish();
|
||||
}
|
||||
catch (RootException const & ex)
|
||||
{
|
||||
LOG(LCRITICAL, ("Locality data writing error:", ex.Msg()));
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
} // namespace feature
|
||||
11
generator/locality_sorter.hpp
Normal file
11
generator/locality_sorter.hpp
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
#pragma once
|
||||
|
||||
#include <string>
|
||||
|
||||
namespace feature
|
||||
{
|
||||
/// Generates data for LocalityIndexBuilder from input feature-dat-files.
|
||||
/// @param featuresDir - path to folder with pregenerated features data;
|
||||
/// @param out - output file name;
|
||||
bool GenerateLocalityData(std::string const & featuresDir, std::string const & out);
|
||||
} // namespace feature
|
||||
|
|
@ -57,19 +57,19 @@ private:
|
|||
};
|
||||
} // namespace
|
||||
|
||||
bool BuildLocalityIndexFromDataFile(string const & dataFile, string const & tmpFile)
|
||||
bool BuildLocalityIndexFromDataFile(string const & dataFile, string const & outFileName)
|
||||
{
|
||||
try
|
||||
{
|
||||
string const idxFileName(tmpFile + LOCALITY_INDEX_TMP_EXT);
|
||||
string const idxFileName(outFileName + LOCALITY_INDEX_TMP_EXT);
|
||||
{
|
||||
LocalityVectorReader localities(dataFile);
|
||||
FileWriter writer(idxFileName);
|
||||
|
||||
covering::BuildLocalityIndex(localities.GetVector(), writer, tmpFile);
|
||||
covering::BuildLocalityIndex(localities.GetVector(), writer, outFileName);
|
||||
}
|
||||
|
||||
FilesContainerW(dataFile, FileWriter::OP_WRITE_EXISTING)
|
||||
FilesContainerW(outFileName, FileWriter::OP_WRITE_TRUNCATE)
|
||||
.Write(idxFileName, LOCALITY_INDEX_FILE_TAG);
|
||||
FileWriter::DeleteFileX(idxFileName);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -22,13 +22,11 @@ void LocalityObject::Deserialize(char const * data)
|
|||
}
|
||||
|
||||
ASSERT_EQUAL(type, feature::GEOM_AREA, ("Only supported types are GEOM_POINT and GEOM_AREA."));
|
||||
uint8_t trgCount;
|
||||
uint32_t trgCount;
|
||||
ReadPrimitiveFromSource(src, trgCount);
|
||||
if (trgCount > 0)
|
||||
{
|
||||
trgCount += 2;
|
||||
char const * start = static_cast<char const *>(src.PtrC());
|
||||
serial::LoadInnerTriangles(start, trgCount, cp, m_triangles);
|
||||
}
|
||||
CHECK_GREATER(trgCount, 0, ());
|
||||
trgCount += 2;
|
||||
char const * start = static_cast<char const *>(src.PtrC());
|
||||
serial::LoadInnerTriangles(start, trgCount, cp, m_triangles);
|
||||
}
|
||||
} // namespace indexer
|
||||
|
|
|
|||
|
|
@ -35,6 +35,11 @@
|
|||
3DFEBF7F1EF2D58900317D5C /* viator_dataset.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3DFEBF7A1EF2D58900317D5C /* viator_dataset.cpp */; };
|
||||
3DFEBF801EF2D58900317D5C /* viator_dataset.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3DFEBF7B1EF2D58900317D5C /* viator_dataset.hpp */; };
|
||||
3DFEBF821EF423FB00317D5C /* sponsored_object_storage.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3DFEBF811EF423FB00317D5C /* sponsored_object_storage.hpp */; };
|
||||
40492BC82021DC53008E093A /* locality_sorter.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 40492BC32021DC53008E093A /* locality_sorter.hpp */; };
|
||||
40492BC92021DC53008E093A /* feature_helpers.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 40492BC42021DC53008E093A /* feature_helpers.cpp */; };
|
||||
40492BCA2021DC53008E093A /* feature_helpers.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 40492BC52021DC53008E093A /* feature_helpers.hpp */; };
|
||||
40492BCB2021DC53008E093A /* locality_sorter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 40492BC62021DC53008E093A /* locality_sorter.cpp */; };
|
||||
40492BCC2021DC53008E093A /* geometry_holder.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 40492BC72021DC53008E093A /* geometry_holder.hpp */; };
|
||||
568762601F6A9B18002C22A6 /* transit_generator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5687625E1F6A9B18002C22A6 /* transit_generator.cpp */; };
|
||||
568762611F6A9B18002C22A6 /* transit_generator.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 5687625F1F6A9B18002C22A6 /* transit_generator.hpp */; };
|
||||
670B84BC1A8CDB0000CE4492 /* osm_source.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 670B84BA1A8CDB0000CE4492 /* osm_source.cpp */; };
|
||||
|
|
@ -145,6 +150,11 @@
|
|||
3DFEBF7A1EF2D58900317D5C /* viator_dataset.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = viator_dataset.cpp; sourceTree = "<group>"; };
|
||||
3DFEBF7B1EF2D58900317D5C /* viator_dataset.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = viator_dataset.hpp; sourceTree = "<group>"; };
|
||||
3DFEBF811EF423FB00317D5C /* sponsored_object_storage.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = sponsored_object_storage.hpp; sourceTree = "<group>"; };
|
||||
40492BC32021DC53008E093A /* locality_sorter.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = locality_sorter.hpp; sourceTree = "<group>"; };
|
||||
40492BC42021DC53008E093A /* feature_helpers.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = feature_helpers.cpp; sourceTree = "<group>"; };
|
||||
40492BC52021DC53008E093A /* feature_helpers.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = feature_helpers.hpp; sourceTree = "<group>"; };
|
||||
40492BC62021DC53008E093A /* locality_sorter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = locality_sorter.cpp; sourceTree = "<group>"; };
|
||||
40492BC72021DC53008E093A /* geometry_holder.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = geometry_holder.hpp; sourceTree = "<group>"; };
|
||||
5687625E1F6A9B18002C22A6 /* transit_generator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = transit_generator.cpp; sourceTree = "<group>"; };
|
||||
5687625F1F6A9B18002C22A6 /* transit_generator.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = transit_generator.hpp; sourceTree = "<group>"; };
|
||||
670B84BA1A8CDB0000CE4492 /* osm_source.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = osm_source.cpp; sourceTree = "<group>"; };
|
||||
|
|
@ -271,6 +281,11 @@
|
|||
children = (
|
||||
9D1B3F1A2034624900278AC8 /* node_mixer.cpp */,
|
||||
9D1B3F192034624900278AC8 /* node_mixer.hpp */,
|
||||
40492BC42021DC53008E093A /* feature_helpers.cpp */,
|
||||
40492BC52021DC53008E093A /* feature_helpers.hpp */,
|
||||
40492BC72021DC53008E093A /* geometry_holder.hpp */,
|
||||
40492BC62021DC53008E093A /* locality_sorter.cpp */,
|
||||
40492BC32021DC53008E093A /* locality_sorter.hpp */,
|
||||
39B2B9761FB468CC00AB85A1 /* cities_boundaries_builder.cpp */,
|
||||
39B2B9771FB468CC00AB85A1 /* cities_boundaries_builder.hpp */,
|
||||
3D74EF051F86841C0081202C /* ugc_section_builder.cpp */,
|
||||
|
|
@ -397,6 +412,7 @@
|
|||
isa = PBXHeadersBuildPhase;
|
||||
buildActionMask = 2147483647;
|
||||
files = (
|
||||
40492BC82021DC53008E093A /* locality_sorter.hpp in Headers */,
|
||||
34F558881DBF4C9600A4FC11 /* opentable_dataset.hpp in Headers */,
|
||||
670E7BCB1EF9C29A00A8E9ED /* ugc_translator.hpp in Headers */,
|
||||
675340881A3F2A7400A0A8C3 /* unpack_mwm.hpp in Headers */,
|
||||
|
|
@ -407,6 +423,7 @@
|
|||
670B84BD1A8CDB0000CE4492 /* osm_source.hpp in Headers */,
|
||||
675340631A3F2A7400A0A8C3 /* coastlines_generator.hpp in Headers */,
|
||||
675340641A3F2A7400A0A8C3 /* intermediate_data.hpp in Headers */,
|
||||
40492BCA2021DC53008E093A /* feature_helpers.hpp in Headers */,
|
||||
675340781A3F2A7400A0A8C3 /* intermediate_elements.hpp in Headers */,
|
||||
3DFEBF7E1EF2D58900317D5C /* utils.hpp in Headers */,
|
||||
6753406B1A3F2A7400A0A8C3 /* feature_emitter_iface.hpp in Headers */,
|
||||
|
|
@ -430,6 +447,7 @@
|
|||
670E7BBA1EF9812B00A8E9ED /* ugc_db.hpp in Headers */,
|
||||
0C5FEC711DDE19E50017688C /* routing_index_generator.hpp in Headers */,
|
||||
67C79BB01E2CEEAB00C40034 /* restriction_collector.hpp in Headers */,
|
||||
40492BCC2021DC53008E093A /* geometry_holder.hpp in Headers */,
|
||||
3DFEBF801EF2D58900317D5C /* viator_dataset.hpp in Headers */,
|
||||
675340941C5231BA002CF0D9 /* search_index_builder.hpp in Headers */,
|
||||
3D51BC591D5E512500F1FA8D /* srtm_parser.hpp in Headers */,
|
||||
|
|
@ -565,6 +583,7 @@
|
|||
6753408D1A3F2A7400A0A8C3 /* osm_element.cpp in Sources */,
|
||||
6726C1D51A4AFEF4005EEA39 /* osm2meta.cpp in Sources */,
|
||||
34F5588C1DBF4C9600A4FC11 /* sponsored_scoring.cpp in Sources */,
|
||||
40492BCB2021DC53008E093A /* locality_sorter.cpp in Sources */,
|
||||
6753405E1A3F2A7400A0A8C3 /* borders_loader.cpp in Sources */,
|
||||
675340691A3F2A7400A0A8C3 /* feature_builder.cpp in Sources */,
|
||||
677E2A171CAACC5F001DC42A /* towns_dumper.cpp in Sources */,
|
||||
|
|
@ -576,6 +595,7 @@
|
|||
3D51BC481D5E50F700F1FA8D /* centers_table_builder.cpp in Sources */,
|
||||
675340671A3F2A7400A0A8C3 /* dumper.cpp in Sources */,
|
||||
E9502E331D34012200CAB86B /* booking_scoring.cpp in Sources */,
|
||||
40492BC92021DC53008E093A /* feature_helpers.cpp in Sources */,
|
||||
670E7BB91EF9812B00A8E9ED /* ugc_db.cpp in Sources */,
|
||||
675340831A3F2A7400A0A8C3 /* statistics.cpp in Sources */,
|
||||
670E7BB51EF9812B00A8E9ED /* road_access_generator.cpp in Sources */,
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue