Polygonal Meshes: Representing 3D Objects

Transcription

1 Polygonal Meshes: Representing 3D Objects Real world modeling requires representation of surfaces Two situations: 1. Model an existing object Most likely can only approximate the object Represent all (most) of the actual points Approximate using surfaces/shapes patched together Can be scanned in or approximated by modeler 2. From scratch Should be able to model exactly Define mathematically Create interactively Concern is surface modeling as opposed to solid modeling One approach is to use a polygonal mesh Set of connected, polygonally bounded planar surfaces Approximate curved surfaces Following addresses representation and creation 1

2 Polygonal Meshes: Intro Polygonal mesh is a set of Edges Vertices Polygons connected so that each edge is shared by at most 2 polygons Every edge must be part of a polygon Every vertex must be shared by at least 2 edges Several representations can be used to represent meshes A single mesh can involve several representations Representations compared wrt space/time tradeoff for the following operations: Find edges connected to a given vertex Find polygons incident on a given vertex Find vertices that define a given edge Find edges of a given polygon Display a mesh Id representation errors; e.g., All polygons are closed All edges used at least once Each polygon is planar Mesh completely connected Mesh has no holes 2

3 Polygonal Meshes: Intro (2) 3 general approaches to representing polygonal meshes: 1. Explicit 2. Using vertex lists 3. Using edge lists 3

4 Polygonal Meshes: Explicit Representation Represent polygons as list of vertices Listed in order of traversal Last connected to first Advantages 1. Space efficient for single polygon 2. Conceptually simple Disadvantages 1. Space inefficient for mesh Vertices represented multiple times 2. No explicit representation of shared edges and vertices 3. Not efficient wrt clipping and transformation 4. Shared edges drawn 2 times 4

5 OpenGL example: Polygonal Meshes: Explicit Representation (2) void createmesh () { glcolor3f (0.0, 0.0, 0.0); glvertex3i(10, 15, -3); glvertex3i(14, 16, -2); glvertex3i(12, 16, -6); glvertex3i(14, 16, -2); glvertex3i(17, 16, -6); glvertex3i(12, 16, -6); glvertex3i(14, 16, -2); glvertex3i(19, 14, -4); glvertex3i(17, 16, -6); glvertex3i(19, 14, -4); glvertex3i(20, 16, -5); glvertex3i(17, 16, -6); glvertex3i(12, 16, -6); glvertex3i(15, 19, -9); glvertex3i(8, 18, -8); glvertex3i(12, 16, -6); glvertex3i(17, 16, -6); glvertex3i(15, 19, -9); glvertex3i(17, 16, -6); glvertex3i(19, 17, -10); glvertex3i(15, 19, -9); glvertex3i(17, 16, -6); glvertex3i(20, 16, -5); glvertex3i(19, 17, -10); glvertex3i(8, 18, -8); glvertex3i(15, 19, -9); glvertex3i(12, 16, -13); glvertex3i(15, 19, -9); glvertex3i(16, 17, -12); glvertex3i(12, 16, -13); glvertex3i(15, 19, -9); glvertex3i(19, 17, -10); glvertex3i(16, 17, -12); glvertex3i(19, 17, -10); glvertex3i(20, 15, -14); glvertex3i(16, 17, -12); } 5

6 Polygonal Meshes: Vertex List Representation Represent polygons as list of pointers into vertex list Vertex list stores each vertex exactly once Advantages 1. More efficient use of memory 2. Easy to modify mesh Disadvantages 1. Difficult to find polygons that share an edge 2. Shared edges drawn twice 6

