Transcript Lights, Surfaces, and Imaging

1
Hierarchical and Object-Oriented Graphics
•
Construct complex models from a set of simple geometric
objects
•
Extend the use of transformations to include hierarchical
relationships
•
Useful for characterizing relationships among model parts in
applications such as robotics and figure animations.
2
Symbols and Instances
•
A non-hierarchical approach which models our world as a
collection of symbols.
•
Symbols can include geometric objects, fonts and other
application-dependent graphical objects.
•
Use the following instance transformation to place instances
of each symbol in the model.
M  TRS
•
The transformation specify the desired size, orientation and
location of the symbol.
3
Example
4
Hierarchical Models
•
Relationships among model parts can be represented by a
graph.
•
A graph consists of :
- A set of nodes or vertices.
- A set of edges which connect pairs of nodes.
•
A directed graph is a graph where each of its edges has a
direction associated with it.
5
Trees and DAG: Trees
•
A tree is a directed graph without closed paths or loops.
•
Each tree has a single root node with outgoing edges only.
•
Each non-root node has a parent node from which an edge
enters.
•
Each node has one or more child nodes to which edges are
connected.
•
A node without children is called a terminal node or leaf.
6
Trees and DAGS: Trees
root node
edge
node
leaf
7
Example
8
Trees and DAG: DAG
•
Storing the same information in different nodes is inefficient.
•
Use a single prototype for multiple instances of an object
and replace the tree structure by the directed acyclic graph
(DAG).
•
Both trees and DAG are hierarchical methods of expressing
relationships.
9
Example: A Robot Arm
•
The robot arm is modeled using three simple objects.
•
The arm has 3 degrees of freedom represented by the 3 joint
angles between components.
•
Each joint angle determines how to position a component
with respect to the others.



10
Robot Arm: Base
•
The base of the robot arm can rotate about the y axis by the
angle .
•
The motion of any point p on the base can be described by
applying the rotation matrix R y ( )
11
Robot Arm: Lower Arm
•
The lower arm is rotated about the z-axis by an angle ,
which is represented by R z ( )
•
It is then shifted to the top of the base by a distance h1 ,
which is represented by T(0, h1 ,0).
•
If the base has rotated, we must also rotate the lower arm
using R y ( ) .
•
The overall transformation is R y ( )T(0, h1,0)R z ( ) .
12
Robot Arm: Upper Arm
•
The upper arm is rotated about the z-axis by the angle ,
represented by the matrix R z ( ) .
•
It is then translated by a matrix
lower arm.
•
The previous transformation is then applied to position the
upper arm relative to the world frame.
•
The overall transformation is
T(0, h2 ,0) relative to the
R y ( )T(0, h1,0)R z ( )T(0, h2 ,0)R z ( )
13
OpenGL Display Program
display()
{
glRotatef(theta, 0.0, 1.0, 0.0);
base();
glTranslatef(0.0, h1, 0.0);
glRotatef(phi, 0.0, 0.0, 1.0);
lower_arm();
glTranslatef(0.0, h2, 0.0);
glRotatef(psi, 0.0, 0.0, 1.0);
upper_arm();
}
14
Tree Representation
•
The robot arm can be described by a tree data structure.
•
The nodes represent the individual parts of the arm.
•
The edges represent the relationships between the
individual parts.
15
Information Stored in Tree Node
•
A pointer to a function that draws the object.
•
A homogeneous coordinate matrix that positions, scales
and orients this node relative to its parent.
•
Pointers to children of the node.
•
Attributes (color, fill pattern, material properties) that applies
to the node.
16
Trees and Traversal
•
Perform a tree traversal to draw the represented figure.
•
Two possible approaches
- Depth-first
- Breadth-first
•
Two ways to implement the traversal function
- Stack-based approach
- Recursive approach
17
Example: A Robot Figure
•
The torso is represented by the root node.
•
Each individual part, represented by a tree node, is
positioned relative to the torso by appropriate
transformation matrices.
•
The tree edges are labeled using these matrices.
18
Stack-Based Traversal
•
The torso is drawn with the initial model-view matrix
•
Trace the leftmost branch to the head node
- Update the model-view matrix to MMh
- Draw the head
•
Back up to the torso node.
•
Trace the next branch of the tree.
- Draw the left-upper arm with matrix
- Draw the left-lower arm with matrix
•
Draw the other parts in a similar way.
MM lua
MMluaMlla
M
19
OpenGL Implementation: Head
Figure()
{
glPushMatrix();
torso();
glTranslate
glRotate3
head();
glPopMatrix();

20
OpenGL Implementation: Left Arm

glPushMatrix();
glTranslate
glRotate3
Left_upper_arm();
glTranslate
glRotate3
Left_lower_arm();
glPopMatrix();
}
21
Push and Pop Operations
•
glPushMatrix puts a copy of the current model-view matrix
on the top of the model-view-matrix stack.
•
glTranslate and glRotate together construct a transformation
matrix to be concatenated with the initial model-view matrix.
•
glPopMatrix recovers the original model-view matrix.
•
glPushAttrib and glPopAttrib store and retrieve primitive
attributes in a similar way as model-view matrices.
22
Recursive Approach
•
Use a left-child right-sibling structure.
•
All elements at the same level are linked left to right.
•
The children are arranged as a second list from the leftmost
child to the rightmost.
root
23
Example
24
FirstChild pointer: arrow that points downward
NextSibling pointer: arrow that goes left to right
25
Data Structure for Node
Typedef struct treenode
{
GLFloat m[16];
void (*f)();
struct treenode *sibling;
struct treenode *child;
} treenode;
26
Description of Data Structure Elements
•
m is used to store a 4x4 homogeneous coordinate matrix by
columns.
•
f is a pointer to the drawing function.
•
sibling is a pointer to the sibling node on the right.
•
child is a pointer to the leftmost child.
27
OpenGL Code: Torso Node Initialization
glLoadIdentity();
glRotatef(theta[0], 0.0, 1.0, 0.0);
glGetFloatv(GL_MODELVIEW_MATRIX,torso_node.m);
Torso_node.f=torso;
Torso_node.sibling=NULL;
Torso_node.child= &head_node;
28
OpenGL Code: Upper Left Arm Node
Initialization
glLoadIdentity();
glTranslatef(-(TORSO_RADIUS+UPPER_ARM_RADIUS),
0.9*TORSO_HEIGHT, 0.0);
glRotatef(theta[3], 1.0, 0.0, 0.0);
glGetFloatv(GL_MODELVIEW_MATRIX, lua_node.m);
Lua_node.f=left_upper_arm;
Lua_node.sibling= &rua_node;
Lua_node.child= &lla_node;
29
OpenGL Code: Tree Traversal
Void traverse (treenode *root)
{
if (root==NULL) return;
glPushMatrix();
glMultMatrixf(root->m);
root->f();
if (root->child!=NULL) traverse(root->child);
glPopMatrix();
if (root->sibling!=NULL) traverse(root->sibling);
}
30
Animation
•
Objective: to model a pair of walking legs.
31
Animation: Walking Legs
•
Rotation of the base will cause rotation of all the other parts.
•
Rotation of other parts will only affect themselves and those
lower parts attached to them.
32
Definition of Body Metrics
•
The relative body metrics are defined in the file model.h.
#define TORSO_HEIGHT 0.8
#define TORSO_WIDTH TORSO_HEIGHT*0.75
#define TORSO_DEPTH TORSO_WIDTH/3.0
#define BASE_HEIGHT TORSO_HEIGHT/4.0
#define BASE_WIDTH TORSO_WIDTH
#define BASE_DEPTH TORSO_DEPTH

