# Modeling

Document Sample

```					Computer Graphics
Modeling

Modeling
• Modeling is simply the process of creating 3D objects
– Many different processes to create models – Many different representations of model data

• Once the models are obtained, one can transform them to the correct locations in space, place a virtual camera in space, and render a 2D image of the scene

Model Representations
• • • • • Polygonal CSG (constructive solid geometry) Spatial subdivision techniques Implicit representation Parametric patches

Polygonal
• Complex objects are broken down into many simple polygons

• Polygons form the “skin” of the object
– Objects are hollow – Polygons have a front face and a back face

Triangles
• Triangles are the #1 choice of polygons
– They are always planar – Graphics hardware is often optimized for triangles
• Nvidia TNT2  8M triangles per second • Nvidia Geforce2  31M triangles per second • Nvidia Geforce4  136M vertices per second
– Note: Don’t read too much into these numbers. They are similar to processor speed numbers in that they don’t tell the whole story of how fast the computer actually is.

Triangulation
• How are triangles obtained?
– Triangulating a set of surface points

• Several different triangulation approaches
– Delaunay triangulations attempt to equalize triangle angles (reduces long skinny triangles)

How Many Triangles?
• More triangles are needed in surface areas that require more geometric detail
– Higher curvature  more triangles necessary

Level Of Detail (LOD)
• It can be very costly to always display an entire object at the greatest level of detail • Less detail is necessary the farther away you are from on object
– Also depends on the viewing angle and screen size

• Solution: create several models of the object at different levels of detail
– Display the correct one for the viewing distance

LOD

50 Vertices

500 Vertices

2000 Vertices

LOD

LOD
• How to create the same model in multiple levels of detail?
– Ex: start with most detailed, resample with less vertices, and then re-triangulate

• When to switch models when rendering?
– Based on distance and screen size
– Ex: 640x480 screen  307,200 pixels Object takes up half of screen  150K pixels  Any more than 300K triangles (half are facing away from the camera) is overkill at this distance and screen size

– Visual artifacts can occur at switching point

Creating the Surface Points
• Triangulation works on a set of points
– One needs to create this surface point set

• Many different approaches:
– Manual placement – Mathematical (geometrical) generation – Scanning real objects

Mathematical Generation
• Solids of Revolution
– Rotation of a cross-section around an axis
• • • • Spheres Cones Cylinders Bundt cakes?

Mathematical Generation
• Extrusion
– Extrude a cross-section along a profile curve – Scale may vary along the profile
• • • • Many metal and plastic parts Cones Cylinders Bottles

Scanning Real Objects
• Laser scanning
Hand-held laser scanner Recovered 3D model

• Tomographic methods

Slice of brain from CT scan

– Medical scanning (Xray, CT, MRI) Recovered 3D – Radar model of lungs

Scanning Real Objects
• Computer vision

Actual photograph of Hoover Tower

Recovered 3D model

Model rendered from novel view and texture mapped

Triangle Representations
• Graphics cards do most of the triangle work
– Need an efficient way to send triangles to the card

• Some typical primitive triangle representations:
– Lists – Fans – Strips

1.6 vertices per triangle

1.5 vertices per triangle

3.0 vertices per triangle

Triangle Representations
• Adding a level of indirection with indexed triangle representations
– Store the vertices (in a vertex buffer) independently of the rendering order (which is stored in a index buffer) – Enables one to reuse a vertex multiple times without sending 3 coordinates each time

• Conventional wisdom is that indexed triangle strips are the most efficient triangle representation

Surface Normal
• Each triangle has a single surface normal
– Easy way to defines the orientation of the surface – Again, the normal is just a vector (no position)

Computing the Surface Normal
1. 2. 3. 4. Let V1 be the vector from point A to point B Let V2 be the vector from point A to point C N = V1 x V2 N is often normalized

•

Note that order of vertices becomes important
– Triangle ABC has an outward facing normal – Triangle ACB has an inward facing normal

Modeling Approaches
• • • • • Polygonal CSG (constructive solid geometry) Spatial subdivision techniques Implicit representation Parametric patches

Constructive Solid Geometry
• Unlike polygonal approaches, CSG models are “solids”
– Polygonal models are “skins”

• Solid approaches are often better suited for medical applications because
– Cutting slices through objects – Representing internal functional data
• Temperature • Blood flow

CSG Trees
• CSG models are stored in trees
– Leaves are primitive shapes
• Spheres, Cubes, Cones, etc.

– Nodes are Boolean operations
• Union, Difference, Intersection

CSG Operations
• Primitives:

• Union:

• Intersection:

• Difference:

CSG Rendering
• CSG models can be rendered by:
– Computing surface points and triangulating
• Rendering can then be performed by standard hardware

– Use of special CSG rendering routines
• Not hardware optimized

Modeling Approaches
• • • • • Polygonal CSG (constructive solid geometry) Spatial subdivision techniques Implicit representation Parametric patches

Spatial subdivision techniques
• The idea is to divide up space into pieces that are the object are pieces that are not the object
– A “solid” approach to modeling

• Usually pieces are cubes • Amount of detail that can be represented is controlled by how small the cubes are

2D Images
• B/W images
– Image is evenly divided up into pixels – Pixels size controls the level of detail – Pixels are on/off to represent presence/absence of object – Representation designed for ease of blitting onto screen, not for efficient data representation

– Subdivision can continue until the required level of detail is reached – Significantly more efficient than using a 2D block of uniform small squares

3D Space Subdivision
• Voxels are the 3D extension of pixels • Again, the brute-force approach is to fill 3D space with uniform small voxels and mark the space as occupied or empty

Octrees
• Octrees are the 3D extension of quad trees and use adaptive subdivision

Modeling Approaches
• • • • • Polygonal CSG (constructive solid geometry) Spatial subdivision techniques Implicit representation Parametric patches

Implicit Representation
• An implicit definition of a sphere:
x 2 + y2 + z2 = r 2

• Defines a type of “isosurface”
– A set of 3D points that satisfy the equation

• However, they are difficult to work with
– Quickly tell me all the points that satisfy the above equation given a particular value of r

Metaballs
• Metaballs (a.k.a. blobby objects) are an implicit modeling technique

Metaballs in Action
• Implicit representations find most of the use in shape changing animations

Modeling Approaches
• • • • • Polygonal CSG (constructive solid geometry) Spatial subdivision techniques Implicit representation Parametric patches

Parametric Patches
• Parametric patches are used to model smooth curved surfaces and to allow dynamic control over the shape of the surface • Parametric patches are uses heavily in CAD application and animation • Currently real-time applications are dominated by triangle meshes
– Patches hold many advantages over triangle meshes and if hardware support for them becomes widespread there could be a major shift to them

Parametric Patches
• One of the first uses of parametric patches is the “Utah Teapot”
– The actual teapot is on the left

Parametric Patches
• We will start be examining curves
– Bézier curves – B-Spline curves

• Then we will expand to surface patches
– Bézier patches – B-Spline patches

Bézier Curves
• Pierre Bézier, a French designer, first used them in the 1970’s in the design of Renault car bodies • Since, they have been heavily used by Adobe in their fonts as well as in graphic applications • A Bézier curve is a parametric curve
– The function C(u) defines the curve points (x, y, z) as the parameter u varies through [0..1]

Bézier Curves
• The space curve C(u) is defined by:
C(u) = i0..N Pi Bi (u) where the Pi are the control points and the Bi(u) are the blending functions

Bézier Curves
• The control points are simply 3D points • The blending functions are defined as:
Bi(u) = N ui (1 – u)N-i i

• Most of the time, the cubic version is used (n=3)
– This implies 4 control points are needed and 4 blending functions: B0(u) = (1 – u)3 B1(u) = 3u (1 – u)2 B2(u) = 3u2 (1 – u) B3(u) = u3

Bézier Curves
• The blending functions make much more sense graphically
– Note that t in the graph below is our u

Bézier Curves
• Due to the setup of the blending functions:
– The curve goes through the end points
• control points P0 and P3

– The curve doesn’t go through the interior control points

• The interior control influence the curve
– The curve is pulled in the direction of the control point – Moving a control point changes the shape of the entire curve (called global control)

Bézier Curves
• A Bézier Curve can only “curve” as much as its degree allows
– Degree 1 (linear) is a line – Degree 2 (quadratic) can curve once – Degree 3 (cubic) can curve twice

• Recall that the number of control points is always 1 larger than the degree

Bézier Curves
• So what if you want a really “curvy” curve?
– You could increase the degree of the curve
• The downfall of this approach is that each control point has global control over the curve shape
– That is, changing a single control point will modify the shape of the entire curve (not great for modeling) – High degree curves are “unstable”

• It is computationally expensive

– You could join multiple cubic curves together
• Each control point only has influence over its piece of the curve (local control w.r.t. the entire joined curve) • Hardware can be optimized for cubic curves • But, we must maintain continuity across the joins!

Bézier Curves
• So how are we going to maintain continuity? • Notice that the line between the first 2 control points specify the tangent of the curve at u=0 • And the line between the last 2 control points specify the tangent of the curve at u=1

Bézier Curves
• So if we line up P2P3 with Q0Q1, then we have the same tangent at end u=1 point of curve P and u=0 point of curve Q

Bézier Curves
• Continuity put into more formal terms:
– C0 continuity means the curve points vary smoothly
• That is, the curve is a set of connected points • For our joined example, it means the two joined segments share the same endpoints
– P3 is the same point as Q0

– C1 continuity means the curve’s first derivatives vary smoothly (plus C0 continuity)
• For our joined example, it means the tangents at the end endpoints must be the same (P2, P3, Q0, Q1 must form a line)
– And P0, P1 must form a line with the curve before it and Q2, Q3 must form a line with the curve after it  all 4 control points are constrained to some extent

Bézier Curves
– C2 continuity means the curve’s second derivatives vary smoothly (plus C1 continuity)
• Second derivative corresponds to curvature • For our joined example, it implies constrains on P1, P2, P3, Q0, Q1, and Q2
– Plus P0, P1, and P2 are constrained from the curve before it and Q1, Q2, and Q3 are constrained from the curve after it – Thus, although it can be achieved, there are so many constrains on the positions of the control points that joined cubic Bézier curves are almost never C2 continuous

Bézier Curves
• Do we care about C2 continuity?
– Probably not for simple modeling – But if the curve is being used to specify the path/orientation of a camera:
• Not C0 means the camera position jumps • Not C1 means the camera’s orientation jumps • Not C2 means the change in the camera’s orientation has sudden jumps

– Think in terms of a car: position, velocity, acceleration

B-Spline Curves
• B-Splines fix two major problems of Béziers:
– Global control of control points – Relationship between degree of the curve and the number of control points

• This is achieved by letting the user specify any number of control points and automatically constructing a set of cubic curves that are C2
– This is similar to a set of joined cubic Bézier curves
• Joined cubic Bézier curves can have any number of control points and are still cubic, and each control point only influences its local cubic curve

– But B-Splines are C2 and have no constraints on control point locations as joined cubic Bézier curves

B-Spline Curves
• The definition of cubic B-Spline curve is:
C(u) = i0..M Pi Bi (u)

• So just like with Bézier curves, we have control points (Pi) and blending functions (Bi(u)) • However, a full B-Spline curve of M+1 control points is really made up of M-2 curve segments, each being controlled by 4 of the control points • Also, the blending functions are defined differently than with Bézier curves, with the two most popular variations being:
– Uniform – Non-Uniform

Uniform B-Spline Curves
• Uniform blending functions get their name from the fact that all the blending functions are uniform

Uniform B-Spline Curves
• Recall that each curve segment composing the full B-Spline needs 4 control points modified by 4 blending functions • This implies that only the section in yellow on the previous slide can be used to define the curve
– At either end there are not enough blending functions

• This also implies that the curve will not go through any of the control points, including the first and last (as was the case with Bézier)
– There are multiple non-zero blending functions at u=0 and u=1

Uniform B-Spline Curves
• Here is an example of a Uniform B-spline curve
– M=8  9 control points, 6 curve segments

Non-Uniform B-Spline Curves
• The main difference between Uniform and NonUniform B-Splines is that all the blending functions are not the same • There are several variations on the blending functions, all controlled by “knot values”
– We won’t get into the details of knot values

• In particular, the blending function can be specified in such a way as force the curve to go through the endpoints (like Bézier)
– P.97 from 3D games book has a good example

Rational Curves
• A rational curve is a curve defined in 4D space that is then projected into 3D space • The main point of using rational curves is that it allows you to define weights on the control points
– Giving a control point a higher weight causes the curve to be pulled more towards that control point – P.105 in 3D games book for an example

• One can have Rational Bézier curves or Rational B-Spline curves
– Or other types of curves not covered (Hermite, etc.)

NURBS
• NURBS stands for Non-Uniform Rational BSplines

• It is one of the most popular curve representations used in CAD and graphics work because it allows:
– Local control of the curve when moving the control points (B-Spline) – Ability to adjust the blending functions by moving the “knot values” (Non-Uniform) – Ability to weight the control points (Rational)

Bézier Patches
• These patches are based on Bézier curves • The equation for a cubic patch is:
C(u, v) = i0..3 j0..3 Pij Bi (u) Bj (v)

• That is, it is a lattice of Bézier curves
– Specifically, 4 horizontal curves (u direction) and 4 vertical curves (v direction)

• These 8 curves share control points such that there are a total of 16 control points in the lattice

Bézier Patches
• The following is an example of the control point lattice:

Bézier Patches
• The surface that is created is based on the control points:

Bézier Patches
• The surface is based on Bézier curves • Thus, the surface only matches the control points at the 4 corners

Bézier Patches
• Adjusting the control points changes the shape of the surface: • See the applet on:
– http://www.nbb.cornell.edu/neurobio/land/OldStudentProjects/cs490-96to97/anson/BezierPatchApplet/

• All the same issue occur with patches as with curves
– Control points have global control – Increasing the number of control points will increase the degree of the patch

Bézier Patches
• Thus, we handle large curvy surfaces the same was as with curves: join patches together • See the applet on:
– http://www1.ics.uci.edu/~frost/unex/JavaGraphics/course/Bezpatch.html

• Recall the continuity constrains:
– C0 continuity: edges must match – C1 continuity: colinear control points

• More difficult near joins of 4 patches

B-Spline Patches
• B-Spline patches are similar to Bézier patches except that they are based on BSpline curves • This implies that:
– You can have any number of control points in either the u or v direction (4x4, 8x12, etc.) and still maintain piecewise C2 cubic patches – With Uniform patches, the patch is will no go through the control points
• See P.116 in Games book

Rendering Patches
• There are two types of ways we can render patches:
– Render them directly from the parametric descriptions in hardware
• Must have hardware support

– Approximate the patch with a triangle mesh and render this mesh
• Usually done in software • Standard pipeline can be used

Rendering Patches
• To approximate the patch with triangles, we can use a uniform subdivision
– Evaluate the surface at fixed (u,v) intervals and connect the points with triangle strips

– Nehe Tutorial 28 (left/right/up/down/space) – OpenGL has support for this which Nehe28 doesn’t use

Rendering Patches
• Or we can use an adaptive subdivision
• Divide surface in quarters • If approximation patch is “flat enough” relative to the actual surface patch, then draw it • Otherwise, repeat the sub-division on that quarter

– Pros:
• More triangles are generated where the curvature is high, less triangles where curvature is low

– Cons:
• Problems with cracks
– Neighbors not subdivided to the same level – Can be fixed by adding more edges

Rendering Patches
• To have proper lighting we also need normals for the triangles
– We can simply use the triangles normal – Or, if we want to be more accurate, we can use the actual normal to the parametric surface
• Partial derivative in the u direction is 1st tangent • Partial derivative in the v direction is 2nd tangent • Take their cross product and normalize to produce the normal vector

OpenGL Bézier Curve Support
• To setup a Bézier curve:
– glMap1f(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4, &controlPts[0][0]);
• Params are: map type, u start, u end, stride, order (degree + 1), array of control points

– glEnable(GL_MAP1_VERTEX_3);

• To setup a grid for subdivision
– glMapGrid1f(100, 0.0, 10.0)
• 100 subdivision between starting with 0 and ending with 10 • Grid 0 gets mapped to u=0, grid 10 get mapped to u=1

• To draw the curve
– glEvalMesh1(GL_LINE, 0, 10)
• Draw lines to approximate the curve from grid range 0 to 10

OpenGL Bézier Patch Support
– glMap2f(GL_MAP2_VERTEX_3, 0.0, 1.0, 3, 4, 0.0, 1.0, 12, 4, &controlPts[0][0][0]); – glEnable(GL_MAP2_VERTEX_3); – glMapGrid2f(100, 0.0f, 10.0f, 100, 0.0f, 10.0f); – glEvalMesh2(GL_LINE, 0, 10, 0, 10);
• Or GL_FILL which produces lit, shaded surface if lighting is turned on and we have normals for our surface
– glEnable(GL_AUTO_NORMAL);

• Texture mapping can also be done by using similar mapping to automatically generate texture coordinates

OpenGL NURBS Support
• To setup the NURBS:
– GLUnurbsObj *myNurb = gluNewNurbsRenderer(); – gluNurbsProperty(myNurb, GLU_SAMPLING_TOLERANCE, maxUnitLength); – gluNurbsProperty(myNurb, GLU_DISPLAY_MODE, GLU_FILL);

• To display the NURBS:
– gluBeginSurface(myNurb); – gluNurbsSurface(myNurb, uKnotCount, uKnotArray, vKnotCount, vKnotArray, uStride, vStride, controlPtsArray, uOrder, vOrder, GL_MAP2_VERTEX_3); – gluEndSurface(myNurb);

• Tons more parameters and control available

```
DOCUMENT INFO
Shared By:
Categories:
Stats:
 views: 156 posted: 1/29/2010 language: English pages: 73
How are you planning on using Docstoc?