Geometric Objects and Transformation

1
Chapter 4

• Geometric Objects and Transformation

2
Objectives

• Introduce the elements of geometry
• Scalars
• Vectors
• Points
• Develop mathematical operations among them in a
  coordinate-free manner
• Define basic primitives
• Line segments
• Polygons

3
Basic Elements

• Geometry is the study of the relationships among
  objects in an n-dimensional space
• In computer graphics, we are interested in
  objects that exist in three dimensions
• Want a minimum set of primitives from which we
  can build more sophisticated objects
• We will need three basic elements
• Scalars
• Vectors
• Points

4
Scalars

• Scalars can be defined as members of sets which
  can be combined by two operations (addition and
  multiplication) obeying some fundamental axioms
  (associativity, commutivity, inverses)
• Examples include the real and complex number
  under the ordinary rules with which we are
  familiar
• Scalars alone have no geometric properties

5
Vectors

• Physical definition a vector is a quantity with
  two attributes
• Direction
• Magnitude
• Directed line segments
• Examples include
• Force
• Velocity

Directed Line segment
6
Vector Operations

• Every vector has an inverse
• Same magnitude but points in opposite direction
• Every vector can be multiplied by a scalar
• There is a zero vector
• Zero magnitude, undefined orientation
• The sum of any two vectors is a vector
• Use head-to-tail axiom

w
vuw
?v
v
-v
u
7
Vectors Lack Position

• These vectors are identical
• Same length and magnitude
• Vectors spaces insufficient for geometry
• Need points

8
Points

• Location in space
• Operations allowed between points and vectors
• Point-point subtraction yields a vector
• Equivalent to point-vector addition

vP-Q
PvQ
9
Coordinate-Free Geometry
Objects without coordinate system
Objects and coordinate system
10
Linear Vector and Euclidean Spaces

• Mathematical system for manipulating vectors
• Operations
• Scalar-vector multiplication u?v
• Vector-vector addition wuv
• 1 P P
• 0 P 0 (zero vector)
• Expressions such as
• vu2w-3r
• Euclidean space is an extension of vector space
  that adds a measure of size of distance

11
Affine Spaces

• Point a vector space
• Operations
• Vector-vector addition
• Scalar-vector multiplication
• Point-vector addition
• Scalar-scalar operations

12
The Computer-Science View

• Abstract data types(ADTs)
• vector u, vpoint p, qscalar a, b
• In C, by using classes and overloading
  operator, we could writeq p av

13
Geometric ADTs

• Textbook notations
• ?, ?, ? denote scalars
• P, Q, R define points
• u, v, w denote vectors
• ?v ?v, v P QP v Q

14
Lines

• Consider all points of the form
• P(a)P0 a d
• Set of all points that pass through P0 in the
  direction of the vector d

15
Parametric Form

• This form is known as the parametric form of the
  line
• More robust and general than other forms
• Extends to curves and surfaces
• Two-dimensional forms
• Explicit y mx h
• Implicit ax by c 0
• Parametric
• x(a) ax0 (1-a)x1
• y(a) ay0 (1-a)y1

16
Rays and Line Segments

• If a gt 0, then P(a) is the ray leaving P0 in the
  direction d
• If we use two points to define v, then
• P( a) Q a (R-Q)Qav
• aR (1-a)Q
• For 0ltalt1 we get all the
• points on the line segment
• joining R and Q

17
Space Partitioning
E
p?u?v
F
v
B
A
u
C
D
E ?gt0, ?gt0, ? ?1 F ?gt0, ?gt0, ? ?gt1 A
?gt0, ?gt0, ? ?lt1 B ?lt0, ?gt0 C ?lt0, ?lt0 D
?gt0, ?lt0
18
Convexity

• An object is convex iff for any two points in the
  object all points on the line segment between
  these points are also in the object

P
P
Q
Q
19
Affine Sums

• Consider the sum
• Pa1P1a2P2..anPn
• Can show by induction that this sum makes sense
  iff
• a1a2..an1
• in which case we have the affine sum of the
  points P1,P2,..Pn
• If, in addition, aigt0, we have the convex hull
  of P1,P2,..Pn

20
Convex Hull

• Smallest convex object containing P1,P2,..Pn
• Formed by shrink wrapping points

21
Dot and Cross Products

22
Linear Independence

• A set of vectors v1, v2, , vn is linearly
  independent if
• v1v2..vn0 iff a1a20
• If a set of vectors is linearly independent, we
  cannot represent one in terms of the others
• If a set of vectors is linearly dependent, as
  least one can be written in terms of the others

23
Dimension

• In a vector space, the maximum number of linearly
  independent vectors is fixed and is called the
  dimension of the space