•
The main parts include the base and the two legs.
33
Drawing the Base
void Draw_Base(void)
{
glPushMatrix() ;
glScalef(BASE_WIDTH,BASE_HEIGHT, BASE_DEPTH);
glColor3f(0.0,1.0,1.0) ;
glutWireCube(1.0) ;
glPopMatrix() ;
}
34
Drawing the Upper Leg
void Draw_Upper_Leg(void)
{
glPushMatrix() ;
glScalef(UP_LEG_JOINT_SIZE,UP_LEG_JOINT_SIZE,UP_LEG_JOINT_SIZE);
glColor3f(0.0,1.0,0.0) ;
glutWireSphere(1.0,8,8) ;
glPopMatrix() ;
glColor3f(0.0,0.0,1.0) ;
glTranslatef(0.0,- UP_LEG_HEIGHT * 0.75, 0.0) ;
glPushMatrix() ;
glScalef(UP_LEG_WIDTH,UP_LEG_HEIGHT,UP_LEG_WIDTH) ;
glutWireCube(1.0) ;
glPopMatrix() ;
}
35
Drawing the Whole Leg
void Draw_Leg(int side)
{
glPushMatrix() ;
glRotatef(walking_angles[side][3],1.0,0.0,0.0) ;
Draw_Upper_Leg() ;
glTranslatef(0.0,- UP_LEG_HEIGHT * 0.75,0.0) ;
glRotatef(walking_angles[side][4],1.0,0.0,0.0) ;
Draw_Lower_Leg() ;
glTranslatef(0.0,- LO_LEG_HEIGHT * 0.625, 0.0) ;
glRotatef(walking_angles[side][5],1.0,0.0,0.0) ;
Draw_Foot() ;
glPopMatrix() ;
}
36
Drawing the Complete Model
void Draw_Base_Legs(void)
{
glPushMatrix() ;
glTranslatef(0.0,base_move,0.0) ;
Draw_Base() ;
glTranslatef(0.0,-(BASE_HEIGHT),0.0) ;
glPushMatrix() ;
glTranslatef(TORSO_WIDTH * 0.33,0.0,0.0) ;
Draw_Leg(LEFT) ;
glPopMatrix() ;
glTranslatef(-TORSO_WIDTH * 0.33,0.0,0.0) ;
Draw_Leg(RIGHT) ;
glPopMatrix() ;
}
37
Modeling the Walking Motion
Displacement  LL - (upper_leg_vertical lower_leg_vertical)
upper_leg_vertical X cos 
lower_leg_vertical Y cos
   
