hierarchical graphics, modeling, and...

CS 352: Computer Graphics

Hierarchical

Graphics,

Modeling,

And Animation

Interactive Computer Graphics Chapter 9 - 2

Overview � Modeling

� Animation

� Data structures for interactive graphics � CSG-tree

� BSP-tree

� Quadtrees and Octrees

� Visibility precomputation

� Many figures and examples in this set of lectures are from The Art of 3D Computer Animation and Imaging, by I. Kerlow


Modeling � The modeling problem

� Modeling primitives � Polygon

� Sphere, ellipsoid, torus, superquadric

� NURBS, surfaces of revolutions, smoothed polygons

� Particles

� Skin & bones

� Approaches to modeling complex shapes � Tools such as extrude, revolve, loft, split, stitch, blend

� Constructive solid geometry (CSG)

� Hierarchy; kinematic joints

� Inverse kinematics

� Keyframes


Representing objects � Objects represented as symbols

� Defined in model coordinates; transformed

into world coordinates (M = TRS) glMatrixMode(GL_MODELVIEW);

glLoadIdentity(); glTranslatef(…);

glRotatef(…); glScalef(…);

glutSolidCylinder(…);


Primitives � The basic sort of primitive is the

polygon

� Number of

polygons:

tradeoff between render time and

model accuracy


Spline Curves � Linear spline

� Cardinal spline

� B-spline

� Bezier curve

� NURBS (non-

uniform rational b-spline)


Mesh


Mesh deformations


Sweep � Sweep a shape over a path to form a generalized cylinder


Revolution � Revolve a shape around an axis to create an object with rotational symmetry


Extrusion � Extrude: grow a 2D shape in the third dimension

� Shape is created with a (1D) b-spline curves

� Hole was created by subtracting a cylinder


Joining Primitives � Stitching, blending


Modifying Primitives


Subdivision Surfaces � Can set level of polygon subdivision


Skin and Bones � Skeleton with joined “bones”

� Can add “skin” on top of bones

� Automatic or

hand-tuned

skinning


Particles


Algorithmic Primitives

Algorithms for trees, mountains, grass, fur, lightning, fire, …


Geometric model file formats � .obj: Alias Wavefront

� .dxf: Autocad

� .vrml: Inventor

� Dozens more

� Can convert

between formats

� Converting to a

common format may lose info…


Hierarchical models � When animation is desired, objects may have parts that move with respect to each other

� Object represented as hierarchy

� Often there are joints with motion constraints

� E.g. represent wheels of car as sub-objects with rotational motion (car moves 2 pi r per rotation)


DAG models � Could use tree to represent object

� Actually, a DAG (directed acyclic graph) is better: can re-use objects

� Note that each arrow needs a separate modeling transform

� In object-oriented graphics, also need motion constraints with each arrow


Example: Robot � Traverse DAG using DFS (or BFS)

� Push and pop matrices along the way

(e.g. left-child right-sibling) (joint position parameters?)


Modeling Programs � Moray

� Shareware

� Limited functionality

� Easy

� Lightwave, Maya

� NOT shareware

� Very full-featured

� Difficult to learn and use

� Moray, Maya demos; Lightwave video


Animation � Suppose you want the robot to

pick up a can of oil

to drink. How?

� You could set the

joint positions at each moment in

the animation (kinematics)


Inverse Kinematics � You can’t just invert the joint transformations

� Joint settings aren’t even necessarily unique for a

hand position!

� Inverse kinematics:

figure out from the hand position where the joints

should be set.


Using Inverse Kinematics � Specify joint constraints

and priorities

� Move end effector

(or object pose)

� Let the system figure

out joint positions

� [IK demo]


Keyframe Animation � In traditional key frame animation the animator draws several important frames, and helpers do the “inbetweening” or “tweening”

� Computer animation is also key-frame based

� At key frames, animator positions objects and lights, sets parameters, etc.

� The system interpolates parameter values linearly or along a curve

� To get from one object pose to the next, inverse kinematics determine joint motions

� [Keyframe animation demo]


Motion Capture � More realistic motion sequences

can be generated

by Motion Capture

� Attach joint

position indicators to real actors

� Record live action


Morphing � Morphing: smoothly shifting from one image to another

� First popularized in a Michael Jackson video

� Method: a combination of

� Warping both images, gradually moving control points from location in first image to location in the second

� Cross-fading from first image sequence to second


3D Morphing � Define 3D before and after shapes as e.g.

NURBS surfaces with

same number of control points

� Gradually move control points from

first setting to second

� Specify key poses: e.g. smile, frown, 12 frames of walking motion


Combined approaches


Example: virtual puppetry � Suppose you want to display virtual puppet shows

� How could you animate puppet movements?

� How could you control the animations externally?


Character Animation � To make computer graphics (or cartoon drawings)

come alive…


Personality through Pose, Expression, Motion, Timing


Object-oriented Graphics � Higher in the programming hierarchy: control models with object-oriented programs

robot robbie;

robbie.smile();

robbie.walk(270, 5, 3);


Data Structures for Modeling � This part of chapter: how some example applications be done efficiently (i.e. topics without a better home…)

� Tree-based subdivisions of space