7 Polygonal Meshes: Vertex List Representation (2) OpenGL example (explicit programmer control): static int vertexarray[12][3] = {{10, 15, -3}, {14, 16, -2}, {19, 14, -4}, {12, 16, -6}, {17, 16, -6}, {20, 16, -5}, {8, 18, -8}, {15, 19, -9}, {19, 17, -10}, {12, 16, -13}, {16, 17, -12}, {20, 15, -14}}; void createmesh () { glcolor3f (0.0, 0.0, 0.0); glvertex3iv(vertexarray[0]); glvertex3iv(vertexarray[1]); glvertex3iv(vertexarray[3]); glvertex3iv(vertexarray[1]); glvertex3iv(vertexarray[4]); glvertex3iv(vertexarray[3]); glvertex3iv(vertexarray[1]); glvertex3iv(vertexarray[2]); glvertex3iv(vertexarray[4]); glvertex3iv(vertexarray[2]); glvertex3iv(vertexarray[5]); glvertex3iv(vertexarray[4]); glvertex3iv(vertexarray[3]); glvertex3iv(vertexarray[7]); glvertex3iv(vertexarray[6]); glvertex3iv(vertexarray[3]); glvertex3iv(vertexarray[4]); glvertex3iv(vertexarray[7]); glvertex3iv(vertexarray[4]); glvertex3iv(vertexarray[8]); glvertex3iv(vertexarray[7]); glvertex3iv(vertexarray[4]); glvertex3iv(vertexarray[5]); glvertex3iv(vertexarray[8]); glvertex3iv(vertexarray[6]); glvertex3iv(vertexarray[7]); glvertex3iv(vertexarray[9]); glvertex3iv(vertexarray[7]); glvertex3iv(vertexarray[10]); glvertex3iv(vertexarray[9]); glvertex3iv(vertexarray[7]); glvertex3iv(vertexarray[8]); glvertex3iv(vertexarray[10]); glvertex3iv(vertexarray[8]); glvertex3iv(vertexarray[11]); glvertex3iv(vertexarray[10]); } 7

8 Polygonal Meshes: OpenGL Vertex Arrays - Vertex List Representation (3) OpenGL example (using OpenGL vertex arrays): static int vertexarray[] = {10, 15, -3, 14, 16, -2, 19, 14, -4, 12, 16, -6, 17, 16, -6, 20, 16, -5, 8, 18, -8, 15, 19, -9, 19, 17, -10, 12, 16, -13, 16, 17, -12, 20, 15, -14}; static unsigned int indices[] = {0, 1, 3, 1, 4, 3, 1, 2, 4, 2, 5, 4, 3, 7, 6, 3, 4, 7, 4, 8, 7, 4, 5, 8, 6, 7, 9, 7, 10, 9, 7, 8, 10, 8, 11, 10}; void createmesh () { glcolor3f (0.0, 0.0, 0.0); gldrawelements(gl_triangles, 36, GL_UNSIGNED_INT, indices); } void display (void) {... glpolygonmode(gl_front_and_back, GL_LINE); glenableclientstate(gl_vertex_array); glvertexpointer(3, GL_INT, 0, vertexarray); createmesh(); glflush (); } 8

9 Polygonal Meshes: Edge List Representation Represent polygons as list of edges and vertices Edge list has pointers to vertex list and to polygon list Polygon list has pointers to edge list For example Polygon represented as (E 0, E 1,..., E n ) Vertex list as (V 0, V 1,..., V n ) Edge as (V i, V j, P m, P n ) Mesh displayed by drawing edges, not polygons Advantages 1. Most efficient approach wrt clipping, transformations, etc. 2. Easily extended to situations where edges shared by n polygons 3. Accommodates error checking 4. Edges drawn only once Disadvantages 1. Not easy to find edges incident on a vertex OpenGL example: 9

