3D Modeling

1. 3D Modeling

2. Modeling Overview • Modeling is the process of describing an object • Sometimes the description is an end in itself • eg: Computer aided design (CAD), Computer Aided Manufacturing (CAM) • The model is an exact description • More typically in graphics, the model is then used for rendering (we will work on this assumption) • The model only exists to produce a picture • It can be an approximation, as long as the visual result is good • The computer graphics motto: “If it looks right it is right” • Doesn’t work for CAD

3. Issues in Modeling • There are many ways to represent the shape of an object • What are some things to think about when choosing a representation?

4. Choosing a Representation • How well does it represents the objects of interest? • How easy is it to render (or convert to polygons)? • How compact is it (how cheap to store and transmit)? • How easy is it to create? • By hand, procedurally, by fitting to measurements, … • How easy is it to interact with? • Modifying it, animating it • How easy is it to perform geometric computations? • Distance, intersection, normal vectors, curvature, …

5. Categorizing Modeling Techniques • Surface vs. Volume • Sometimes we only care about the surface • Rendering and geometric computations • Sometimes we want to know about the volume • Medical data with information attached to the space • Some representations are best thought of defining the space filled, rather than the surface around the space • Parametric vs. Implicit • Parametric generates all the points on a surface (volume) by “plugging in a parameter” eg (sin cos, sinsin, cos) • Implicit models tell you if a point in on (in) the surface (volume) eg x2 + y2 + z2- 1 = 0

6. Techniques We Will Examine • Polygon meshes • Surface representation, Parametric representation • Prototype instancing and hierarchical modeling • Surface or Volume, Parametric • Volume enumeration schemes • Volume, Parametric or Implicit • Parametric curves and surfaces • Surface, Parametric • Subdivision curves and surfaces • Procedural models

7. Polygon Modeling • Polygons are the dominant force in modeling for real-time graphics • Why?

8. Polygons Dominate • Everything can be turned into polygons (almost everything) • We know how to render polygons quickly • Many operations are easy to do with polygons • Memory and disk space is cheap • Simplicity and inertia

9. What’s Bad About Polygons? • What are some disadvantages of polygonal representations?

10. Polygons Aren’t Great • They are always an approximation to curved surfaces • But can be as good as you want, if you are willing to pay in size • Normal vectors are approximate • They throw away information • Most real-world surfaces are curved, particularly natural surfaces • They can be very unstructured • It is difficult to perform many geometric operations • Results can be unduly complex, for instance

11. Properties of Polygon Meshes • Convex/Concave • Convexity makes many operations easier: • Clipping, intersection, collision detection, rendering, volume computations, … • Closed/Open • Closed if the polygons as a group contain a closed space • Can’t have “dangling edges” or “dangling faces” • Every edge lies between two faces • Closed also referred to as watertight • Simple • Faces intersect each other only at edges and vertices • Edges only intersect at vertices

12. Polygonal Data Structures • There are many ways to store a model made up of polygons • Choice affects ease of particular operations • There is no one best way of doing things, so choice depends on application • There are typically three components to a polygonal model: • The location of the vertices • The connectivity - which vertices make up which faces • Associated data: normals, texture coordinates, plane equations, … • Typically associated with either faces or vertices

13. struct Vertex { float coords[3]; } struct Triangle { struct Vertex verts[3]; } struct Triangle mesh[n]; glBegin(GL_TRIANGLES) for ( i = 0 ; i < n ; i++ ) { glVertex3fv(mesh[i].verts[0]); glVertex3fv(mesh[i].verts[1]); glVertex3fv(mesh[i].verts[2]); } glEnd(); Polygon Soup • Many polygon models are just lists of polygons Important Point: OpenGL, and almost everything else, assumes a constant vertex ordering: clockwise or counter-clockwise. Default, and slightly more standard, is counter-clockwise

14. Polygon Soup Evaluation • What are the advantages? • What are the disadvantages?

15. Polygon Soup Evaluation • What are the advantages? • It’s very simple to read, write, transmit, etc. • A common output format from CAD modelers • The format required for OpenGL • BIG disadvantage: No higher order information • No information about neighbors • No open/closed information • No guarantees on degeneracies

