forked from organicmaps/organicmaps-tmp
Feature geometry size optimization : make triangles Encoding\Decoding as binary tree.
This commit is contained in:
vng
Alex Zolotarev
parent
910964da85
commit
3f869a3c19
13 changed files with 767 additions and 130 deletions
|
|
@ -12,7 +12,6 @@ include($$ROOT_DIR/common.pri)
|
|||
SOURCES += \
|
||||
screenbase.cpp \
|
||||
packer.cpp \
|
||||
tesselator.cpp \
|
||||
|
||||
HEADERS += \
|
||||
rect2d.hpp \
|
||||
|
|
@ -30,5 +29,4 @@ HEADERS += \
|
|||
transformations.hpp \
|
||||
tree4d.hpp \
|
||||
polygon.hpp \
|
||||
region2d.hpp \
|
||||
tesselator.hpp \
|
||||
region2d.hpp \
|
||||
|
|
|
|||
|
|
@ -1,64 +0,0 @@
|
|||
#include "tesselator.hpp"
|
||||
|
||||
#include "../base/assert.hpp"
|
||||
|
||||
#include "../../3party/sgitess/interface.h"
|
||||
|
||||
namespace tesselator
|
||||
{
|
||||
struct AddTessPointF
|
||||
{
|
||||
tess::Tesselator & m_tess;
|
||||
AddTessPointF(tess::Tesselator & tess) : m_tess(tess)
|
||||
{}
|
||||
void operator()(m2::PointD const & p)
|
||||
{
|
||||
m_tess.add(tess::Vertex(p.x, p.y));
|
||||
}
|
||||
};
|
||||
|
||||
void TesselateInterior(points_container const & bound, holes_container const & holes,
|
||||
points_container & triangles)
|
||||
{
|
||||
tess::VectorDispatcher disp;
|
||||
tess::Tesselator tess;
|
||||
tess.setDispatcher(&disp);
|
||||
tess.setWindingRule(tess::WindingOdd);
|
||||
|
||||
tess.beginPolygon();
|
||||
|
||||
tess.beginContour();
|
||||
for_each(bound.begin(), bound.end(), AddTessPointF(tess));
|
||||
tess.endContour();
|
||||
|
||||
for (holes_container::const_iterator it = holes.begin(); it != holes.end(); ++it)
|
||||
{
|
||||
tess.beginContour();
|
||||
for_each(it->begin(), it->end(), AddTessPointF(tess));
|
||||
tess.endContour();
|
||||
}
|
||||
|
||||
tess.endPolygon();
|
||||
|
||||
for (size_t i = 0; i < disp.indices().size(); ++i)
|
||||
{
|
||||
switch (disp.indices()[i].first)
|
||||
{
|
||||
case tess::TrianglesFan:
|
||||
case tess::TrianglesStrip:
|
||||
case tess::LineLoop:
|
||||
ASSERT(0, ("We've got invalid type during teselation:", disp.indices()[i].first));
|
||||
case tess::TrianglesList: break;
|
||||
}
|
||||
|
||||
for (size_t j = 0; j < disp.indices()[i].second.size(); ++j)
|
||||
{
|
||||
int const idx = disp.indices()[i].second[j];
|
||||
tess::Vertex const & v = disp.vertices()[idx];
|
||||
triangles.push_back(m2::PointD(v.x, v.y));
|
||||
}
|
||||
|
||||
ASSERT_EQUAL(triangles.size() % 3, 0, ());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
#pragma once
|
||||
|
||||
#include "point2d.hpp"
|
||||
|
||||
#include "../std/list.hpp"
|
||||
|
||||
namespace tesselator
|
||||
{
|
||||
typedef vector<m2::PointD> points_container;
|
||||
typedef list<points_container> holes_container;
|
||||
void TesselateInterior(points_container const & bound, holes_container const & holes,
|
||||
points_container & triangles);
|
||||
}
|
||||
|
|
@ -868,7 +868,7 @@ uint32_t FeatureType::ParseTriangles(int scale) const
|
|||
ReaderSource<FileReader> src(
|
||||
m_cont->GetReader(feature::GetTagForIndex(TRIANGLE_FILE_TAG, ind)));
|
||||
src.Skip(m_trgOffsets[ind]);
|
||||
feature::LoadTriangles(m_Triangles, m_base, src);
|
||||
serial::LoadOuterTriangles(src, m_base, m_Triangles);
|
||||
|
||||
sz = static_cast<uint32_t>(src.Pos() - m_trgOffsets[ind]);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,9 @@
|
|||
|
||||
#include "../std/algorithm.hpp"
|
||||
#include "../std/iterator.hpp"
|
||||
#include "../std/stack.hpp"
|
||||
|
||||
#include "../base/start_mem_debug.hpp"
|
||||
|
||||
|
||||
namespace serial
|
||||
|
|
@ -35,9 +38,9 @@ namespace serial
|
|||
}
|
||||
}
|
||||
|
||||
void Encode(EncodeFunT fn, vector<m2::PointD> const & points, int64_t base, vector<uint64_t> & deltas)
|
||||
void Encode(EncodeFunT fn, vector<m2::PointD> const & points, int64_t base, DeltasT & deltas)
|
||||
{
|
||||
vector<m2::PointU> upoints;
|
||||
PointsT upoints;
|
||||
upoints.reserve(points.size());
|
||||
|
||||
transform(points.begin(), points.end(), back_inserter(upoints), &pts::D2U);
|
||||
|
|
@ -45,20 +48,20 @@ namespace serial
|
|||
(*fn)(upoints, pts::GetBasePoint(base), pts::GetMaxPoint(), deltas);
|
||||
}
|
||||
|
||||
void Decode(DecodeFunT fn, vector<uint64_t> const & deltas, int64_t base, OutPointsT & points)
|
||||
void Decode(DecodeFunT fn, DeltasT const & deltas, int64_t base, OutPointsT & points)
|
||||
{
|
||||
vector<m2::PointU> upoints;
|
||||
PointsT upoints;
|
||||
upoints.reserve(deltas.size());
|
||||
|
||||
(*fn)(deltas, pts::GetBasePoint(base), pts::GetMaxPoint(), upoints);
|
||||
|
||||
points.reserve(upoints.size());
|
||||
// Don't make reserve for points. It may be not empty.
|
||||
transform(upoints.begin(), upoints.end(), back_inserter(points), &pts::U2D);
|
||||
}
|
||||
|
||||
void const * LoadInner(DecodeFunT fn, void const * pBeg, size_t count, int64_t base, OutPointsT & points)
|
||||
{
|
||||
vector<uint64_t> deltas;
|
||||
DeltasT deltas;
|
||||
deltas.reserve(count);
|
||||
void const * ret = ReadVarUint64Array(static_cast<char const *>(pBeg), count,
|
||||
MakeBackInsertFunctor(deltas));
|
||||
|
|
@ -66,4 +69,162 @@ namespace serial
|
|||
Decode(fn, deltas, base, points);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
TrianglesChainSaver::TrianglesChainSaver(int64_t base)
|
||||
{
|
||||
m_base = pts::GetBasePoint(base);
|
||||
m_max = pts::GetMaxPoint();
|
||||
}
|
||||
|
||||
namespace
|
||||
{
|
||||
struct edge_less_p0
|
||||
{
|
||||
typedef tesselator::Edge edge_t;
|
||||
|
||||
bool operator() (edge_t const & e1, edge_t const & e2) const
|
||||
{
|
||||
return (e1.m_p[0] == e2.m_p[0]) ? (e1.m_side < e2.m_side) : (e1.m_p[0] < e2.m_p[0]);
|
||||
}
|
||||
bool operator() (edge_t const & e1, int e2) const
|
||||
{
|
||||
return e1.m_p[0] < e2;
|
||||
}
|
||||
bool operator() (int e1, edge_t const & e2) const
|
||||
{
|
||||
return e1 < e2.m_p[0];
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
void TrianglesChainSaver::operator() (PointT arr[3], vector<EdgeT> edges)
|
||||
{
|
||||
m_buffers.push_back(BufferT());
|
||||
MemWriter<BufferT> writer(m_buffers.back());
|
||||
|
||||
WriteVarUint(writer, EncodeDelta(arr[0], m_base));
|
||||
WriteVarUint(writer, EncodeDelta(arr[1], arr[0]));
|
||||
|
||||
EdgeT curr = edges.front();
|
||||
curr.m_delta = EncodeDelta(arr[2], arr[1]);
|
||||
|
||||
sort(edges.begin(), edges.end(), edge_less_p0());
|
||||
|
||||
stack<EdgeT> st;
|
||||
while (true)
|
||||
{
|
||||
CHECK_EQUAL ( curr.m_delta >> 62, 0, () );
|
||||
uint64_t delta = curr.m_delta << 2;
|
||||
|
||||
// find next edges
|
||||
int const nextNode = curr.m_p[1];
|
||||
vector<EdgeT>::iterator i = lower_bound(edges.begin(), edges.end(), nextNode, edge_less_p0());
|
||||
bool const found = (i != edges.end() && i->m_p[0] == nextNode);
|
||||
if (found)
|
||||
{
|
||||
// fill 2 tree-struct bites
|
||||
ASSERT_NOT_EQUAL(i->m_side, -1, ());
|
||||
|
||||
// first child
|
||||
delta |= (1 << i->m_side);
|
||||
|
||||
vector<EdgeT>::iterator j = i+1;
|
||||
if (j != edges.end() && j->m_p[0] == nextNode)
|
||||
{
|
||||
// second child
|
||||
ASSERT_EQUAL(i->m_side, 0, ());
|
||||
ASSERT_EQUAL(j->m_side, 1, ());
|
||||
|
||||
delta |= (1 << j->m_side);
|
||||
|
||||
// push to stack for further processing
|
||||
st.push(*j);
|
||||
}
|
||||
|
||||
curr = *i;
|
||||
}
|
||||
|
||||
// write delta for current element
|
||||
WriteVarUint(writer, delta);
|
||||
|
||||
if (!found)
|
||||
{
|
||||
// end of chain - pop current from stack or exit
|
||||
if (st.empty())
|
||||
break;
|
||||
else
|
||||
{
|
||||
curr = st.top();
|
||||
st.pop();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void DecodeTriangles(DeltasT const & deltas,
|
||||
m2::PointU const & basePoint,
|
||||
m2::PointU const & maxPoint,
|
||||
PointsT & points)
|
||||
{
|
||||
size_t const count = deltas.size();
|
||||
ASSERT_GREATER ( count, 2, () );
|
||||
|
||||
points.reserve(3*count);
|
||||
|
||||
points.push_back(DecodeDelta(deltas[0], basePoint));
|
||||
points.push_back(DecodeDelta(deltas[1], points.back()));
|
||||
points.push_back(DecodeDelta(deltas[2] >> 2, points.back()));
|
||||
|
||||
stack<size_t> st;
|
||||
|
||||
size_t ind = 2;
|
||||
uint8_t treeBits = deltas[2] & 3;
|
||||
|
||||
for (size_t i = 3; i < count;)
|
||||
{
|
||||
size_t trg[3];
|
||||
|
||||
if (treeBits & 1)
|
||||
{
|
||||
// common edge is 1->2
|
||||
trg[0] = ind;
|
||||
trg[1] = ind-1;
|
||||
trg[2] = ind-2;
|
||||
|
||||
// push to stack for further processing
|
||||
if (treeBits & 2)
|
||||
st.push(ind);
|
||||
}
|
||||
else if (treeBits & 2)
|
||||
{
|
||||
// common edge is 2->0
|
||||
trg[0] = ind-2;
|
||||
trg[1] = ind;
|
||||
trg[2] = ind-1;
|
||||
}
|
||||
else
|
||||
{
|
||||
// end of chain - pop current from stack
|
||||
ASSERT ( !st.empty(), () );
|
||||
ind = st.top();
|
||||
st.pop();
|
||||
treeBits = 2;
|
||||
continue;
|
||||
}
|
||||
|
||||
// push points
|
||||
points.push_back(points[trg[0]]);
|
||||
points.push_back(points[trg[1]]);
|
||||
points.push_back( DecodeDelta(deltas[i] >> 2,
|
||||
PredictPointInTriangle(maxPoint, points[trg[0]], points[trg[1]], points[trg[2]])));
|
||||
|
||||
// next step
|
||||
treeBits = deltas[i] & 3;
|
||||
ind = points.size() - 1;
|
||||
++i;
|
||||
}
|
||||
|
||||
ASSERT ( treeBits == 0 && st.empty(), () );
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,12 +1,17 @@
|
|||
#pragma once
|
||||
|
||||
#include "geometry_coding.hpp"
|
||||
#include "tesselator_decl.hpp"
|
||||
|
||||
#include "../geometry/point2d.hpp"
|
||||
|
||||
#include "../coding/reader.hpp"
|
||||
#include "../coding/writer.hpp"
|
||||
#include "../coding/varint.hpp"
|
||||
|
||||
#include "../std/algorithm.hpp"
|
||||
#include "../std/bind.hpp"
|
||||
|
||||
#include "../base/buffer_vector.hpp"
|
||||
#include "../base/stl_add.hpp"
|
||||
|
||||
|
|
@ -20,35 +25,46 @@ namespace serial
|
|||
WriteVarUint(sink, v[i]);
|
||||
}
|
||||
|
||||
typedef void (*EncodeFunT)(vector<m2::PointU> const &, m2::PointU const &, m2::PointU const &, vector<uint64_t> &);
|
||||
typedef void (*DecodeFunT)(vector<uint64_t> const &, m2::PointU const &, m2::PointU const &, vector<m2::PointU> &);
|
||||
namespace pts { m2::PointU D2U(m2::PointD const & p); }
|
||||
|
||||
void Encode(EncodeFunT fn, vector<m2::PointD> const & points, int64_t base, vector<uint64_t> & deltas);
|
||||
typedef vector<m2::PointU> PointsT;
|
||||
typedef vector<uint64_t> DeltasT;
|
||||
|
||||
typedef void (*EncodeFunT)(PointsT const &, m2::PointU const &, m2::PointU const &, DeltasT &);
|
||||
typedef void (*DecodeFunT)(DeltasT const &, m2::PointU const &, m2::PointU const &, PointsT &);
|
||||
|
||||
void Encode(EncodeFunT fn, vector<m2::PointD> const & points, int64_t base, DeltasT & deltas);
|
||||
|
||||
typedef buffer_vector<m2::PointD, 32> OutPointsT;
|
||||
void Decode(DecodeFunT fn, vector<uint64_t> const & deltas, int64_t base, OutPointsT & points);
|
||||
void Decode(DecodeFunT fn, DeltasT const & deltas, int64_t base, OutPointsT & points);
|
||||
|
||||
template <class TSink>
|
||||
void SaveInner(EncodeFunT fn, vector<m2::PointD> const & points, int64_t base, TSink & sink)
|
||||
{
|
||||
vector<uint64_t> deltas;
|
||||
DeltasT deltas;
|
||||
Encode(fn, points, base, deltas);
|
||||
WriteVarUintArray(deltas, sink);
|
||||
}
|
||||
|
||||
template <class TSink>
|
||||
void WriteBufferToSink(vector<char> const & buffer, TSink & sink)
|
||||
{
|
||||
uint32_t const count = buffer.size();
|
||||
WriteVarUint(sink, count);
|
||||
sink.Write(&buffer[0], count);
|
||||
}
|
||||
|
||||
template <class TSink>
|
||||
void SaveOuter(EncodeFunT fn, vector<m2::PointD> const & points, int64_t base, TSink & sink)
|
||||
{
|
||||
vector<uint64_t> deltas;
|
||||
DeltasT deltas;
|
||||
Encode(fn, points, base, deltas);
|
||||
|
||||
vector<char> buffer;
|
||||
MemWriter<vector<char> > writer(buffer);
|
||||
WriteVarUintArray(deltas, writer);
|
||||
|
||||
uint32_t const count = buffer.size();
|
||||
WriteVarUint(sink, count);
|
||||
sink.Write(&buffer[0], count);
|
||||
WriteBufferToSink(buffer, sink);
|
||||
}
|
||||
|
||||
void const * LoadInner(DecodeFunT fn, void const * pBeg, size_t count, int64_t base, OutPointsT & points);
|
||||
|
|
@ -61,10 +77,11 @@ namespace serial
|
|||
char * p = &buffer[0];
|
||||
src.Read(p, count);
|
||||
|
||||
vector<uint64_t> deltas;
|
||||
DeltasT deltas;
|
||||
deltas.reserve(count / 2);
|
||||
ReadVarUint64Array(p, p + count, MakeBackInsertFunctor(deltas));
|
||||
|
||||
points.reserve(deltas.size());
|
||||
Decode(fn, deltas, base, points);
|
||||
}
|
||||
|
||||
|
|
@ -106,5 +123,47 @@ namespace serial
|
|||
{
|
||||
return LoadInner(&geo_coding::DecodeTriangleStrip, pBeg, count, base, points);
|
||||
}
|
||||
|
||||
class TrianglesChainSaver
|
||||
{
|
||||
typedef m2::PointU PointT;
|
||||
typedef tesselator::Edge EdgeT;
|
||||
typedef vector<char> BufferT;
|
||||
|
||||
PointT m_base, m_max;
|
||||
|
||||
list<BufferT> m_buffers;
|
||||
|
||||
public:
|
||||
TrianglesChainSaver(int64_t base);
|
||||
|
||||
PointT GetBasePoint() const { return m_base; }
|
||||
PointT GetMaxPoint() const { return m_max; }
|
||||
|
||||
void operator() (PointT arr[3], vector<EdgeT> edges);
|
||||
|
||||
template <class TSink> void Save(TSink & sink)
|
||||
{
|
||||
size_t const count = m_buffers.size();
|
||||
CHECK_LESS(count, 256, ());
|
||||
WriteToSink(sink, static_cast<uint8_t>(count));
|
||||
|
||||
for_each(m_buffers.begin(), m_buffers.end(), bind(&WriteBufferToSink<TSink>, _1, ref(sink)));
|
||||
}
|
||||
};
|
||||
|
||||
void DecodeTriangles(DeltasT const & deltas,
|
||||
m2::PointU const & basePoint,
|
||||
m2::PointU const & maxPoint,
|
||||
PointsT & triangles);
|
||||
|
||||
template <class TSource>
|
||||
void LoadOuterTriangles(TSource & src, int64_t base, OutPointsT & triangles)
|
||||
{
|
||||
int const count = ReadPrimitiveFromSource<uint8_t>(src);
|
||||
|
||||
for (int i = 0; i < count; ++i)
|
||||
LoadOuter(&DecodeTriangles, src, base, triangles);
|
||||
}
|
||||
//@}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,22 +3,12 @@
|
|||
TARGET = indexer
|
||||
TEMPLATE = lib
|
||||
CONFIG += staticlib
|
||||
#!macx:DEFINES += COMPILED_FROM_DSP # needed for Expat
|
||||
#macx:DEFINES += HAVE_MEMMOVE # needed for Expat
|
||||
|
||||
ROOT_DIR = ..
|
||||
DEPENDENCIES = geometry coding base expat
|
||||
|
||||
include($$ROOT_DIR/common.pri)
|
||||
|
||||
!iphonesimulator-g++42 {
|
||||
!iphonedevice-g++42 {
|
||||
!bada-simulator {
|
||||
PRE_TARGETDEPS += $$BINARIES_PATH/$${LIB_PREFIX}sgitess$$LIB_EXT
|
||||
LIBS += -lsgitess
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SOURCES += \
|
||||
osm2type.cpp \
|
||||
|
|
@ -39,7 +29,8 @@ SOURCES += \
|
|||
data_header.cpp \
|
||||
data_header_reader.cpp \
|
||||
geometry_coding.cpp \
|
||||
geometry_serialization.cpp
|
||||
geometry_serialization.cpp \
|
||||
tesselator.cpp \
|
||||
|
||||
HEADERS += \
|
||||
feature.hpp \
|
||||
|
|
@ -71,5 +62,7 @@ HEADERS += \
|
|||
tree_structure.hpp \
|
||||
feature_impl.hpp \
|
||||
geometry_coding.hpp \
|
||||
geometry_serialization.hpp \
|
||||
point_to_int64.hpp
|
||||
geometry_serialization.hpp \
|
||||
point_to_int64.hpp \
|
||||
tesselator.hpp \
|
||||
tesselator_decl.hpp \
|
||||
|
|
|
|||
|
|
@ -37,5 +37,5 @@ SOURCES += \
|
|||
data_header_test.cpp \
|
||||
feature_bucketer_test.cpp \
|
||||
feature_routine.cpp \
|
||||
geometry_coding_test.cpp
|
||||
|
||||
geometry_coding_test.cpp \
|
||||
triangles_tree_coding_test.cpp
|
||||
|
|
|
|||
85
indexer/indexer_tests/triangles_tree_coding_test.cpp
Normal file
85
indexer/indexer_tests/triangles_tree_coding_test.cpp
Normal file
|
|
@ -0,0 +1,85 @@
|
|||
#include "../tesselator.hpp"
|
||||
#include "../geometry_serialization.hpp"
|
||||
#include "../mercator.hpp"
|
||||
|
||||
#include "../../coding/reader.hpp"
|
||||
#include "../../coding/writer.hpp"
|
||||
|
||||
#include "../../testing/testing.hpp"
|
||||
|
||||
|
||||
namespace
|
||||
{
|
||||
typedef m2::PointD P;
|
||||
|
||||
bool is_equal(P const & p1, P const & p2)
|
||||
{
|
||||
return p1.EqualDxDy(p2, MercatorBounds::GetCellID2PointAbsEpsilon());
|
||||
}
|
||||
|
||||
bool FindTriangle(serial::OutPointsT const & test, P arr[])
|
||||
{
|
||||
size_t const count = test.size();
|
||||
for (size_t i = 0; i < count; i+=3)
|
||||
{
|
||||
for (int base = 0; base < 3; ++base)
|
||||
if (is_equal(test[i], arr[base]) &&
|
||||
is_equal(test[i+1], arr[(base+1)%3]) &&
|
||||
is_equal(test[i+2], arr[(base+2)%3]))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void CompareTriangles(serial::OutPointsT const & test,
|
||||
P arrP[], uintptr_t arrT[][3], size_t count)
|
||||
{
|
||||
TEST_EQUAL(test.size(), 3*count, (test));
|
||||
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
{
|
||||
P trg[] = { arrP[arrT[i][0]], arrP[arrT[i][1]], arrP[arrT[i][2]] };
|
||||
TEST ( FindTriangle(test, trg), ("Triangles : ", test, " Etalon : ", trg[0], trg[1], trg[2]) );
|
||||
}
|
||||
}
|
||||
|
||||
void TestTrianglesCoding(P arrP[], size_t countP, uintptr_t arrT[][3], size_t countT)
|
||||
{
|
||||
tesselator::TrianglesInfo info;
|
||||
info.AssignPoints(arrP, arrP + countP);
|
||||
|
||||
info.Reserve(countT);
|
||||
|
||||
for (size_t i = 0; i < countT; ++i)
|
||||
info.Add(arrT[i]);
|
||||
|
||||
serial::TrianglesChainSaver saver(0);
|
||||
info.ProcessPortions(saver.GetBasePoint(), saver.GetMaxPoint(), &serial::pts::D2U, saver);
|
||||
|
||||
vector<char> buffer;
|
||||
MemWriter<vector<char> > writer(buffer);
|
||||
saver.Save(writer);
|
||||
|
||||
TEST ( !buffer.empty(), () );
|
||||
|
||||
MemReader reader(&buffer[0], buffer.size());
|
||||
ReaderSource<MemReader> src(reader);
|
||||
|
||||
serial::OutPointsT triangles;
|
||||
serial::LoadOuterTriangles(src, 0, triangles);
|
||||
|
||||
CompareTriangles(triangles, arrP, arrT, countT);
|
||||
}
|
||||
}
|
||||
|
||||
UNIT_TEST(TrianglesCoding_Smoke)
|
||||
{
|
||||
{
|
||||
P arrP[] = { P(0, 0), P(0, 1), P(1, 0), P(1, 1), P(0, -1), P(-1, 0) };
|
||||
uintptr_t arrT[][3] = { {0, 1, 2}, {1, 3, 2}, {4, 0, 2}, {1, 0, 5}, {4, 5, 0} };
|
||||
|
||||
TestTrianglesCoding(arrP, ARRAY_SIZE(arrP), arrT, ARRAY_SIZE(arrT));
|
||||
}
|
||||
}
|
||||
|
|
@ -7,11 +7,10 @@
|
|||
#include "../../indexer/feature_processor.hpp"
|
||||
#include "../../indexer/feature_visibility.hpp"
|
||||
#include "../../indexer/feature_impl.hpp"
|
||||
#include "../../indexer/cell_id.hpp"
|
||||
#include "../../indexer/geometry_serialization.hpp"
|
||||
#include "../../indexer/tesselator.hpp"
|
||||
|
||||
#include "../../geometry/polygon.hpp"
|
||||
#include "../../geometry/tesselator.hpp"
|
||||
|
||||
#include "../../platform/platform.hpp"
|
||||
|
||||
|
|
@ -135,6 +134,10 @@ namespace feature
|
|||
m_writer.Finish();
|
||||
}
|
||||
|
||||
private:
|
||||
typedef vector<m2::PointD> points_t;
|
||||
typedef list<points_t> holes_t;
|
||||
|
||||
class GeometryHolder
|
||||
{
|
||||
public:
|
||||
|
|
@ -144,8 +147,6 @@ namespace feature
|
|||
FeaturesCollector2 & m_rMain;
|
||||
FeatureBuilder2 & m_rFB;
|
||||
|
||||
typedef vector<m2::PointD> points_t;
|
||||
|
||||
points_t m_current;
|
||||
|
||||
int64_t m_base;
|
||||
|
|
@ -157,11 +158,21 @@ namespace feature
|
|||
serial::SaveOuterPath(points, m_base, *m_rMain.m_geoFile[i]);
|
||||
}
|
||||
|
||||
void WriteOuterTriangles(points_t const & triangles, int i)
|
||||
void WriteOuterTriangles(points_t const & bound, holes_t const & holes, int i)
|
||||
{
|
||||
m_buffer.m_trgMask |= (1 << i);
|
||||
m_buffer.m_trgOffset.push_back(m_rMain.GetFileSize(*m_rMain.m_trgFile[i]));
|
||||
feature::SaveTriangles(triangles, m_base, *m_rMain.m_trgFile[i]);
|
||||
|
||||
// tesselation
|
||||
tesselator::TrianglesInfo info;
|
||||
tesselator::TesselateInterior(bound, holes, info);
|
||||
|
||||
// triangles processing
|
||||
serial::TrianglesChainSaver saver(m_base);
|
||||
info.ProcessPortions(saver.GetBasePoint(), saver.GetMaxPoint(), &serial::pts::D2U, saver);
|
||||
|
||||
// saving to file
|
||||
saver.Save(*m_rMain.m_trgFile[i]);
|
||||
}
|
||||
|
||||
void FillInnerPointsMask(points_t const & points, uint32_t scaleIndex)
|
||||
|
|
@ -279,15 +290,16 @@ namespace feature
|
|||
return true;
|
||||
}
|
||||
|
||||
void AddTriangles(points_t const & triangles, int scaleIndex)
|
||||
void AddTriangles(points_t const & bound, holes_t const & holes, int scaleIndex)
|
||||
{
|
||||
ASSERT ( m_buffer.m_innerTrg.empty(), () );
|
||||
m_trgInner = false;
|
||||
|
||||
WriteOuterTriangles(triangles, scaleIndex);
|
||||
WriteOuterTriangles(bound, holes, scaleIndex);
|
||||
}
|
||||
};
|
||||
|
||||
public:
|
||||
void operator() (FeatureBuilder2 & fb)
|
||||
{
|
||||
(void)GetFileSize(m_datFile);
|
||||
|
|
@ -302,7 +314,7 @@ namespace feature
|
|||
if (fb.IsDrawableInRange(i > 0 ? g_arrScales[i-1] + 1 : 0, g_arrScales[i]))
|
||||
{
|
||||
// simplify and serialize geometry
|
||||
tesselator::points_container points;
|
||||
points_t points;
|
||||
SimplifyPoints(holder.GetSourcePoints(), points, g_arrScales[i]);
|
||||
|
||||
if (isLine)
|
||||
|
|
@ -312,15 +324,15 @@ namespace feature
|
|||
{
|
||||
// simplify and serialize triangles
|
||||
|
||||
tesselator::holes_container const & holes = fb.GetHoles();
|
||||
holes_t const & holes = fb.GetHoles();
|
||||
|
||||
if (holes.empty() && holder.TryToMakeStrip(points))
|
||||
continue;
|
||||
|
||||
tesselator::holes_container simpleHoles;
|
||||
for (tesselator::holes_container::const_iterator iH = holes.begin(); iH != holes.end(); ++iH)
|
||||
holes_t simpleHoles;
|
||||
for (holes_t::const_iterator iH = holes.begin(); iH != holes.end(); ++iH)
|
||||
{
|
||||
simpleHoles.push_back(tesselator::points_container());
|
||||
simpleHoles.push_back(points_t());
|
||||
|
||||
SimplifyPoints(*iH, simpleHoles.back(), g_arrScales[i]);
|
||||
|
||||
|
|
@ -328,11 +340,7 @@ namespace feature
|
|||
simpleHoles.pop_back();
|
||||
}
|
||||
|
||||
tesselator::points_container triangles;
|
||||
tesselator::TesselateInterior(points, simpleHoles, triangles);
|
||||
|
||||
if (!triangles.empty())
|
||||
holder.AddTriangles(triangles, i);
|
||||
holder.AddTriangles(points, simpleHoles, i);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
231
indexer/tesselator.cpp
Normal file
231
indexer/tesselator.cpp
Normal file
|
|
@ -0,0 +1,231 @@
|
|||
#include "tesselator.hpp"
|
||||
#include "geometry_coding.hpp"
|
||||
|
||||
#include "../base/assert.hpp"
|
||||
#include "../base/logging.hpp"
|
||||
|
||||
#include "../std/queue.hpp"
|
||||
|
||||
#include "../../3party/sgitess/interface.h"
|
||||
|
||||
#include "../base/start_mem_debug.hpp"
|
||||
|
||||
|
||||
namespace tesselator
|
||||
{
|
||||
struct AddTessPointF
|
||||
{
|
||||
tess::Tesselator & m_tess;
|
||||
AddTessPointF(tess::Tesselator & tess) : m_tess(tess)
|
||||
{}
|
||||
void operator()(m2::PointD const & p)
|
||||
{
|
||||
m_tess.add(tess::Vertex(p.x, p.y));
|
||||
}
|
||||
};
|
||||
|
||||
void TesselateInterior(PointsT const & bound, HolesT const & holes, TrianglesInfo & info)
|
||||
{
|
||||
tess::VectorDispatcher disp;
|
||||
tess::Tesselator tess;
|
||||
tess.setDispatcher(&disp);
|
||||
tess.setWindingRule(tess::WindingOdd);
|
||||
|
||||
tess.beginPolygon();
|
||||
|
||||
tess.beginContour();
|
||||
for_each(bound.begin(), bound.end(), AddTessPointF(tess));
|
||||
tess.endContour();
|
||||
|
||||
for (HolesT::const_iterator it = holes.begin(); it != holes.end(); ++it)
|
||||
{
|
||||
tess.beginContour();
|
||||
for_each(it->begin(), it->end(), AddTessPointF(tess));
|
||||
tess.endContour();
|
||||
}
|
||||
|
||||
tess.endPolygon();
|
||||
|
||||
// assign points
|
||||
vector<tess::Vertex> const & vert = disp.vertices();
|
||||
info.AssignPoints(vert.begin(), vert.end());
|
||||
|
||||
for (size_t i = 0; i < disp.indices().size(); ++i)
|
||||
{
|
||||
if (disp.indices()[i].first != tess::TrianglesList)
|
||||
{
|
||||
LOG(LERROR, ("We've got invalid type during teselation:", disp.indices()[i].first));
|
||||
continue;
|
||||
}
|
||||
|
||||
vector<uintptr_t> const & indices = disp.indices()[i].second;
|
||||
size_t const count = indices.size();
|
||||
ASSERT_GREATER(count, 0, ());
|
||||
ASSERT_EQUAL(count % 3, 0, ());
|
||||
|
||||
info.Reserve(count / 3);
|
||||
for (size_t j = 0; j < count; j += 3)
|
||||
{
|
||||
ASSERT_LESS ( j+2, count, () );
|
||||
info.Add(&indices[j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// TrianglesInfo::ListInfo implementation
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
int TrianglesInfo::ListInfo::empty_key = -1;
|
||||
|
||||
void TrianglesInfo::ListInfo::AddNeighbour(int p1, int p2, int trg)
|
||||
{
|
||||
// find or insert element for key
|
||||
pair<neighbours_t::iterator, bool> ret = m_neighbours.insert(make_pair(make_pair(p1, p2), trg));
|
||||
|
||||
// triangles should not duplicate
|
||||
CHECK ( ret.second, ("Duplicating triangles for indices : ", p1, p2) );
|
||||
}
|
||||
|
||||
void TrianglesInfo::ListInfo::Add(uintptr_t const * arr)
|
||||
{
|
||||
int arr32[] = { arr[0], arr[1], arr[2] };
|
||||
m_triangles.push_back(Triangle(arr32));
|
||||
|
||||
size_t const trg = m_triangles.size()-1;
|
||||
for (int i = 0; i < 3; ++i)
|
||||
AddNeighbour(arr32[i], arr32[(i+1)%3], trg);
|
||||
}
|
||||
|
||||
/// Find best (cheap in serialization) start edge for processing.
|
||||
TrianglesInfo::ListInfo::iter_t
|
||||
TrianglesInfo::ListInfo::FindStartTriangle() const
|
||||
{
|
||||
for (iter_t i = m_neighbours.begin(); i != m_neighbours.end(); ++i)
|
||||
{
|
||||
if (m_neighbours.find(make_pair(i->first.second, i->first.first)) == m_neighbours.end())
|
||||
return i;
|
||||
}
|
||||
|
||||
ASSERT ( false, ("?WTF? There is no border triangles!") );
|
||||
return m_neighbours.end();
|
||||
}
|
||||
|
||||
/// Return indexes of common edges of [to, from] triangles.
|
||||
pair<int, int> CommonEdge(Triangle const & to, Triangle const & from)
|
||||
{
|
||||
for (int i = 0; i < 3; ++i)
|
||||
{
|
||||
for (int j = 0; j < 3; ++j)
|
||||
{
|
||||
if (to.m_p[i] == from.m_p[my::NextModN(j, 3)] && to.m_p[my::NextModN(i, 3)] == from.m_p[j])
|
||||
return make_pair(i, j);
|
||||
}
|
||||
}
|
||||
|
||||
ASSERT ( false, ("?WTF? Triangles not neighbours!") );
|
||||
return make_pair(-1, -1);
|
||||
}
|
||||
|
||||
/// Get neighbours of 'trg' triangle, wich was riched from 'from' triangle.
|
||||
/// @param[out] nb Neighbours indexes of 'trg' if 0->1 is common edge with'from':
|
||||
/// - nb[0] - by 1->2 edge;
|
||||
/// - nb[1] - by 2->0 edge;
|
||||
void TrianglesInfo::ListInfo::GetNeighbours(
|
||||
Triangle const & trg, Triangle const & from, int * nb) const
|
||||
{
|
||||
int i = my::NextModN(CommonEdge(trg, from).first, 3);
|
||||
int j = my::NextModN(i, 3);
|
||||
|
||||
int ind = 0;
|
||||
iter_t it = m_neighbours.find(make_pair(trg.m_p[j], trg.m_p[i]));
|
||||
nb[ind++] = (it != m_neighbours.end()) ? it->second : empty_key;
|
||||
|
||||
it = m_neighbours.find(make_pair(trg.m_p[my::NextModN(j, 3)], trg.m_p[j]));
|
||||
nb[ind++] = (it != m_neighbours.end()) ? it->second : empty_key;
|
||||
}
|
||||
|
||||
/// Calc delta of 'from'->'to' graph edge.
|
||||
uint64_t TrianglesInfo::ListInfo::CalcDelta(
|
||||
PointsInfo const & points, Triangle const & from, Triangle const & to) const
|
||||
{
|
||||
pair<int, int> const p = CommonEdge(to, from);
|
||||
|
||||
m2::PointU const prediction =
|
||||
PredictPointInTriangle(points.m_max,
|
||||
// common edge with 'to'
|
||||
points.m_points[from.m_p[(p.second+1) % 3]],
|
||||
points.m_points[from.m_p[(p.second)]],
|
||||
// diagonal point of 'from'
|
||||
points.m_points[from.m_p[(p.second+2) % 3]]);
|
||||
|
||||
// delta from prediction to diagonal point of 'to'
|
||||
return EncodeDelta(points.m_points[to.m_p[(p.first+2) % 3]], prediction);
|
||||
}
|
||||
|
||||
// Element with less m_delta is better than another one.
|
||||
struct edge_greater_delta
|
||||
{
|
||||
bool operator() (Edge const & e1, Edge const & e2) const
|
||||
{
|
||||
return (e1.m_delta > e2.m_delta);
|
||||
}
|
||||
};
|
||||
|
||||
void TrianglesInfo::ListInfo::MakeTrianglesChain(
|
||||
PointsInfo const & points, iter_t start, vector<Edge> & chain) const
|
||||
{
|
||||
Triangle const fictive(start->first.second, start->first.first, -1);
|
||||
|
||||
priority_queue<Edge, vector<Edge>, edge_greater_delta> q;
|
||||
q.push(Edge(-1, start->second, 0.0, -1));
|
||||
|
||||
// marks of visited nodes
|
||||
vector<bool> visited;
|
||||
visited.resize(m_triangles.size());
|
||||
|
||||
while (!q.empty())
|
||||
{
|
||||
// pop current element
|
||||
Edge e = q.top();
|
||||
q.pop();
|
||||
|
||||
// check if already processed
|
||||
if (visited[e.m_p[1]])
|
||||
continue;
|
||||
visited[e.m_p[1]] = true;
|
||||
|
||||
// push to chain
|
||||
chain.push_back(e);
|
||||
|
||||
Triangle const & trg = m_triangles[e.m_p[1]];
|
||||
|
||||
// get neighbours
|
||||
int nb[2];
|
||||
GetNeighbours(trg, (e.m_p[0] == -1) ? fictive : m_triangles[e.m_p[0]], nb);
|
||||
|
||||
// push neighbours to queue
|
||||
for (int i = 0; i < 2; ++i)
|
||||
if (nb[i] != empty_key && !visited[nb[i]])
|
||||
q.push(Edge(e.m_p[1], nb[i], CalcDelta(points, trg, m_triangles[nb[i]]), i));
|
||||
}
|
||||
}
|
||||
|
||||
void TrianglesInfo::Add(uintptr_t const * arr)
|
||||
{
|
||||
m2::PointD arrP[] = { m_points[arr[0]], m_points[arr[1]], m_points[arr[2]] };
|
||||
double const cp = m2::CrossProduct(arrP[1] - arrP[0], arrP[2] - arrP[1]);
|
||||
|
||||
if (fabs(cp) > 1.0E-4)
|
||||
{
|
||||
bool const isCCW = (cp > 0.0);
|
||||
|
||||
if (m_isCCW == 0)
|
||||
m_isCCW = (isCCW ? 1 : -1);
|
||||
else
|
||||
CHECK_EQUAL ( m_isCCW == 1, isCCW, () );
|
||||
}
|
||||
|
||||
m_triangles.back().Add(arr);
|
||||
}
|
||||
}
|
||||
153
indexer/tesselator.hpp
Normal file
153
indexer/tesselator.hpp
Normal file
|
|
@ -0,0 +1,153 @@
|
|||
#pragma once
|
||||
#include "tesselator_decl.hpp"
|
||||
|
||||
#include "../geometry/point2d.hpp"
|
||||
|
||||
#include "../std/list.hpp"
|
||||
#include "../std/vector.hpp"
|
||||
#include "../std/unordered_map.hpp"
|
||||
#include "../std/iterator.hpp"
|
||||
|
||||
|
||||
namespace tesselator
|
||||
{
|
||||
typedef vector<m2::PointD> PointsT;
|
||||
typedef list<PointsT> HolesT;
|
||||
|
||||
struct Triangle
|
||||
{
|
||||
int m_p[3];
|
||||
|
||||
Triangle(int p0, int p1, int p2)
|
||||
{
|
||||
m_p[0] = p0;
|
||||
m_p[1] = p1;
|
||||
m_p[2] = p2;
|
||||
}
|
||||
|
||||
Triangle(int const * p)
|
||||
{
|
||||
for (int i = 0; i < 3; ++i)
|
||||
m_p[i] = p[i];
|
||||
}
|
||||
|
||||
int GetPoint3(pair<int, int> const & p) const
|
||||
{
|
||||
for (int i = 0; i < 3; ++i)
|
||||
if (m_p[i] != p.first && m_p[i] != p.second)
|
||||
return m_p[i];
|
||||
|
||||
ASSERT ( false, ("Triangle with equal points") );
|
||||
return -1;
|
||||
}
|
||||
};
|
||||
|
||||
// Converted points, prepared for serialization.
|
||||
struct PointsInfo
|
||||
{
|
||||
typedef m2::PointU PointT;
|
||||
vector<PointT> m_points;
|
||||
PointT m_base, m_max;
|
||||
|
||||
PointsInfo(PointT const & baseP, PointT const & maxP)
|
||||
: m_base(baseP), m_max(maxP)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
class TrianglesInfo
|
||||
{
|
||||
PointsT m_points;
|
||||
|
||||
class ListInfo
|
||||
{
|
||||
static int empty_key;
|
||||
|
||||
vector<Triangle> m_triangles;
|
||||
|
||||
// directed edge -> triangle
|
||||
typedef unordered_map<pair<int, int>, int> neighbours_t;
|
||||
neighbours_t m_neighbours;
|
||||
|
||||
void AddNeighbour(int p1, int p2, int trg);
|
||||
|
||||
void GetNeighbours(
|
||||
Triangle const & trg, Triangle const & from, int * nb) const;
|
||||
|
||||
uint64_t CalcDelta(
|
||||
PointsInfo const & points, Triangle const & from, Triangle const & to) const;
|
||||
|
||||
public:
|
||||
typedef neighbours_t::const_iterator iter_t;
|
||||
|
||||
ListInfo(size_t count)
|
||||
{
|
||||
m_triangles.reserve(count);
|
||||
}
|
||||
|
||||
void Add(uintptr_t const * arr);
|
||||
|
||||
iter_t FindStartTriangle() const;
|
||||
|
||||
void MakeTrianglesChain(PointsInfo const & points, iter_t start, vector<Edge> & chain) const;
|
||||
|
||||
Triangle GetTriangle(int i) const { return m_triangles[i]; }
|
||||
};
|
||||
|
||||
list<ListInfo> m_triangles;
|
||||
|
||||
int m_isCCW; // 0 - uninitialized; -1 - false; 1 - true
|
||||
|
||||
public:
|
||||
TrianglesInfo() : m_isCCW(0) {}
|
||||
|
||||
/// @name Making functions.
|
||||
//@{
|
||||
template <class IterT> void AssignPoints(IterT b, IterT e)
|
||||
{
|
||||
m_points.reserve(distance(b, e));
|
||||
while (b != e)
|
||||
{
|
||||
m_points.push_back(m2::PointD(b->x, b->y));
|
||||
++b;
|
||||
}
|
||||
}
|
||||
|
||||
void Reserve(size_t count) { m_triangles.push_back(ListInfo(count)); }
|
||||
|
||||
void Add(uintptr_t const * arr);
|
||||
//@{
|
||||
|
||||
/// Triangles chains processing function.
|
||||
template <class EmitterT>
|
||||
void ProcessPortions(m2::PointU const & baseP, m2::PointU const & maxP,
|
||||
m2::PointU (*convert) (m2::PointD const &), EmitterT & emitter)
|
||||
{
|
||||
// convert points from double to uint
|
||||
size_t const count = m_points.size();
|
||||
PointsInfo points(baseP, maxP);
|
||||
points.m_points.reserve(count);
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
points.m_points.push_back((*convert)(m_points[i]));
|
||||
|
||||
// process portions and push out result chains
|
||||
vector<Edge> chain;
|
||||
for (list<ListInfo>::const_iterator i = m_triangles.begin(); i != m_triangles.end(); ++i)
|
||||
{
|
||||
chain.clear();
|
||||
typename ListInfo::iter_t start = i->FindStartTriangle();
|
||||
i->MakeTrianglesChain(points, start, chain);
|
||||
|
||||
Triangle const trg = i->GetTriangle(start->second);
|
||||
m2::PointU arr[] = { points.m_points[start->first.first],
|
||||
points.m_points[start->first.second],
|
||||
points.m_points[trg.GetPoint3(start->first)] };
|
||||
|
||||
emitter(arr, chain);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/// Main tesselate function.
|
||||
void TesselateInterior(PointsT const & bound, HolesT const & holes, TrianglesInfo & info);
|
||||
}
|
||||
26
indexer/tesselator_decl.hpp
Normal file
26
indexer/tesselator_decl.hpp
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
#pragma once
|
||||
|
||||
#include "../base/assert.hpp"
|
||||
|
||||
namespace tesselator
|
||||
{
|
||||
// Edge of graph, builded from triangles list.
|
||||
struct Edge
|
||||
{
|
||||
int m_p[2]; // indexes of connected triangles (0 -> 1)
|
||||
uint64_t m_delta; // delta of 1 - triangle from 0 - triangle
|
||||
|
||||
// intersected rib of 0 - triangle:
|
||||
// - -1 - uninitialized or root edge
|
||||
// - 0 - this edge intersects 1-2 rib;
|
||||
// - 1 - this edge intersects 2-0 rib;
|
||||
char m_side;
|
||||
|
||||
Edge(int from, int to, uint64_t delta, char side)
|
||||
: m_delta(delta), m_side(side)
|
||||
{
|
||||
m_p[0] = from;
|
||||
m_p[1] = to;
|
||||
}
|
||||
};
|
||||
}
|
||||
Loading…
Add table
Reference in a new issue