10 Polygonal Meshes: Edge List Representation (2) //Global declarations and definitions struct edge { int *v1; int *v2; struct edge *p1; struct edge *p2; }; int v1[3] = {10, 15, -3}; int v2[3] = {14, 16, -2}; int v3[3] = {19, 14, -4}; int v4[3] = {12, 16, -6}; int v5[3] = {17, 16, -6}; int v6[3] = {20, 16, -5}; int v7[3] = {8, 18, -8}; int v8[3] = {15, 19, -9}; int v9[3] = {19, 17, -10}; int v10[3] = {12, 16, -13}; int v11[3] = {16, 17, -12}; int v12[3] = {20, 15, -14}; //Polygons struct edge p1[3], p2[3], p3[3], p4[3], p5[3], p6[3], p7[3], p8[3], p9[3], p10[3], p11[3], p12[3]; //edges struct edge e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23; //edge list struct edge *edgelist[23] = {&e1, &e2, &e3, &e4, &e5, &e6, &e7, &e8, &e9, &e10, &e11, &e12, &e13, &e14, &e15, &e16, &e17, &e18, &e19, &e20, &e21, &e22, &e23}; 10

11 Polygonal Meshes: Edge List Representation (3) void initmesh (void) { e1.v1 = &v1[0]; e1.v2 = &v2[0]; e1.p1 = &p1[0]; e1.p2 = 0; e2.v1 = &v2[0]; e2.v2 = &v3[0]; e2.p1 = &p2[0]; e2.p2 = 0; e3.v1 = &v1[0]; e3.v2 = &v4[0]; e3.p1 = &p1[0]; e3.p2 = 0; e4.v1 = &v2[0]; e4.v2 = &v4[0]; e4.p1 = &p1[0]; e4.p2 = &p2[0]; e5.v1 = &v2[0]; e5.v2 = &v5[0]; e5.p1 = &p2[0]; e5.p2 = &p3[0]; e6.v1 = &v3[0]; e6.v2 = &v5[0]; e6.p1 = &p3[0]; e6.p2 = &p4[0]; e7.v1 = &v3[0]; e7.v2 = &v6[0]; e7.p1 = &p4[0]; e7.p2 = 0; e8.v1 = &v4[0]; e8.v2 = &v5[0]; e8.p1 = &p2[0]; e8.p2 = &p6[0]; e9.v1 = &v5[0]; e9.v2 = &v6[0]; e9.p1 = &p4[0]; e9.p2 = &p8[0]; e10.v1 = &v4[0]; e10.v2 = &v7[0]; e10.p1 = &p5[0]; e10.p2 = 0; e11.v1 = &v4[0]; e11.v2 = &v8[0]; e11.p1 = &p5[0]; e11.p2 = &p6[0]; e12.v1 = &v5[0]; e12.v2 = &v8[0]; e12.p1 = &p6[0]; e12.p2 = &p7[0]; e13.v1 = &v5[0]; e13.v2 = &v9[0]; e13.p1 = &p7[0]; e13.p2 = &p8[0]; e14.v1 = &v6[0]; e14.v2 = &v9[0]; e14.p1 = &p8[0]; e14.p2 = 0; e15.v1 = &v7[0]; e15.v2 = &v8[0]; e15.p1 = &p5[0]; e15.p2 = &p9[0]; e16.v1 = &v8[0]; e16.v2 = &v9[0]; e16.p1 = &p7[0]; e16.p2 = &p11[0]; e17.v1 = &v7[0]; e17.v2 = &v10[0]; e17.p1 = &p5[0]; e17.p2 = &p9[0]; e18.v1 = &v8[0]; e18.v2 = &v10[0]; e18.p1 = &p9[0]; e18.p2 = &p10[0]; e19.v1 = &v8[0]; e19.v2 = &v11[0]; e19.p1 = &p10[0]; e19.p2 = &p11[0]; e20.v1 = &v9[0]; e20.v2 = &v11[0]; e20.p1 = &p11[0]; e20.p2 = &p12[0]; e21.v1 = &v9[0]; e21.v2 = &v12[0]; e21.p1 = &p12[0]; e21.p2 = 0; e22.v1 = &v10[0]; e22.v2 = &v11[0]; e22.p1 = &p10[0]; e22.p2 = 0; e23.v1 = &v11[0]; e23.v2 = &v12[0]; e23.p1 = &p12[0]; e23.p2 = 0; } p1[0] = e1; p1[1] = e4; p1[2] = e3; p2[0] = e5; p2[1] = e8; p2[2] = e4; p3[0] = e2; p3[1] = e6; p3[2] = e5; p4[0] = e6; p4[1] = e7; p4[2] = e5; p5[0] = e11; p5[1] = e15; p5[2] = e10; p6[0] = e8; p6[1] = e12; p6[2] = e11; p7[0] = e13; p7[1] = e16; p7[2] = e12; p8[0] = e9; p8[1] = e14; p8[2] = e13; p9[0] = e15; p9[1] = e18; p9[2] = e17; p10[0] = e19; p10[1] = e22; p10[2] = e18; p11[0] = e16; p11[1] = e20; p11[2] = e19; p12[0] = e21; p12[1] = e23; p12[2] = e20; void createmesh (void) { int i; } glcolor3f(0.0, 0.0, 0.0); for (i = 0; i < 23; i++) { glbegin(gl_lines); glvertex3i(edgelist[i]->v1[0], edgelist[i]->v1[1], edgelist[i]->v1[2]); glvertex3i(edgelist[i]->v2[0], edgelist[i]->v2[1], edgelist[i]->v2[2]); } 11