16. Vertex Indirection v0 • There are reasons not to store the vertices explicitly at each polygon • Wastes memory - each vertex repeated many times • Very messy to find neighboring polygons • Difficult to ensure that polygons meet correctly • Solution: Indirection • Put all the vertices in a list • Each face stores the list indices of its vertices • Advantages? Disadvantages? v4 vertices v0 v1 v2 v3 v4 v1 faces 0 2 1 0 1 4 1 2 3 1 3 4 v2 v3

17. Indirection Evaluation • Advantages: • Connectivity information is easier to evaluate because vertex equality is obvious • Saving in storage: • Vertex index might be only 2 bytes, and a vertex is probably 12 bytes • Each vertex gets used at least 3 and generally 4-6 times, but is only stored once • Normals, texture coordinates, colors etc. can all be stored the same way • Disadvantages: • Connectivity information is not explicit

18. struct Vertex { float coords[3]; } struct Triangle { GLuint verts[3]; } struct Mesh { struct Vertex vertices[m]; struct Triangle triangles[n]; } OpenGL and Vertex Indirection Continued…

19. glEnableClientState(GL_VERTEX_ARRAY) glVertexPointer(3, GL_FLOAT, sizeof(struct Vertex), mesh.vertices); glBegin(GL_TRIANGLES) for ( i = 0 ; i < n ; i++ ) { glArrayElement(mesh.triangles[i].verts[0]); glArrayElement(mesh.triangles[i].verts[1]); glArrayElement(mesh.triangles[i].verts[2]); } glEnd(); OpenGL and Vertex Indirection (v1)

20. glEnableClientState(GL_VERTEX_ARRAY) glVertexPointer(3, GL_FLOAT, sizeof(struct Vertex), mesh.vertices); for ( i = 0 ; i < n ; i++ ) glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, mesh.triangles[i].verts); OpenGL and Vertex Indirection (v2) • Minimizes amount of data sent to the renderer • Fewer function calls • Faster! • Another variant restricts the range of indices that can be used - even faster because vertices may be cached • Can even interleave arrays to pack more data in a smaller space

21. Yet More Variants • Many algorithms can take advantage of neighbor information • Faces store pointers to their neighbors • Edges may be explicitly stored • Helpful for: • Building strips and fans for rendering • Collision detection • Mesh decimation (combines faces) • Slicing and chopping • Many other things • Information can be extracted or explicitly saved/loaded

22. Normal Vectors • Normal vectors give information about the true surface shape • Per-Face normals: • One normal vector for each face, stored as part of face • Flat shading • Per-Vertex normals: • A normal specified for every vertex (smooth shading) • Can keep an array of normals analogous to array of vertices • Faces store vertex indices and normal indices separately • Allows for normal sharing independent of vertex sharing

23. A Cube Vertices: (1,1,1) (-1,1,1) (-1,-1,1) (1,-1,1) (1,1,-1) (-1,1,-1) (-1,-1,-1) (1,-1,-1) Normals: (1,0,0) (-1,0,0) (0,1,0) (0,-1,0) (0,0,1) (0,0,-1) Faces ((vert,norm), …): ((0,4),(1,4),(2,4),(3,4)) ((0,0),(3,0),(7,0),(4,0)) ((0,2),(4,2),(5,2),(1,2)) ((2,1),(1,1),(5,1),(6,1)) ((3,3),(2,3),(6,3),(7,3)) ((7,5),(6,5),(5,5),(4,5))

24. Computing Normal Vectors • Many models do not come with normals • Models from laser scans are one example • Per-Face normals are easy to compute: • Get the vectors along two edges, cross them and normalize • For per-vertex normals: • Compute per-face normals • Average normals of faces surrounding vertex • A case where neighbor information is useful • Question of whether to use area-weighted samples • Can define crease angle to avoid smoothing over edges • Do not average if angle between faces is greater than crease angle

25. Storing Other Information • Colors, Texture coordinates and so on can all be treated like vertices or normals • Lighting/Shading coefficients may be per-face or per-object, rarely per vertex • Key idea is sub-structuring: • Faces are sub-structure of objects • Vertices are sub-structure of faces • May have sub-objects • Associate data with appropriate level of substructure