� Example 1: how to represent complex objects made up of union, intersection,

difference of other objects


CSG Tree


Application 2: HSR � How to render in 3D with hidden surface removal when you don’t have a hardware

depth-buffer?

� Can you think of any other ways of removing

hidden surfaces quickly?

� Principle: a polygon can’t be occluded by another polygon that is behind it.


BSP-tree � The painter’s algorithm for hidden surface removal works by drawing all faces, from

back to front

� How to get a listing of the faces in back-to-

front order?

� Put them into a binary tree and traverse the

tree (but in what order?)


BSP Tree Figures � Right is “front” of polygon; left is “back”

� In and Out nodes show regions of space

inside or outside the object

� (Or, just store split pieces of polygons at

leaves)


Traversing a BSP tree � Binary Space Partition tree: a binary tree with a polygon at each node � Children in left subtree are behind polygon

� Children in right subtree are in front of polygon

� Traversing a BSP-tree: � If null pointer, do nothing

� Else, draw far subtree, then polygon at current node, then near subtree

� Far and near are determined by location of viewer

� Runtime of traversal?

� Drawbacks?


Building a BSP tree � Inserting a polygon:

� If tree is empty make it the root

� If polygon to be inserted intersects plane of polygon of current node, split and insert half on each side recursively.

� Else insert on appropriate side recursively

� Problem: the number of faces could grow

dramatically � Worst case (O(n2))…but usually it doesn’t grow too badly in

practice…


BSP-tree Summary � Returns polygons not necessarily in sorted order, but in an order that is correct for back-to-front rendering

� Widely used when Z-buffer hardware may not be available (e.g. game engines)

� Guarantees back-to-front rendering for alpha blending

� Works well (linear-time traversals) in the number of split polygons

� [And we hope the number of polygons doesn’t grow too much through splitting]


Application 3: Handling Large Spatial Data Sets � Example application: image-based rendering

� Suppose you have many digital images of a scene, with depth information for pixels

� How to find efficiently the points that are in front?

� Other applications:

� Speeding up ray-tracing with many objects

� Rendering contours of 3D volumetric data such as MRI scans


Quadtree � Quadtree: divide space into four quadrants. Mark as Empty, Full, or Partially full.

� Recursively subdivide partially full regions

� Saves much time, space over 2D pixel data!


Quadtree Structure


Octrees � Generalize to cutting up a cube into 8 sub-cubes, each of which may be E, F, or P (and

subdivided)

� Much more efficient

than a 3D array of

cells for 3D volumetric data


Quadtree Algorithms � How would you

� render a quadtree shape?

� find the intersection of a ray with a quadtree shape?

� Take the union of two quadtrees?

� Intersection?

� Find the neighbors of a cell?


Applications of Octrees � Contour finding in MRI data

� 3D scanning and rendering

� Efficient ray tracing

� Intersection, collision testing


Research in Visibility � Can we figure out in advance what will be visible from each viewpoint?


Viewer-centered representation

� Viewer-centered object representations: representation not of volume of space filled

but appearance from all viewpoints


Occlusion in view space

� Occlusion in view space is subtraction


Events � Events: boundaries in viewpoint space where faces appear or disappear


Aspect Graph � Aspect graph: a graph with a node for every topologically distinct view of an object, with

edges connecting adjacent views


Aspect graph varieties � Aspect graphs can be constructed for

� 3D: space

� 2D: multiple axis rotations or planar motions

� 1D: single-axis rotations


1D Aspect Graph for Rotation


1D Aspect Graph Results � Useful for rotations without Z-buffer hardware!

� Not so useful for more viewer freedom, modern graphics hardware


Conservative Visibility Preprocessing

� Q. can we take advantage of z-buffer?

� Definition: weak visibility. A polygon is weakly visible from a region if any part of the polygon is visible from any viewpoint in the region

� Conservative visibility preprocessing: computing in advance a (super-)set of the polygons that are weakly visible from some region

� Rendering with Z-buffer yields correct image, but it’s faster since fewer polygons are drawn


Weak Visibility Subdivision � Given an object and a wall, find the region of space from which the wall occludes the

object

� Divide space into

regions, where each

edge represents some object

appearing or disappearing


Conservative Visibility Preprocessing on a Grid � Divide viewing space into a 3D

(or 2D) grid

� Compute a

conservative

display list for each cell


Conservative visibility algorithm � Initialize a display list for each grid cell

� Algorithm: for each object, wall, and cell

� If the object is not weakly visible from the cell, remove from cell’s display list

� You can churn away at this computation as

long as you like, increasing runtimes, but you

can stop at any time with usable results. (Results improve over time!)


Perspective � What good did this visibility research do for the world?

� It wasn’t enough for me

� I left graphics research and went into digital libraries

� Left University of Pittsburgh and went to Wheaton College


Summary � 3D modeling uses advanced primitives and ways of cutting, joining them

� Inverse kinematics determines joint position from end effector motions

� Keyframe animation involves important poses and inbetweening

� 3D morphing animates surface control points

� 3D spatial subdivision trees include CSG-

trees, BSP-trees, Quadtrees, and Octrees

� Visibility preprocessing speeds walkthrough

hierarchical graphics, modeling, and...

Documents