12 Polygonal Meshes: Plane Equations Standard plane equation: Ax + By + Cz + D = 0 Two ways to compute 1. For planar polygons [ A B C ] are x, y, z coefficients of normal to plane Given any 3 points in plane p 1, p 2, p 3 p 1 p 2 p 1 p 3 computes normal Providing non-0 result, find D by solving Ax + By + Cz + D = 0 with new-found values for A, B, C, and one of p 1, p 2, p 3 2. For non-planar polygons Want to find plane that most closely contains points I.e., want plane that minimizes sums of distances of polygon vertices from plane A, B, C are proportional to signed areas of projections of polygon onto y-z, z-x, and x-y planes (respectively) C = 1 2 n i=1 (y i + y i 1 )(x i 1 x i ) where B = 1 2 A = 1 2 n i=1 n i=1 i 1 = (x i x i 1 )(z i 1 z i ) (z i + z i 1 )(y i 1 y i ) i + 1 i < n 1 i = n 12

13 Polygonal Meshes: Plane Equations (2) These equations compute the sum of all trapezoids formed by successive edges of the polygon Once A, B, C, and D determined, calculate distances from vertices to plane using Ax + By + Cz + D A2 + B 2 + C 2 13

14 Polygonal Meshes: Tessellation - Intro Tessellation is the process of subdividing a polygon into subpolygons Motivation: 1. Convert shapes so all polygons are planar Remember: Triangles are always planar; polygons with edges > 3 are not guaranteed to be 2. Generate more detail By creating more vertices (and possibly relocating in 3-space), can increase the detail of a model Cf creating a sphere by recursive subdivision The standard results generated by tessellation are 1. Triangles 2. Quadrilaterals Which ultimately are reduced to a pair of triangles The following addresses triangles only 14

15 Polygonal Meshes: Tessellation - Simple, Convex Polygons Tessellating these is trivial Algorithm: Given: n vertices Select a vertex (any vertex) Call this v 0 Number the remaining vertices in a counterclockwise manner from 1 to n 1 for (i = 1 to n - 2) Create triangle from v 0 to v i to v i+1 The result is a triangle fan 15