26. Indexed Lists vs. Pointers • Previous example have faces storing indices of vertices • Access a face vertex with: mesh.vertices[mesh.faces[i].vertices[j]] • Lots of address computations • Works with OpenGL’s vertex arrays • Can store pointers directly • Access a face vertex with: *(mesh.faces[i].vertices[j]) • Probably faster because it requires fewer address computations • Easier to write • Doesn’t work directly with OpenGL • Messy to save/load (pointer arithmetic) • Messy to copy (more pointer arithmetic)

27. struct Vertex { float coords[3]; } struct Triangle { struct Vertex *verts[3]; } struct Mesh { struct Vertex vertices[m]; struct Triangle faces[n]; } glBegin(GL_TRIANGLES) for ( i = 0 ; i < n ; i++ ) { glVertex3fv(*(mesh.gaces[i].verts[0])); glVertex3fv(*(mesh.gaces[i].verts[1])); glVertex3fv(*(mesh.gaces[i].verts[2])); } glEnd(); Vertex Pointers

28. Meshes from Scanning • Laser scanners sample 3D positions • One method uses triangulation • Another method uses time of flight • Some take images also for use as textures • Famous example: Scanning the David • Software then takes thousands of points and builds a polygon mesh out of them • Research topics: • Reduce the number of points in the mesh • Reconstruction and re-sampling!

29. Scanning in Action http://www-graphics.stanford.edu/projects/mich/

30. Level Of Detail • There is no point in having more than 1 polygon per pixel • Or a few, if anti-aliasing • Level of detail strategies attempt to balance the resolution of the mesh against the viewing conditions • Must have a way to reduce the complexity of meshes • Must have a way to switch from one mesh to another • An ongoing research topic, made even more important as laser scanning becomes popular • Also called mesh decimation, multi-resolution modeling and other things

31. Level of Detail http://www.cs.unc.edu/~geom/SUCC_MAP/

32. Problems with Polygons • They are inherently an approximation • Things like silhouettes can never be prefect without very large numbers of polygons, and corresponding expense • Normal vectors are not specified everywhere • Interaction is a problem • Dragging points around is time consuming • Maintaining things like smoothness is difficult • Low level information • Eg: Hard to increase, or decrease, the resolution • Hard to extract information like curvature

33. More Object Representations • Parametric instancing • Hierarchical modeling • Constructive Solid Geometry • Sweep Objects • Octrees • Blobs and Metaballs and other such things • Production rules

34. Parametric Instancing • Many things, called primitives, are conveniently described by a label and a few parameters • Cylinder: Radius, length, does it have end-caps, … • Bolts: length, diameter, thread pitch, … • Other examples? • This is a modeling format: • Provide software that knows how to draw the object given the parameters, or knows how to produce a polygonal mesh • How you manage the model depends on the rendering style • Can be an exact representation

35. Rendering Instances • Generally, provide a routine that takes the parameters and produces a polygonal representation • Conveniently brings parametric instancing into the rendering pipeline • May include texture maps, normal vectors, colors, etc • OpenGL utility library (GLu) defines routines for cubes, cylinders, disks, and other common shapes • Renderman does similar things, so does POVray, … • The procedure may be dynamic • For example, adjust the polygon resolution according to distance from the viewer

36. OpenGL Support • OpenGL defines display lists for encapsulating commands that are executed frequently • Not exactly parametric instancing, because you are very limited in the parameters list_id = glGenLists(1); glNewList(list_id, GL_COMPILE); glBegin(GL_TRIANGLES); draw some stuff glEnd(); glEndList(); And later glCallList(list_id);

37. Display Lists (2) • The list can be: • GL_COMPILE: things don’t get drawn, just stored • GL_COMPILE_AND_EXECUTE: things are drawn, and also stored • The list can contain almost anything: • Useful for encapsulating lighting set-up commands • Cannot contain vertex arrays and other client state • The list cannot be modified after it is compiled • The whole point is that the list may be internally optimized, which precludes modification • For example, sequences of transformations may be composed into one transformation

38. Display Lists (3) • When should you use display lists: • When you do the same thing over and over again • Advantages: • Can’t be much slower than the original way • Can be much much faster • Disadvantages: • Doesn’t support real parameterized instancing, because you can’t have any parameters (except transformations)! • Can’t use various commands that would offer other speedups • For example, can’t use glVertexPointer()