• In an n-dimensional space, any set of n linearly
  independent vectors form a basis for the space
• Given a basis v1, v2,., vn, any vector v can be
  written as
• va1v1 a2v2 .anvn
• where the ai are unique

24
Planes and Normals

• Every plane has a vector n normal (perpendicular,
  orthogonal) to it
• From point-two vector form P(a,b)Raubv, we
  know we can use the cross product to find n
  u ? v and the equivalent form
• (P(a, b)-P) ? n0
• Assume P(x0, y0, z0) and n(nx, ny, nz), then
  the plane equationnxxnyynzznx0ny0nz0

25
Three-Dimensional Primitives

• Hollow objects
• Objects can be specified by vertices
• Simple and flat polygons (triangles)
• Constructive Solid Geometry (CSG)

3D curves
3D surfaces
Volumetric Objects
26
Constructive Solid Geometry
27
Representation

• Until now we have been able to work with
  geometric entities without using any frame of
  reference, such a coordinate system
• Need a frame of reference to relate points and
  objects to our physical world.
• For example, where is a point? Cant answer
  without a reference system
• World coordinates
• Camera coordinates

28
Coordinate Systems

• Consider a basis v1, v2,., vn
• A vector is written va1v1 a2v2 .anvn
• The list of scalars a1, a2, . anis the
  representation of v with respect to the given
  basis
• We can write the representation as a row or
  column array of scalars

aa1 a2 . anT
29
Example

• v2v13v2-4v3
• a2 3 4
• Note that this representation is with respect to
  a particular basis
• For example, in OpenGL we start by representing
  vectors using the world basis but later the
  system needs a representation in terms of the
  camera or eye basis

30
Problem in Coordinate Systems

• Which is correct?
• Both are because vectors have no fixed location

v
v
31
Frames 1/2

• Coordinate System is insufficient to present
  points
• If we work in an affine space we can add a single
  point, the origin, to the basis vectors to form a
  frame

32
Frames 2/2

• Frame determined by (P0, v1, v2, v3)
• Within this frame, every vector can be written as
  
• va1v1 a2v2 .anvn
• Every point can be written as
• P P0 b1v1 b2v2 .bnvn

33
Representations and N-tuples
34
Change of Coordinate Systems

• Consider two representations of a the same vector
  with respect to two different bases. The
  representations are

aa1 a2 a3
bb1 b2 b3
where
va1v1 a2v2 a3v3 a1 a2 a3 v1 v2 v3
T b1u1 b2u2 b3u3 b1 b2 b3 u1 u2 u3 T
35
Representing Second Basis in terms of the First

• Each of the basis vectors, u1,u2, u3, are vectors
  that can be represented in terms of the first
  basis

u1 g11v1g12v2g13v3 u2 g21v1g22v2g23v3 u3
g31v1g32v2g33v3
v
36
Matrix Form

• The coefficients define a 3 x 3 matrix
• and the basis can be related by
• see text for numerical examples

M
aMTb ?b(MT)-1a
37
Confusing Points and Vectors

• Consider the point and the vector
• P P0 b1v1 b2v2 .bnvn
• va1v1 a2v2 .anvn
• They appear to have the similar representations
• Pb1 b2 b3 va1 a2 a3
• which confuse the point with the vector
• A vector has no position

v
p
v
can place anywhere
fixed
38
A Single Representation

• If we define 0P 0 and 1P P then we can write
  
• va1v1 a2v2 a3v3 a1 a2 a3 0 v1 v2 v3 P0
  T
• P P0 b1v1 b2v2 b3v3 b1 b2 b3 1 v1 v2
  v3 P0 T
• Thus we obtain the four-dimensional homogeneous
  coordinate representation
• v a1 a2 a3 0 T
• P b1 b2 b3 1 T

39
Homogeneous Coordinates

• The general form of four dimensional homogeneous
  coordinates is
• px y x w T
• We return to a three dimensional point (for w?0)
  by
• x?x/w
• y?y/w
• z?z/w
• If w0, the representation is that of a vector
• Note that homogeneous coordinates replaces points
  in three dimensions by lines through the origin
  in four dimensions

40
Homogeneous Coordinates and Computer Graphics

• Homogeneous coordinates are key to all computer
  graphics systems
• All standard transformations (rotation,
  translation, scaling) can be implemented by
  matrix multiplications with 4 x 4 matrices
• Hardware pipeline works with 4 dimensional
  representations
• For orthographic viewing, we can maintain w0 for
  vectors and w1 for points
• For perspective we need a perspective division

41
Change of Frames

• We can apply a similar process in homogeneous
  coordinates to the representations of both points
  and vectors
• Consider two frames
• Any point or vector can be represented in each

u2
u1
v2
Q0
P0
v1
u3
v3
42
Representing One Frame in Terms of the Other

• Extending what we did with change of bases

u1 g11v1g12v2g13v3 u2 g21v1g22v2g23v3 u3
g31v1g32v2g33v3 Q0 g41v1g42v2g43v3 g44P0
using a 4 x 4 matrix
M
43
Working with Representations

• Within the two frames any point or vector has a
  representation of the same form
• aa1 a2 a3 a4 in the first frame
• bb1 b2 b3 b4 in the second frame
• where a4 b4 1 for points and a4 b4 0 for
  vectors and
• The matrix M is 4 x 4 and specifies an affine
  transformation in homogeneous coordinates

aMTb
44
Frames and ADTs 1/3

• point3 p, qvector3 v, uIn C, through
  overloading,qpvup-qare valid,
  butqvupqare not!

45
Frames and ADTs 2/3

• typedef float point34
• typedef float point24 / making a 2D point a
  special 3D point /
• How do we initialize a point?
• p1.0, 2.0, 3.0
• / implementation dependent! /

46
Frames and ADTs 3/3

• Solutions
• initialize a point through a functionp
  new_point3(1.0, 2.0, 3.0)
• All operations are done through functionspoint3
  p, qvector3 v / frame f /v point_sub(p,
  q)/ v point_sub(p, q, f) /

47
Frames in OpenGL

• When we work with representations, we work with
  n-tuples or arrays of scalars
• Changes in frame are then defined by 4 x 4
  matrices
• In OpenGL, the base frame that we start with is
  the world frame
• Eventually we represent entities in the camera
  frame by changing the world representation using
  the model-view matrix
• Initially these frames are the same (MI)

48
Positioning the World Frame 1/2

• If objects are on both sides of z0, we should
  move the world frame

M
49
Positioning the World Frame 2/2
50
Modeling of a Colored Cube

• Modeling
• Converting to the camera frame
• Clipping
• Projecting
• Removing hidden surfaces
• Rasterizing

Demo
51
Objectives

• Introduce simple data structures for building
  polygonal models
• Vertex lists
• Edge lists
• OpenGL vertex arrays

52
Representing a Mesh
e2
v5

• Consider a mesh
• There are 8 nodes and 12 edges
• 5 interior polygons
• 6 interior (shared) edges
• Each vertex has a location vi (xi yi zi)

v6
e3
e9
e8
v8
v4
e1
e11
e10
v7
e4
e7
v1
e12
v2
v3
e6
e5
53
Simple Representation

• List all polygons by their geometric locations
• Leads to OpenGL code such as
• Inefficient and unstructured
• Consider moving a vertex to a new locations

glBegin(GL_POLYGON) glVertex3f(x1, x1, x1)
glVertex3f(x6, x6, x6) glVertex3f(x7, x7,
x7) glEnd()
54
Modeling of a Cube

• typedef GLfloat point33
• point3 vertices83 -1.0,-1.0,-1.0,1.0,-1.0
  ,-1.0,
• 1.0,1.0,-1.0, -1.0,1.0,-1.0, -1.0,-1.0,1.0,
• 1.0,-1.0,1.0, 1.0,1.0,1.0, -1.0,1.0,1.0
• glBegin(GL_POLYGON)
• glVertex3fv(vertices0)
• glVertex3fv(vertices3)
• glVertex3fv(vertices2)
• glVertex3fv(vertices1)
• glEnd()

OpenGL glVertex3f ? 4D form
55
Inward and Outward Facing Polygons

• The order v0, v3, v2, v1 and v1, v0, v3, v2
  are equivalent in that the same polygon will be
  rendered by OpenGL but the order v0, v1, v2,
  v3 is different
• The first two describe outwardly
• facing polygons
• Use the right-hand rule
• counter-clockwise encirclement
• of outward-pointing normal
• OpenGL treats inward and
• outward facing polygons differently

56
Geometry versus Topology

• Generally it is a good idea to look for data
  structures that separate the geometry from the
  topology
• Geometry locations of the vertices
• Topology organization of the vertices and edges
• Example a polygon is an ordered list of vertices
  with an edge connecting successive pairs of
  vertices and the last to the first
• Topology holds even if geometry changes

57
Vertex Lists

• Put the geometry in an array
• Use pointers from the vertices into this array
• Introduce a polygon list

,z0
Each location appears only once!
58
The Color Cube 1/3

• Model a color cube for rotating cube program
• Define global arrays for vertices and colors
• typedef GLfloat point33
• point3 vertices83 -1.0,-1.0,-1.0,1.0,-1.
  0,-1.0,
• 1.0,1.0,-1.0, -1.0,1.0,-1.0, -1.0,-1.0,1.0,
• 1.0,-1.0,1.0, 1.0,1.0,1.0, -1.0,1.0,1.0
• GLfloat colors83 0.0,0.0,0.0,1.0,0.0,0.0
  ,
• 1.0,1.0,0.0, 0.0,1.0,0.0, 0.0,0.0,1.0,
• 1.0,0.0,1.0, 1.0,1.0,1.0, 0.0,1.0,1.0

59
The Color Cube 2/3
void quad(int a, int b, int c , int d)
glBegin(GL_POLYGON) glColor3fv(colorsa)
glVertex3fv(verticesa)
glColor3fv(colorsb) glVertex3fv(vertices
b) glColor3fv(colorsc)
glVertex3fv(verticesc)
glColor3fv(colorsd) glVertex3fv(vertices
d) glEnd()
Color each vertex accordingly
60
The Color Cube 3/3

• void colorcube( )
• polygon(0,3,2,1)
• polygon(2,3,7,6)
• polygon(0,4,7,3)
• polygon(1,2,6,5)
• polygon(4,5,6,7)
• polygon(0,1,5,4)
• Note that vertices are ordered so that
• we obtain correct outward facing normals

5
6
2
1
7
4
0
3
61
Bilinear Interpolation
Assuming a linear variation, then we can make use
of the same interpolation coefficients in
coordinates for the interpolation of other
attributes.
62
Scan-line Interpolation

• A polygon is filled only when it is displayed
• It is filled scan line by scan line
• Can be used for other associated attributes with
  each vertex

63
Efficiency

• The weakness of our approach is that we are
  building the model in the application and must do
  many function calls to draw the cube
• Drawing a cube by its faces in the most straight
  forward way requires
• 6 glBegin, 6 glEnd
• 6 glColor
• 24 glVertex
• More if we use texture and lighting

64
Vertex Arrays

• OpenGL provides a facility called vertex arrays
  that allow us to store array data in the
  implementation
• Six types of arrays supported
• Vertices
• Colors
• Color indices
• Normals
• Texture coordinates
• Edge flags
• We will need only colors and vertices

65
Initialization

• Using the same color and vertex data, first we
  enable
• glEnableClientState(GL_COLOR_ARRAY)
• glEnableClientState(GL_VERTEX_ARRAY)
• Identify location of arrays
• glVertexPointer(3, GL_FLOAT, 0, vertices)
• glColorPointer(3, GL_FLOAT, 0, colors)

data array
data contiguous
3d arrays
stored as floats
66
Mapping Indices to Faces

• Form an array of face indices
• Each successive four indices describe a face of
  the cube
• Draw through glDrawElements which replaces all
  glVertex and glColor calls in the display
  callback

GLubyte cubeIndices24 0,3,2,1,2,3,7,6
0,4,7,3,1,2,6,5,4,5,6,7,0,1,5,4
67
Drawing the Cube
number of indices
what to draw

• Method 1
• Method 2

for(i0 ilt6 i) glDrawElements(GL_POLYGON, 4,
GL_UNSIGNED_BYTE, cubeIndices4i)
format of index data
start of index data
glDrawElements(GL_QUADS, 24,
GL_UNSIGNED_BYTE, cubeIndices)
Draws cube with 1 function call!!
68
General Transformations

• A transformation maps points to other points
  and/or vectors to other vectors

69
Linear Function (Transformation)
Transformation matrix for homogeneous coordinate
system
70
Affine Transformations 1/2

• Line preserving
• Characteristic of many physically important
  transformations
• Rigid body transformations rotation, translation
• Scaling, shear
• Importance in graphics is that we need only
  transform endpoints of line segments and let
  implementation draw line segment between the
  transformed endpoints

71
Affine Transformations 2/2

• Every linear transformation (if the corresponding
  matrix is nonsingular) is equivalent to a change
  in frames
• However, an affine transformation has only 12
  degrees of freedom because 4 of the elements in
  the matrix are fixed and are a subset of all
  possible 4 x 4 linear transformations

72
Translation

• Move (translate, displace) a point to a new
  location
• Displacement determined by a vector d
• Three degrees of freedom
• PPd

P
d
P
73
How Many Ways?

• Although we can move a point to a new location in
  infinite ways, when we move many points there is
  usually only one way

object
translation every point displaced by
same vector
74
Rotation (2D) 1/2

• Consider rotation about the origin by q degrees
• radius stays the same, angle increases by q

x r cos (f q) r cosf cosq - r sinf sinq y
r sin (f q) r cosf sinq r sinf cosq
x x cos q y sin q y x sin q y cos q
x r cos f y r sin f
75
Rotation (2D) 2/2

• Using the matrix form
• There is a fixed point
• Could be extended to 3D
• Positive direction of rotation is
  counterclockwise
• 2D rotation is equivalent to 3D rotation about
  the z-axis

76
(Non-)Rigid-Body Transformation

• Translation and rotation are rigid-body
  transformation

Non-rigid-bodytransformations
77
Scaling

• Expand or contract along each axis (fixed point
  of origin)

xsxx ysyx zszx
Uniform and non-uniform scaling
78
Reflection

• corresponds to negative scale factors

sx -1 sy 1
original
sx -1 sy -1
sx 1 sy -1
79
Transformation in Homogeneous Coordinates

• With a frame, each affine transformation is
  represented by a 4?4 matrix of the form

80
Translation

• Using the homogeneous coordinate representation
  in some frame
• p x y z 1T
• px y z 1T
• ddx dy dz 0T
• Hence p p d or
• xxdx
• yydy
• zzdz

note that this expression is in four dimensions
and expresses that point vector point
81
Translation Matrix

• We can also express translation using a
• 4 x 4 matrix T in homogeneous coordinates
• pTp where
• This form is better for implementation because
  all affine transformations can be expressed this
  way and multiple transformations can be
  concatenated together

82
Rotation about the Z axis

• Rotation about z axis in three dimensions leaves
  all points with the same z
• Equivalent to rotation in two dimensions in
  planes of constant z
• or in homogeneous coordinates
• pRz(q)p

xx cos q y sin q y x sin q y cos q zz
83
Rotation Matrix
84
Rotation about X and Y axes

• Same argument as for rotation about z axis
• For rotation about x axis, x is unchanged
• For rotation about y axis, y is unchanged

85
Scaling Matrix

• xsxx
• ysyx
• zszx
• pSp

86
Shear

• Helpful to add one more basic transformation
• Equivalent to pulling faces in opposite
  directions

87
Shear Matrix

• Consider simple shear
• along x axis

x x y cot q y y z z
88
Inverses

• Although we could compute inverse matrices by
  general formulas, we can use simple geometric
  observations
• Translation T-1(dx, dy, dz) T(-dx, -dy, -dz)
• Rotation R -1(q) R(-q)
• Holds for any rotation matrix
• Note that since cos(-q) cos(q) and
  sin(-q)-sin(q)
• R -1(q) R T(q)
• Scaling S-1(sx, sy, sz) S(1/sx, 1/sy, 1/sz)

89
Concatenation

• We can form arbitrary affine transformation
  matrices by multiplying together rotation,
  translation, and scaling matrices
• Because the same transformation is applied to
  many vertices, the cost of forming a matrix
  MABCD is not significant compared to the cost of
  computing Mp for many vertices p
• The difficult part is how to form a desired
  transformation from the specifications in the
  application

90
Order of Transformations

• Note that matrix on the right is the first
  applied
• Mathematically, the following are equivalent
• p ABCp A(B(Cp))
• Note many references use column matrices to
  present points. In terms of column matrices
• pT pTCTBTAT

91
Rotation about a Fixed Point and about the Z axis
f
?
92
Sequence of Transformations
93
General Rotation about the Origin

• A rotation by q about an arbitrary axis can be
  decomposed into the concatenation of rotations
  about the x, y, and z axes

R(q) Rx(?) Ry(?) Rz(?)
y
?, ?, ? are called the Euler angles
v
q
Note that rotations do not commute We can use
rotations in another order but with different
angles
x
z
94
Decomposition of General Rotation
?
?
?
95
The Instance Transformation

• In modeling, we often start with a simple object
  centered at the origin, oriented with the axis,
  and at a standard size
• We apply an instance transformation to its
  vertices to
• Scale
• Orient
• Locate
• Display lists

96
Rotation about an Arbitrary Axis 1/3
?
1. Move the fixed point to the origin
2. Rotate through a sequence of rotations
97
Rotation about an Arbitrary Axis 2/3
Final rotation matrix
?
?
?
?
Normalize u
?
?
98
Rotation about an Arbitrary Axis 3/3
Rotate the line segment to the plane of y0, and
the line segment is foreshortened to
?
?
?
?
?
?
?
Rotate clockwise about the y-axis, so
?
?
Final transformation matrix
99
OpenGL Matrices

• In OpenGL matrices are part of the state
• Three types
• Model-View (GL_MODEL_VIEW)
• Projection (GL_PROJECTION)
• Texture (GL_TEXTURE) (ignore for now)
• Single set of functions for manipulation
• Select which to manipulated by
• glMatrixMode(GL_MODEL_VIEW)
• glMatrixMode(GL_PROJECTION)

100
Current Transformation Matrix (CTM)

• Conceptually there is a 4 x 4 homogeneous
  coordinate matrix, the current transformation
  matrix (CTM) that is part of the state and is
  applied to all vertices that pass down the
  pipeline
• The CTM is defined in the user program and loaded
  into a transformation unit

C
pCp
p
CTM
vertices
vertices
101
CTM Operations

• The CTM can be altered either by loading a new
  CTM or by postmutiplication

Load an identity matrix C ? I Load an arbitrary
matrix C ? M Load a translation matrix C ?
T Load a rotation matrix C ? R Load a scaling
matrix C ? S Postmultiply by an arbitrary
matrix C ? CM Postmultiply by a translation
matrix C ? CT Postmultiply by a rotation matrix
C ? C R Postmultiply by a scaling matrix C ? C S
102
Rotation about a Fixed Point

• Start with identity matrix C ? I
• Move fixed point to origin C ? CT -1
• Rotate C ? CR
• Move fixed point back C ? CT
• Result C T -1RT
• Each operation corresponds to one function call
  in the program.
• Note that the last operation specified is the
  first executed in the program

103
CTM in OpenGL

• OpenGL has a model-view and a projection matrix
  in the pipeline which are concatenated together
  to form the CTM
• Can manipulate each by first setting the matrix
  mode

104
Rotation, Translation, Scaling
Load an identity matrix
glLoadIdentity()
Multiply on right
glRotatef(theta, vx, vy, vz)
theta in degrees, (vx, vy, vz) define axis of
rotation
glTranslatef(dx, dy, dz)
glScalef( sx, sy, sz)
Each has a float (f) and double (d) format
(glScaled)
105
Example

• Rotation about z axis by 30 degrees with a fixed
  point of (1.0, 2.0, 3.0)
• Remember that last matrix specified in the
  program is the first applied

glMatrixMode(GL_MODELVIEW) glLoadIdentity() glTr
anslatef(1.0, 2.0, 3.0) glRotatef(30.0, 0.0,
0.0, .10) glTranslatef(-1.0, -2.0, -3.0)
106
Using Transformations

• Example use idle function to rotate a cube and
  mouse function to change direction of rotation
• Start with a program that draws a cube (cube.c)
  in a standard way
• Centered at origin
• Sides aligned with axes
• Discussed modeling previously

107
main.c

• void main(int argc, char argv)
• glutInit(argc, argv)
• glutInitDisplayMode(GLUT_DOUBLE GLUT_RGB
  GLUT_DEPTH)
• glutInitWindowSize(500, 500)
• glutCreateWindow("cube")
• glutReshapeFunc(myReshape)
• glutDisplayFunc(display)
• glutIdleFunc(spinCube)
• glutMouseFunc(mouse)
• glEnable(GL_DEPTH_TEST)
• glutMainLoop()

108
Idle and Mouse Callbacks

• void spinCube()
• thetaaxis 2.0
• if( thetaaxis gt 360.0 ) thetaaxis - 360.0
• glutPostRedisplay()
• void mouse(int btn, int state, int x, int y)
• if(btnGLUT_LEFT_BUTTON state
  GLUT_DOWN)
• axis 0
• if(btnGLUT_MIDDLE_BUTTON state
  GLUT_DOWN)
• axis 1
• if(btnGLUT_RIGHT_BUTTON state
  GLUT_DOWN)
• axis 2

109
Display Callback

• void display()
• glClear(GL_COLOR_BUFFER_BIT
  GL_DEPTH_BUFFER_BIT)
• glLoadIdentity()
• glRotatef(theta0, 1.0, 0.0, 0.0)
• glRotatef(theta1, 0.0, 1.0, 0.0)
• glRotatef(theta2, 0.0, 0.0, 1.0)
• colorcube()
• glutSwapBuffers()

Note that because of fixed from of callbacks,
variables such as theta and axis must be
defined as globals Camera information is in
standard reshape callback
110
Arbitrary Matrices

• Can load and multiply by matrices defined in the
  application program
• The matrix m is a one dimension array of 16
  elements which are the components of the desired
  4 x 4 matrix stored by columns
• In glMultMatrixf, m multiplies the existing
  matrix on the right

glLoadMatrixf(m) glMultMatrixf(m)
111
Matrix Stacks

• In many situations we want to save transformation
  matrices for use later
• Traversing hierarchical data structures (Chapter
  9)
• Avoiding state changes when executing display
  lists
• OpenGL maintains stacks for each type of matrix
• Access present type (as set by glMatrixMode) by

glPushMatrix() glPopMatrix()
112
Reading Back Matrices

• Can also access matrices (and other parts of the
  state) by enquiry (query) functions
• For matrices, we use as

glGetIntegerv glGetFloatv glGetBooleanv glGetDoubl
ev glIsEnabled
double m16 glGetFloatv(GL_MODELVIEW, m)
113
Using the Model-View Matrix

• In OpenGL the model-view matrix is used to
• Position the camera
• Can be done by rotations and translations but is
  often easier to use gluLookAt (Chapter 5)
• Build models of obejcts
• The projection matrix is used to define the view
  volume and to select a camera lens
• Although both are manipulated by the same
  functions, we have to be careful because
  incremental changes are always made by
  postmultiplication
• For example, rotating model-view and projection
  matrices by the same matrix are not equivalent
  operations. Postmultiplication of the model-view
  matrix is equivalent to premultiplication of the
  projection matrix

114
Interfaces to 3D Applications

• One of the major problems in interactive computer
  graphics is how to use two-dimensional devices
  such as a mouse to interface with three
  dimensional objects
• Example how to form an instance matrix?
• Some alternatives
• Virtual trackball
• 3D input devices such as the spaceball
• Use areas of the screen
• Distance from center controls angle, position,
  scale depending on mouse button depressed

115
Using Areas of the Screen

• Each button controls rotation, scaling and
  translation, separately
• Example
• Left button closer to the center, no rotation,
  moving up or down, rotate about x-axis, moving
  left or right, rotate about y-axis, moving to the
  corner, rotate about x-y-axes
• Right button translation
• Middle button scaling (zoom-in or zoom-out)

116
Physical Trackball

• The trackball is an upside down mouse
• If there is little friction between the ball and
  the rollers, we can give the ball a push and it
  will keep rolling yielding continuous changes
• Two possible modes of operation
• Continuous pushing or tracking hand motion
• Spinning

117
A Trackball from a Mouse

• Problem we want to get the two behavior modes
  from a mouse
• We would also like the mouse to emulate a
  frictionless (ideal) trackball
• Solve in two steps
• Map trackball position to mouse position
• Use GLUT to obtain the proper modes

118
Trackball Frame
origin at center of ball
119
Projection of Trackball Position

• We can relate position on trackball to position
  on a normalized mouse pad by projecting
  orthogonally onto pad

120
Reversing Projection

• Because both the pad and the upper hemisphere of
  the ball are two-dimensional surfaces, we can
  reverse the projection
• A point (x,z) on the mouse pad corresponds to the
  point (x,y,z) on the upper hemisphere where

y
if r ? x? 0, r ? z ? 0
121
Computing Rotatoins

• Suppose that we have two points that were
  obtained from the mouse.
• We can project them up to the hemisphere to
  points p1 and p2
• These points determine a great circle on the
  sphere
• We can rotate from p1 to p
• by finding the proper axis of rotation and the
  angle between the points

122
Using the Cross Product

• The axis of rotation is given by the normal to
  the plane determined by the origin, p1 , and p2

n p1 ? p1
123
Obtaining the Angle

• The angle between p1 and p2 is given by
• If we move the mouse slowly or sample its
  position frequently, then q will be small and we
  can use the approximation

sin q
sin q ? q
124
Implementing with GLUT

• We will use the idle, motion, and mouse callbacks
  to implement the virtual trackball
• Define actions in terms of three booleans
• trackingMouse if true update trackball position
• redrawContinue if true, idle function posts a
  redisplay
• trackballMove if true, update rotation matrix

125
Example

• In this example, we use the virtual trackball to
  rotate the color cube we modeled earlier
• The code for the colorcube function is omitted
  because it is unchanged from the earlier examples

126
Initialization

• define bool int / if system does not support
• bool type /
• define false 0
• define true 1
• define M_PI 3.14159 / if not in math.h /
• int winWidth, winHeight
• float angle 0.0, axis3, trans3
• bool trackingMouse false
• bool redrawContinue false
• bool trackballMove false
• float lastPos3 0.0, 0.0, 0.0
• int curx, cury
• int startX, startY

127
The Projection Step

• voidtrackball_ptov(int x, int y, int width, int
  height, float v3)
• float d, a
• / project x,y onto a hemisphere centered
  within width, height , note z is up here/
• v0 (2.0Fx - width) / width
• v1 (height - 2.0Fy) / height
• d sqrt(v0v0 v1v1)
• v2sqrt(1.0F-dd)
• / v2 cos((M_PI/2.0) ((d lt 1.0) ? d
  1.0))
• a 1.0 / sqrt(v0v0 v1v1
  v2v2)
• v0 a v1 a v2 a /

128
glutMotionFunc 1/2

• void mouseMotion(int x, int y)
• float curPos3,
• dx, dy, dz
• / compute position on hemisphere /
• trackball_ptov(x, y, winWidth, winHeight,
  curPos)
• if(trackingMouse)
• / compute the change in position
• on the hemisphere /
• dx curPos0 - lastPos0
• dy curPos1 - lastPos1
• dz curPos2 - lastPos2

129
glutMotionFunc 2/2

• if (dx dy dz)
• / compute theta and cross product /
• angle 90.0 sqrt(dxdx dydy dzdz)
• axis0 lastPos1curPos2
• lastPos2curPos1
• axis1 lastPos2curPos0
• lastPos0curPos2
• axis2 lastPos0curPos1
• lastPos1curPos0
• / update position /
• lastPos0 curPos0
• lastPos1 curPos1
• lastPos2 curPos2
• glutPostRedisplay()

130
Idle and Display Callbacks

• void spinCube()
• if (redrawContinue) glutPostRedisplay()
• void display()
• glClear(GL_COLOR_BUFFER_BIT
  GL_DEPTH_BUFFER_BIT)
• if (trackballMove)
• glRotatef(angle, axis0, axis1, axis2)
• colorcube()
• glutSwapBuffers()

131
Mouse Callback

• void mouseButton(int button, int state, int x,
  int y)
• if(buttonGLUT_RIGHT_BUTTON) exit(0)
• / holding down left button
• allows user to rotate cube /
• if(buttonGLUT_LEFT_BUTTON) switch(state)
• case GLUT_DOWN
• ywinHeight-y
• startMotion( x,y)
• break
• case GLUT_UP
• stopMotion( x,y)
• break

132
Start Function

• void startMotion(int x, int y)
• trackingMouse true
• redrawContinue false
• startX x
• startY y
• curx x
• cury y
• trackball_ptov(x, y, winWidth, winHeight,
  lastPos)
• trackballMovetrue

133
Stop Function

• void stopMotion(int x, int y)
• trackingMouse false
• / check if position has changed /
• if (startX ! x startY ! y)
• redrawContinue true
• else
• angle 0.0
• redrawContinue false
• trackballMove false

134
Smooth Rotation 1/2

• From a practical standpoint, we are often want to
  use transformations to move and reorient an
  object smoothly
• Problem find a sequence of model-view matrices
  M0,M1,..,Mn so that when they are applied
  successively to one or more objects we see a
  smooth transition, cannot always decompose a
  rotation into three rotations about the x, y, and
  z axes
• For orientating an object, we can use the fact
  that every rotation corresponds to part of a
  great circle on a sphere
• Find the axis of rotation and angle
• Virtual trackball

135
Smooth Rotation 2/2

• Observe that for arbitrary rotation matrix R,
  there must exist a direction d such that all the
  points on Rpp, and Rdd, therefore the vector d
  and the column matrix p are eigen vectors of the
  matrix R corresponding to the eigen value 1!

136
Incremental Rotation 1/4

• Consider the two approaches
• For a sequence of rotation matrices R0,R1,..,Rn
  , find the Euler angles for each and use Ri Riz
  Riy Rix
• Not very efficient
• Use the final positions to determine the axis and
  angle of rotation, then increment only the angle
• Quaternions can be more efficient than either

137
Incremental Rotation 2/4

• for(i0 ilt imax i)
• glRotatef(delta_theta, dx, dy, dz)
• draw_objects()
• Problem calculation of sin and cos of angles

138
Incremental Rotation 3/4

• A better solution is to reuse the matrix
• GLfloat m16
• glRotatef(delta_theta, dx, dy, dz)
• glGetFloatv(GL_MODELVIEW,m)
• for(i0 ilt imax i)
• glMultMatrixf(m)
• draw_objects()

139
Incremental Rotation 4/4

• Further improvement by approximations

So, if we form an arbitrary rotation matrix
through the Euler angles
140
Complex Numbers

• Eulers identity

For an arbitrary complex number c
If we rotate c about the origin by ? to c
141
Quaternions

• Extension of imaginary numbers from two to three
  dimensions
• Requires one real and three imaginary components
  i, j, k
• Quaternions can express rotations on sphere
  smoothly and efficiently. Process
• Model-view matrix ? quaternion
• Carry out operations with quaternions
• Quaternion ? Model-view matrix

qq0q1iq2jq3k
142
Quaternions Properties
143
Quaternions and Rotation
144
Example of using Quaternion Rotation
145
Quaternions and Rotation Matrix
146
The Rotation Matrix in the Textbook
147
Quaternions

• Because the rotations are on the surface of a
  sphere, quaternions provide an interesting and
  more efficient way to implement the trackball
• See code in some of the standard demos included
  with Mesa