16 Polygonal Meshes: Tessellation - Simple Polygons in General There are a number of triangle tessellation algorithms ov various run times This discussion concerns the ear clipping algorithm (O(n 2 )) Basic definitions Convex vertex: One which is at an interior angle < 180 Vertices: v 0, v 1, v 3, v 4, v 5, v 6, v 7 Reflex vertex: One which is at an interior angle > 180 (i.e., concave) Vertices: v 2, v 8 Ear: Given 3 consecutive vertices v i 1, v i, and v i+1 of a polygon P, and v i is convex, an ear of P is a triangle vi 1 v i v i+1 such that the line segment v i 1 v i+1 lies wholly within P, and no other vertices fall within this triangle Ears: triangles centered on vertices v 0, v 3, v 4, v 5, v 6 Not ears: triangles centered on vertices v 1 and v 7 : Diagonal: The line segment v i 1 v i+1 v 8 v 1, v 2 v 4, v 3 v 5, v 4 v 6, v 5 v 7 Ear tip: Vertex v i Vertices: v 0, v 3, v 4, v 5, v 6 16

17 Polygonal Meshes: Tessellation - Simple Polygons in General (2) A triangle consists of a single ear A polygon of 4 vertices consists of 2 non-overlapping ears In general, any polygon with n > 3 vertices consists of at least 2 nonoverlapping ears The general tessellation strategy is to id a polygon s ears, then remove them one by one Each iteration eliminates one vertex (an ear tip), leaving n 1 vertices The process is repeated until n = 3 When an ear tip v i is removed, the category of its adjacent vertices (v i 1 and v i+1 ) may change Convex vertices remain convex An ear tip may no longer be one Reflex vertices may become convex, and may become ear tips The algorithm: Data structures: Polygon vertices stored in a doubly linked circular list Convex vertices stored in a doubly linked linear list Reflex vertices stored in a doubly linked linear list Ear tips stored in a doubly linked circular list Steps: 1. To categorize a vertex as convex or reflex, calculate cross product of v i v i+1 and v i v i 1 Cross product is positive for convex, negative for reflex (and zero for colinear) 17

18 Polygonal Meshes: Tessellation - Simple Polygons in General (3) 2. For each convex vertex v i, determine if it is an ear tip To do this, no other vertices can fall within the triangle T bounded by v i 1, v i, and v i+1 To determine if a vertex P falls within T (a) Calculate v i v i+1 v i v i 1 and save the sign as S (b) For each vertex of the triangle, calculate the following cross products: v i v i+1 v i P v i+1 v i 1 v i+1 P v i 1 v i v i 1 P (c) If any of the signs of these products differs from S, P lies outside the triangle The rationale behind this strategy is that for points within the triangle, the normals of the above cross products will all point in the same direction (I.e., interior points all lie to the left of the triangle s edges, assuming a counterclockwise enumeration) If a point lies outside the triangle, the cross product will point in the opposite direction NOTE: Only reflex vertices must be checked for containment 3. While there are more than three vertices in the convex and reflex lists combined (a) Select an ear tip v i and remove it from the ear list and convex list (b) Add v i 1, v i, and v i+1 to the mesh (c) Remove v i from the ear tip list (d) Re-evaluate the categorization of v i 1 and v i+1 wrt convexity and ear tip membership Reflex vertices must be checked for convexity, and if so must be checked to see if they have become ear tips Convex vertices must be checked to see if they have become ear tips if not so already 4. Add the triangle formed by the final 3 ear tips to the mesh 18

19 Example: Polygonal Meshes: Tessellation - Simple Polygons in General (4) Final result: 19

20 Polygonal Meshes: Issues Polygonal approximations of surfaces not efficient in terms of space They are generally created prior to main program execution (e.g., before a game or animation starts) and reside in memory during execution They are pieced together from planar polygons They can only approximate curved surfaces One could store a minimal mesh and procedurally increase the detail during program execution, but which vertices to move out of the plane and by how much is not obvious procedurally (but simple to do interactively) A better approach would be to represent a surface in terms of curves of higher degree than lines (which is what polygons are defined in terms of) Higher-order curves are not necessarily planar, and - like a line - can be represented in terms of a small number of points from which all the points of the curve can be generated This results in great savings in space (at the expense of the time needed to generate the curve) 20