39. Hierarchical Modeling • A hierarchical model unites several parametric instances into one object • For example: a desk is made up of many cubes • Other examples? • Generally represented as a tree, with transformations and instances at any node • Rendered by traversing the tree, applying the transformations, and rendering the instances • Particularly useful for animation • Human is a hierarchy of body, head, upper arm, lower arm, etc… • Animate by changing the transformations at the nodes

40. Hierarchical Model Example Draw body • Vitally Important Point: • Every node has its own local coordinate system. • This makes specifying transformations much much easier. xarm left arm Rotate about shoulder Draw upper arm l Translate (l,0,0) Rotate about origin of lower arm Draw lower arm

41. OpenGL Support • OpenGL defines glPushMatrix() and glPopMatrix() • Takes the current matrix and pushes it onto a stack, or pops the matrix off the top of the stack and makes it the current matrix • Note: Pushing does not change the current matrix • Rendering a hierarchy (recursive): RenderNode(tree) glPushMatrix() Apply node transformation Draw node contents RenderNode(children) glPopMatrix()

42. Regularized Set Operations • Hierarchical modeling is not good enough if objects in the hierarchy intersect each other • Transparency will reveal internal surfaces that should not exist • Computing properties like mass may count the same volume twice • Solution is to define regularized set operations: • Just a fancy name • Every object must be a closed volume (mathematically closed) • Define mathematical set operations (union, intersection, difference, complement) to the sets of points within the volume

43. Constructive Solid Geometry (CSG) • Based on a tree structure, like hierarchical modeling, but now: • The internal nodes are set operations: union, intersection or difference (sometimes complement) • The edges of the tree have transformations associated with them • The leaves contain only geometry • Allows complex shapes with only a few primitives • Common primitives are cylinders, cubes, etc, or quadric surfaces • Motivated by computer aided design and manufacture • Difference is like drilling or milling • A common format in CAD products

44. CSG Example - Fill it in! scale translate - cube  scale translate scale translate  cylinder cylinder

45. Rendering CSG • Normals and texture coordinates typically come from underlying primitives (not a big deal with CAD) • Some rendering algorithms can render CSG directly • Raytracing (later in the course) • Scan-line with an A-buffer • Can do 2D with tesselators in OpenGL • For OpenGL and other polygon renderers, must convert CSG to polygonal representation • Must remove redundant faces, and chop faces up • Basic algorithm: Split polygons until they are inside, outside, or on boundary. Then choose appropriate set for final answer. • Generally difficult, messy and slow • Numerical imprecision is the major problem

46. CSG Summary • Advantages: • Good for describing many things, particularly machined objects • Better if the primitive set is rich • Early systems used quadratic surfaces • Moderately intuitive and easy to understand • Disadvantages: • Not a good match for polygon renderers • Some objects may be very hard to describe, if at all • Geometric computations are sometimes easy, sometimes hard • A volume representation (hence solid in the name) • Boundary (surface representation) can also work

47. Sweep Objects • Define a polygon by its edges • Sweep it along a path • The path taken by the edges form a surface - the sweep surface • Special cases • Surface of revolution: Rotate edges about an axis • Extrusion: Sweep along a straight line

48. General Sweeps • The path maybe any curve • The polygon that is swept may be transformed as it is moved along the path • Scale, rotate with respect to path orientation, … • One common way to specify is: • Give a poly-line (sequence of line segments) as the path • Give a poly-line as the shape to sweep • Give a transformation to apply at the vertex of each path segment • Difficult to avoid self-intersection

49. Rendering Sweeps • Convert to polygons • Break path into short segments • Create a copy of the sweep polygon at each segment • Join the corresponding vertices between the polygons • May need things like end-caps on surfaces of revolution and extrusions • Normals come from sweep polygon and path orientation • Sweep polygon defines one texture parameter, sweep path defines the other

50. Spatial Enumeration • Basic idea: Describe something by the space it occupies • For example, break the volume of interest into lots of tiny cubes, and say which cubes are inside the object • Works well for things like medical data • The process itself, like MRI or CAT scans, enumerates the volume • Data is associated with each voxel (volume element) • Problem to overcome: • For anything other than small volumes or low resolutions, the number of voxels explodes • Note that the number of voxels grows with the cube of linear dimension