38
Codes for Calculating Vertical Displacement
double find_base_move(double langle_up, double langle_lo, double
rangle_up, double rangle_lo)
{
double result1, result2, first_result, second_result, radians_up,
radians_lo;
radians_up = (PI*langle_up)/180.0 ;
radians_lo = PI*(langle_lo-langle_up)/180.0 ;
result1 = (UP_LEG_HEIGHT + 2*UP_LEG_JOINT_SIZE) * cos(radians_up);
result2 =
(LO_LEG_HEIGHT+2*(LO_LEG_JOINT_SIZE+FOOT_JOINT_SIZE)
+FOOT_HEIGHT)* cos(radians_lo) ;
first_result = LEG_HEIGHT - (result1 + result2) ;

39
Codes for Calculating Vertical Displacement

radians_up = (PI*rangle_up)/180.0 ;
radians_lo = PI*(rangle_lo-rangle_up)/180.0 ;
result1 = (UP_LEG_HEIGHT + 2*UP_LEG_JOINT_SIZE) * cos(radians_up) ;
result2 = (LO_LEG_HEIGHT +2*(LO_LEG_JOINT_SIZE+FOOT_JOINT_SIZE)
+FOOT_HEIGHT)* cos(radians_lo) ;
second_result = LEG_HEIGHT - (result1 + result2) ;
if (first_result <= second_result)
return (- first_result) ;
else
return (- second_result) ;
}
40
Key-Frame Animation
•
The more critical motions of the object is shown in a number
of key frames.
•
The remaining frames are filled in by interpolation (the
inbetweening process)
•
In the current example, inbetweening is automated by
interpolating the joint angles between key frames.
41
Interpolation Between Key Frames
•
Let the set of joint angles in key frame A and key frame B be
( A1 , A2 ,, AN ) and ( B1 , B 2 ,, BN ) respectively.
•
If there are M frames between key frame A and B, let
 n 
•
 Bn   An
M
The set of joint angles in the m-th in-between frame is
assigned as
( A1  m1, A2  m 2 ,, AN  m N )
42
Implementation of Key-Frame Animation
switch (flag)
{
case 1 :
l_upleg_dif = 15 ;r_upleg_dif = 5 ;
l_loleg_dif = 15 ;r_loleg_dif = 5 ;
l_upleg_add = l_upleg_dif / FRAMES ;
r_upleg_add = r_upleg_dif / FRAMES ;
l_loleg_add = l_loleg_dif / FRAMES ;
r_loleg_add = r_loleg_dif / FRAMES ;
walking_angles[0][3] += l_upleg_add ;
walking_angles[1][3] += r_upleg_add ;
walking_angles[0][4] += l_loleg_add ;
walking_angles[1][4] += r_loleg_add ;
43
Implementation of Key-Frame Animation
base_move =find_base_move(walking_angles[0][3],
walking_angles[0][4], walking_angles[1][3],
walking_angles[1][4]
) ;
frames-- ;
if (frames == 0)
{ flag = 2 ; frames = FRAMES ;}
break ;
case 2:

44
Snapshots of Walking Sequence
45
Object-Oriented Approach
•
Adopt an object-oriented approach to define graphical
objects.
•
In an object-oriented programming language, objects are
defined as modules with which we build programs
•
Each module includes
- The data that define the properties of the module
(attributes).
- The functions that manipulate these attributes
(methods).
•
Messages are sent to objects to invoke a method.
46
A Cube Object
•
Non object-oriented implementation
Typedef struct cube
{
float color[3];
float matrix[4][4];
}cube;
•
Need external function to manipulate the variables in the
data structure.
47
A Cube Object
•
Object-oriented implementation
Class cube
{
float color[3];
float matrix[4][4];
public:
void render();
void translate (float x, float y, float z);
void rotate(float theta, float axis_x, float
axis_y, float axis_z);
}
48
A Cube Object
•
The application code assumes that a cube instance “knows”
how to perform action on itself.
Cube a;
a.rotate(45.0, 1.0, 0.0, 0.0);
a.translate (1.0, 2.0, 3.0);
a.render();
49
Other Examples: a Material Object
•
Definition of the material class
Class material
{
float specular[3];
float shininess;
float diffuse[3];
float ambient[3];
}
•
Creating an instance of the material class
Cube a;
Material b;
a.setMaterial(b);
50
Other examples: a light source object
•
Definition of the light source class
Class light
{
boolean type;
boolean near;
float position[3];
float orientation[3];
float specular[3];
float diffuse[3];
float ambient[3];
}
51
Solid Modeling
How would you interpret the above object?
52
Solids
•
Definition
- A model which has a well-defined inside and
outside
- For each point, we can determine whether the
point is inside, outside, or on the solid
•
Purpose
- Model more complicated shapes
- Mass properties calculations
= Volume and Moment of Insertia
- CAD/CAM manufacturing
53
Representations
•
Constructive Solid Geometry (CSG)
•
Spatial Partitioning representation
- Cell Decomposition
- Spatial-occupancy Enumeration
- Quadtrees and Octrees
- Binary Space Partitioning (BSP)
54
Constructive Solid Geometry (CSG ) Trees (1)
Data Structure = Binary tree
• Nodes= Boolean Operations
- Union, Intersection, Difference
• Nodes = Transformation
- To position and scale objects
• Leaves = Primitives
- Blocks and wedges
- Quadrics – spheres, cylinders, cones, paraboloids
- Deformed solids
55
CSG Trees (2)
•
Constructive solid geometry (CSG) operates on a set of solid
geometric entities instead of surface primitives.
•
Uses three operations: union, intersection, and set
difference:
- AB consists of all points in either A or B.
- AB consists of all points in both A and B.
- A-B consists of all points in A which are not in B.
56
CSG Trees (3)






57
CSG Trees (3)
•
The algebraic expressions are stored and parsed using
expression trees.
- Internal nodes store operations.
- Terminal nodes store operands.
•
The CSG tree is evaluated by a post-order traversal.
58
CSG Trees (4)
-
Example
Extracted from Foley et al.’s book
59
CSG Trees (5)
-
Example
CSG does not provide unique representation
Extracted from Foley et al.’s book
60
Spatial Partitioning Representation (SPR) –
Cell Decomposition
•
•
Each cell-decomposition system defines a set of primitives
cells that are typically parameterized
“Gluing” them together
Extracted from Foley et al.’s book
61
SPR – Spatial-Occupancy Enumeration
•
•
Special case of cell decomposition
Decomposed into identical cells arranged in a fixed, regular
grid
Extracted from Foley et al.’s book
62
SPR – Quadtrees and Octrees (2)
•
•
•
•
•
A hierarchical variant of spatial-occupancy enumeration
Designed to address approach’s demanding storage
requirements
Use separating planes and lines parallel to the coordinate
axes.
For a quadtree, each parent node has four child nodes.
For an octree (derived from quadtrees), each parent node has
eight child nodes.
Extracted from Foley et al.’s book
63
SPR – Quadtrees and Octrees (3)
•
•
Successive subdivision can be represented as a tree with
partially full quadrants (P), full (F) and empty (E)
No standard for assigning quadrant numbers (0-3)
Extracted from Foley et al.’s book
64
SPR – Quadtrees and Octrees (4)
•
Octree is similar to the quandtree, except that its three
dimensionals are recursively subdivided into octant.
Extracted from Foley et al.’s book
65
SPR – Quadtrees and Octrees (5)
•
Boolean set operations
S
S T
T
S T
Extracted from Foley et al.’s book
66
SPR – Binary Space-Partitioning (BSP) Trees (1)
•
•
Recursively divide space into a pairs of subspaces, each
separated by a plane of arbitrary orientation and position.
Originally, used in determining visible surface in graphics
View
point
67
SPR – Binary Space-Partitioning (BSP) Trees (2)
•
Rendering of a set of polygons using binary spatial-partition
tree (BSP tree)
•
Plane A separates polygons into two groups
- B,C in front of A
- D,E and F behind A.
•
In the BSP tree
- A is at the root.
- B and C are in the left subtree.
- D, E and F are in the right subtree.
68
SPR – Binary Space-Partitioning (BSP) Trees (3)
•
Proceeding recursively
- B is in front of C
- D separates E and F
•
In the 2 BSP sub-trees
- B is the left child of C
- E and F are the left and right of D respectively
69
SPR – Binary Space-Partitioning (BSP) Trees (4)
•
•
•
•
Later to represent arbitrary polyhedra.
Each internal node is associated with a plane and has two
child pointers – one for each side
If the half-space on a side of the plane is subdivided further,
its child is the root of a subtree
If the half-space is homogenous, its child is a leaf,
representing a region either entirely inside or entirely
outside, labeled as “in” or “out”
70
Comparison of Representations
•
Accuracy
- Spatial-partitioning – only an approximation
- CSG – high
•
Uniqueness
- Octree and spatial-occupancy-enumeration – unique
- CSG – not