网格的数据结构

tf
... ... ...
v n−1
combinatorial information
Half-edge data structure: polygonal (orientable) meshes
8 6 5 9
3
7 0
e
11 4 2 10
1
f + 5 × h + n ≈ 2n + 5 × (2e) + n = 32n + n
e e.next.opposite e.next.opposite.next
vertex(e)
next(e)
opposite(e) e
prev (e)
Half-edge data structure: polygonal manifold meshes
vertex(e)
next(e)
opposite(e) e
prev (e)
can we represent them?
yes
Triangle based DS: for triangle meshes
class Point{ float x; float y; float z; } class Triangle{ Triangle t1, t2, t3; Vertex v1, v2, v3; } class Vertex{ Triangle root; Point p; }
geometric information
(x0 , y0 , z0 ) (x1 , y1 , z1 ) ... ...
class Vertex{ Point p; } class Face{ Vertex[] vertices; }
Queries/Operations
List all vertices or faces Test adjacency between u and v Find the 3 neighboring faces of f List the neighbors of vertex v
3
7 0
f
11 4 2 10 1
faces
class Point{ double x; double y; }
vertex locations
v0 v1 v2 v3
Memory cost 3 × f = 6n
Size (number of references)
t0 t1 t2 t3 t4 t5
v1 v3 . . . v3 v1 v2 v2 v3 . . . ... ... ...
Mesh representations and data structures
Luca Castelli Aleardi
Shared vertex representation Half-edge DS Winged edge Triangle based DS Corner Table
Shared vertex representation
prev (e)
Half-edge data structure: efficient traversal
e e.next e.next.opposite
vertex(e)
next(e)
opposite(e) e
prev (e)
Half-edge data structure: efficient traversal
connectivity
q
p
we can locate a point, by performing a walk in the triangulation
int degree(int v) { int d = 1; int f = face(v); int g = neighbor(f , cw(vertexIndex(v, f ))); while (g ! = f ) { int next = neighbor(g, cw(faceIndex(f , g))); int i = faceIndex(g, next); g = next; d + +; } return d; }
connectivity
t0 t1 t2 t5 v2 t1 v1 t0 t 2 v3 v0 t2 t3 t4 t5
T
. . . . . . . . . v1 v3 . . . t5 t2 t0 v3 v1 v2 v2 v3 . . . ... ... ... ... ... ... ... ... ...
v n−1
Triangle based DS: mesh traversal operators
class Point{ float x; float y; float z; } class Triangle{ Triangle t1, t2, t3; Vertex v1, v2, v3; } class Vertex{ Triangle root; Point p; }
Size (number of references)
class Point{ double x; double y; }
geometric information
class Halfedge{ Halfedge prev, next, opposite; Vertex v; Face f; } class Vertex{ Halfedge e; Point p; } class Face{ Halfedge e; }
Size (number of references)
class Point{ double x; double y; }
geometric information
class Halfedge{ Halfedge prev, next, opposite; Vertex v; Face f; } class Vertex{ Halfedge e; Point p; } class Face{ Halfedge e; }
vertex(e)
next(e)
opposite(e) e
combinatorial information
Half-edge data structure: efficient traversal
e = v.halfedge v
e.next
vertex(e)
next(e)
opposite(e) e
vertex(e)
next(e)
opposite(e) e
f ace(e) prev (e)
combinatorial information
Half-edge data structure: polygonal (orientable) meshes
8 6 5 9
3
7 0
e
11 4 2 10
1
3 × h + n ≈ 3 × (2e) + n = 18n + n
the data structure supports the following operators
int cw(int i) {return (i + 2)%3; } v = vertex( , i) int ccw(int i) {return (i + 1)%3; } = face(v ) v i = vertexIndex(v, ) z g0 = neighbor( , i) i g2 g1 g1 = neighbor( , ccw(i)) g2 = neighbor( , cw(i)) i+2 i+1 z = vertex(g2 , faceIndex(g2 , )) g0
we can turn around a vertex, by combining the operators above
Triangle based DS: mesh update operators
class Point{ float x; float y; float z; } class Triangle{ Triangle t1, t2, t3; Vertex v1, v2, v3; } class Vertex{ Triangle root; Point p; }
all these operators can be performed in O(1) time
g2 e g1 g1
edgeFlip(e)
g2
(used in CGAL)
for each triangle, store: • 3 references to neighboring faces • 3 references to incident vertices for each vertex, store: • 1 reference to an incident face
the data structure supports the following operators
connectivity
removeVertex(v ) splitFace(f ) edgeFlip(e)
removeVertex(v ) g0 splitFace(re is modifiable
8 6 5 9
easy to implement quite compact not efficient for traversal for each face (of degree d), store: • d references to incident vertices for each vertex, store: • 1 reference to its coordinates
v0 v1 v2 v3
V
t2 (x0 , y0 , z0 ) . . . (x1 , y1 , z1 ) ... ... ... ...