Scribd
Upload
52 views15 pages

Mesh Data Structures: Denis Zorin

The document discusses different types of mesh data structures used to represent 3D meshes in computer graphics. It covers manifold and non-manifold meshes, common mesh queries and modifications, and popular data structures like winged-edge and half-edge to efficiently represent mesh connectivity and support basic operations.

Uploaded by

Shah Mahmood
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
52 views15 pages

Mesh Data Structures: Denis Zorin

The document discusses different types of mesh data structures used to represent 3D meshes in computer graphics. It covers manifold and non-manifold meshes, common mesh queries and modifications, and popular data structures like winged-edge and half-edge to efficiently represent mesh connectivity and support basic operations.

Uploaded by

Shah Mahmood
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 15

Mesh data structures

Denis Zorin
Types of meshes
ƒ Most general: polygon soup; polygons may
have arbitrary number of vertices, vertices
and edges can be shared by arbitrary
polygons.
ƒ Manifold polygonal meshes
the union of all faces adjacent to a vertex
can be continously deformed to a disk
ƒ Orientable: orientation on faces can be
chosen consistently
ƒ Triangular meshes: all faces are triangles
Types of meshes
Manifold
ƒ Common assumption for many algorithms
ƒ For a given vertex v, adjacent faces Fi can be
ordered so that their vertices ≠ v form a
simple chain, i.e. no 2 vertices coincide and
two sequential are connected by an edge
ƒ Each edge is shared by no more than 2 faces;
Types of meshes
Nonmanifold features

three faces sharing an edge


outer vertices do not form a
simple chain
Types of meshes
Manifold property is commonly required, but
available meshes often violate it;
ƒ Solution: convert nonmanifold meshes to
manifold by splitting along edges and vertices
ƒ Increases mesh-parsing code complexity
ƒ Arbitrary polygonal meshes often converted to
triangular
Basic mesh queries
The choice of the data structure is
determined by the elementary operations
that have to be supported efficiently
ƒ Simplest choice for a triangle mesh: list of
vertex x,y,z coordinates, list of triples of vertex
indices i1,i2,i3 for each triangle
ƒ Finding two faces adjacent to an edge
requires traversing the whole triangle list
Basic mesh queries
Adjacency:
ƒ FV all vertices of a face
ƒ EV both vertices of an edge
ƒ VF all faces sharing a vertex
ƒ EF all faces sharing an edge
ƒ FE all edges of a face
ƒ VE all edges sharing a vertex
For a list-of-triangles representation, only
FV, EV, FE are efficient
Mesh modification
ƒ Add/remove face, edge or vertex
ƒ Split face or edge

To keep the mesh manifold (or triangular),


operations need to be performed in a
consistent way;
e.g. an edge split requires one or two face
splits in a triangular mesh
Mesh data structures
Typical requirement: constant storage per data
structure
ƒ For manifold meshes, only the number of faces per
edge and vertices per edge requires constant
storage;
ƒ Most popular data structures for storing adjacency
information are edge-based
ƒ Face-based are also used for triangular meshes
(vertices and edges per face are constant)
Winged-edge
struct Edge {
headleft headright
Edge *headleft,*headright,
*tailleft,*tailright; verthead
Face *faceleft,*faceright;
Vertex *verthead, *verttail;
// edge data
}; faceleft faceright
struct Face {
Edge* edge;
// face data
}; verttail
struct Vertex {
Edge* edge; tailleft tailright
// vertex data
red arrows indicate pointers
};
Winged-edge
6-8 pointers per edge E Pointer storage for a
ƒ 4 to next/previous edges in regular triangular grid:
two faces sharing E
ƒ 2 to faces (if information # faces ~ 2 #vertices
is stored in faces)
# edges ~ 3#vertices
ƒ 2 to vertices (if information
is stored in vertices) If #vertices = N
Vertices and faces store ~27*N pointers need to
a single pointer to an edge be stored
Winged-edge
Trivial: EF, EV VE (all edges sharing a vertex,
FE (all edges of a face) interior vertices)
e0 = f->edge; e = e0; e0 = v-> edge; e = e0;
do { do {
if(e->faceleft== v) if(e->verthead == v)
e = edge->headleft; e = edge->headright;
else else
e = edge->tailright; e = edge->tailleft;
} while (e != e0); } while (e != e0);

FV and VF are similar


Half-edge
Split each winged-edge data structure into 2;
ƒ advantage: FE, VE traversals do not require
“ifs” in code, consistent orientation
he1.head he2.tail
headleft headright he1.verthead
verthead

he1.face he2.face
faceleft faceright

verttail
he2.verthead
tailleft tailright he1.tail he2.head
Half-edge
HalfEdge { VE (all edges sharing a
HalfEdge* head, *tail; vertex, interior vertices)
// tail pointer is optional e0 = v->halfedge; e0 = e;
HalfEdge* opposite; do {
Face* face; e = e->opposite->head;
Vertex* verthead; } while ( e!= e0);
};
Both traversals do not
FE (all edges of a face) require if’s
e0 = f->halfedge; e0 = e;
do { e = e->head; }
while (e != e0);
Face-based data structure
Primarily for triangle Face {
meshes Face*nbr[3];
Vertex* vert[3];
}

6 pointers per triangle


1 per vertex, no edge
records
(3/2*6+1)*N = 10*N vs.
27N for winged-edge

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy