24 |
|
|
25 |
#include <SurfaceMeshOfTriangles.hpp> |
#include <SurfaceMeshOfTriangles.hpp> |
26 |
|
|
27 |
|
#include <map> |
28 |
|
#include <set> |
29 |
|
#include <list> |
30 |
|
|
31 |
|
struct MeshSimplifier::Internals |
32 |
|
{ |
33 |
|
|
34 |
|
struct ltv |
35 |
|
{ |
36 |
|
bool operator() (const Edge::Pair& e1, const Edge::Pair& e2) const |
37 |
|
{ |
38 |
|
if (e1.first == e2.first) { |
39 |
|
return (e1.second < e2.second); |
40 |
|
} else { |
41 |
|
return (e1.first < e2.first); |
42 |
|
} |
43 |
|
} |
44 |
|
}; |
45 |
|
|
46 |
|
struct eq |
47 |
|
{ |
48 |
|
bool operator() (const Edge::Pair& e1, const Edge::Pair& e2) const |
49 |
|
{ |
50 |
|
return ((e1.first == e2.first) and (e1.second == e2.second)); |
51 |
|
} |
52 |
|
}; |
53 |
|
}; |
54 |
|
|
55 |
template <typename MeshType> |
template <typename MeshType> |
56 |
void MeshSimplifier::__proceed(const MeshType& m) |
void MeshSimplifier::__proceed(const MeshType& givenMesh) |
57 |
{ |
{ |
58 |
typedef typename MeshType::ElementsGeometry ElementType; |
typedef typename MeshType::ElementsGeometry ElementType; |
59 |
|
|
60 |
Connectivity<ElementType> connectivity(m.numberOfCells()); |
ReferenceCounting<VerticesSet> vertices |
61 |
|
= new VerticesSet(givenMesh.numberOfVertices()); |
62 |
|
for (size_t i=0; i<givenMesh.numberOfVertices(); ++i) { |
63 |
|
(*vertices)[i] = givenMesh.vertex(i); |
64 |
|
} |
65 |
|
|
66 |
Vector<size_t> references(m.numberOfCells()); |
typedef std::set<ElementType*> IntermediateCells; |
67 |
references = 0; |
IntermediateCells intermediateCells; |
68 |
|
|
69 |
std::set<size_t> toRemove; /**< This element is to remove */ |
for (size_t i=0; i<givenMesh.numberOfCells(); ++i) { |
70 |
|
const ElementType& C = givenMesh.cell(i); |
71 |
|
intermediateCells.insert(new Triangle((*vertices)[givenMesh.vertexNumber(C(0))], |
72 |
|
(*vertices)[givenMesh.vertexNumber(C(1))], |
73 |
|
(*vertices)[givenMesh.vertexNumber(C(2))])); |
74 |
|
} |
75 |
|
|
76 |
ConnectivityBuilder<MeshType> connectivityBuilder(m, connectivity); |
/// This defines associations of edges to elements |
77 |
for (size_t i=0; i<m.numberOfCells(); ++i) { |
typedef std::map<Edge::Pair, std::list<ElementType*>, MeshSimplifier::Internals::ltv > EdgeElements; |
78 |
for (size_t j=0; j<ElementType::NumberOfNeighbours; ++j) { |
EdgeElements edgeElements; |
79 |
if (m.cell(i).volume() < 0.2* (*connectivity(i)[j]).volume()) { |
|
80 |
references[i] = 1; |
/// This defines associations of vertices to edges |
81 |
toRemove.insert(i); |
typedef std::map<size_t, std::set<Edge::Pair> > VertexEdges; |
82 |
} |
VertexEdges vertexEdges; |
83 |
|
|
84 |
|
for (typename IntermediateCells::iterator i = intermediateCells.begin(); |
85 |
|
i != intermediateCells.end(); ++i) { |
86 |
|
for (size_t j=0; j<ElementType::NumberOfEdges; ++j) { |
87 |
|
Edge e = (*(*i)).edge(j); |
88 |
|
(edgeElements[e]).push_back(*i); |
89 |
} |
} |
90 |
} |
} |
91 |
|
|
92 |
ReferenceCounting<VerticesSet> vertices |
for(typename EdgeElements::iterator i = edgeElements.begin(); |
93 |
= new VerticesSet(m.numberOfVertices()); |
i != edgeElements.end(); ++i) { |
94 |
for (size_t i=0; i<m.numberOfVertices(); ++i) { |
vertexEdges[(*vertices).number(*((*i).first).first) ].insert((*i).first); |
95 |
(*vertices)[i] = m.vertex(i); |
vertexEdges[(*vertices).number(*((*i).first).second)].insert((*i).first); |
96 |
|
} |
97 |
|
|
98 |
|
const size_t numberOfEdges = edgeElements.size(); |
99 |
|
|
100 |
|
typedef std::map<real_t, Edge::Pair> EdgeSizes; |
101 |
|
EdgeSizes edgeSizes; |
102 |
|
|
103 |
|
real_t maxSize = 0.; |
104 |
|
for(typename EdgeElements::iterator i = edgeElements.begin(); |
105 |
|
i != edgeElements.end(); ++i) { |
106 |
|
const Edge::Pair& e = (*i).first; |
107 |
|
const real_t norm = Norm(e.first->Vector3()-e.second->Vector3()); |
108 |
|
edgeSizes[norm] = (*i).first; |
109 |
|
maxSize = std::max(norm, maxSize); |
110 |
|
} |
111 |
|
|
112 |
|
|
113 |
|
// Edge collapsing |
114 |
|
for (typename EdgeSizes::iterator i = edgeSizes.begin(); |
115 |
|
(*i).first < 0.25*maxSize; ++i) { |
116 |
|
TinyVector<ElementType::NumberOfVertices, const Vertex*> newVertices; |
117 |
|
|
118 |
|
const Vertex* v0 = ((*i).second).first; |
119 |
|
const Vertex* v1 = ((*i).second).second; |
120 |
|
|
121 |
|
for (size_t n=0; n<ElementType::NumberOfVertices; ++n) { |
122 |
|
// WRITE COLLAPSING ELEMENTS HERE. |
123 |
|
} |
124 |
|
|
125 |
|
size_t v0Number = (*vertices).number(*v0); |
126 |
|
|
127 |
|
for(typename std::list<ElementType*>::iterator |
128 |
|
j = edgeElements[(*i).second].begin(); |
129 |
|
j != edgeElements[(*i).second].end(); ++j) { |
130 |
|
intermediateCells.erase(*j); |
131 |
|
} |
132 |
} |
} |
133 |
|
|
134 |
ReferenceCounting<Vector<ElementType> > cells |
ReferenceCounting<Vector<ElementType> > cells |
135 |
= new Vector<ElementType>(m.numberOfCells()); |
= new Vector<ElementType>(intermediateCells.size()); |
136 |
|
|
137 |
for (size_t i=0; i<m.numberOfCells(); ++i) { |
size_t n=0; |
138 |
const ElementType& C = m.cell(i); |
for (typename IntermediateCells::iterator i = intermediateCells.begin(); |
139 |
(*cells)(i) = Triangle((*vertices)[m.vertexNumber(C(0))], |
i != intermediateCells.end(); ++i) { |
140 |
(*vertices)[m.vertexNumber(C(1))], |
const ElementType& C = (*(*i)); |
141 |
(*vertices)[m.vertexNumber(C(2))], |
(*cells)(n) = Triangle((*vertices)[(*vertices).number(C(0))], |
142 |
references[i]); |
(*vertices)[(*vertices).number(C(1))], |
143 |
|
(*vertices)[(*vertices).number(C(2))]); |
144 |
|
n++; |
145 |
} |
} |
146 |
|
|
147 |
__mesh = new MeshType(vertices, cells); |
__mesh = new MeshType(vertices, cells); |