Introduction to Computer Graphics

Assignment 1
3D Primitives and Transformations

OpenGL: Front/Back Rendering

Each polygon has two sides, front and back
OpenGL can render the two differently
The ordering of vertices in the list determines
which is the front side:
When looking at the front side, the vertices go
counterclockwise
This is basically the right-hand rule
Note that this still holds after perspective projection

OpenGL: Specifying Geometry

Geometry in OpenGL consists of a list of vertices in
between calls to glBegin() and glEnd()
A simple example: telling GL to render a triangle
glBegin(GL_POLYGON);
glVertex3f(x1, y1, z1);
glVertex3f(x2, y2, z2);
glVertex3f(x3, y3, z3);
glEnd();
Usage: glBegin(geomtype) where geomtype is:
Points, lines, polygons, triangles, quadrilaterals, etc...

OpenGL: Drawing Triangles

You can draw multiple triangles between
glBegin(GL_TRIANGLES) and glEnd():
float v1[3], v2[3], v3[3], v4[3];
...
glBegin(GL_TRIANGLES);
glVertex3fv(v1); glVertex3fv(v2); glVertex3fv(v3);
glVertex3fv(v1); glVertex3fv(v3); glVertex3fv(v4);
glEnd();

Each set of 3 vertices forms a triangle

How much redundant computation is happening?

OpenGL: Triangle Strips

An OpenGL triangle strip primitive reduces this redundancy by sharing vertices:
glBegin(GL_TRIANGLE_STRIP);
glVertex3fv(v0);
glVertex3fv(v1);

v2

glVertex3fv(v2);
glVertex3fv(v3);

v0

v4

glVertex3fv(v4);

v5

glVertex3fv(v5);
glEnd();

v1

triangle 0 is v0, v1, v2

triangle 1 is v2, v1, v3 (why not v1, v2, v3?)

triangle 2 is v2, v3, v4

triangle 3 is v4, v3, v5 (again, why not v3, v4, v5)

v3

OpenGL: More Examples

Example: GL supports quadrilaterals:
glBegin(GL_QUADS);
glVertex3f(-1, 1, 0);
glVertex3f(-1, -1, 0);
glVertex3f(1, -1, 0);
glVertex3f(1, 1, 0);
glEnd();
This type of operation is called immediate-mode rendering;
each command happens immediately

Primitive Types
GL_POINTS
GL_LINE
{S | _STRIP | _LOOP}

GL_TRIANGLE
{S | _STRIP | _FAN}

GL_QUAD
{S | _STRIP}

GL_POLYGON

GL_POLYGON
List of vertices defines polygon edges
Polygon must be convex

Non-planar Polygons
Imagine polygon with non-planar vertices
Some perspectives will be rendered as concave
polygons
These concave polygons may not rasterize
correctly

Single Buffering
Buffer corresponds to frame buffer
Single corresponds to there being just one
Place where you write pixel color values is same place
graphics hardware goes to read color values for display
Can draw on top of existing image
Might be faster than redrawing whole image
Can also lead to flickering and half-drawn images

Double Buffering
OpenGL writes raster image to separate buffer from that read for
display
front buffer is for video signal
back buffer is the drawing target
After each frame is drawn, the front and back buffers swap
glxSwapBuffers (Display *dpy, Window, w)
glutSwapBuffers (void)
Avoids displaying partially rendered frame buffer
Avoids flickering

Setting up the OpenGL Window

Must clear the canvas before drawing
glClearColor (r, g, b, )
Specify the color to initialize canvas to
Typically set to 0.0 to make fully transparent
This is a state variable and can only be called once
glClear(GL_COLOR_BUFFER_BIT)
Actually clear the screen
glClear could also clear the GL_DEPTH_BUFFER_BIT
Were not worried about that now

Scaling and Translation in 3-D

Pretty much just like 2-D

Just add on the z dimension to
everything

r
0

0 0 0
s 0 0
0 t 0

0 0 1

Scaling
1
0

0
1
0
0

0 x
0 y
1 z

0 1

Translation

Rotation in 3-D
Looks similar to 2-D Case
Specify arbitrray rotation as
three angles
One per coordinate axis
Called an Euler Angle
Common representation

Rotation x

0
1
0 cos

0
sin

0 sin

0
0

cos
0
Rotation y
sin

0
cos
sin

But order of rotations matters

Rotation z

0
0

cos
0
0 sin
1
0
0 cos
0
0

sin
cos
0
0

0
0

1
0
0
0

0 0
0 0
1 0

0 1

3-D Rotation
General rotations in 3-D require rotating about an
arbitrary axis of rotation
Deriving the rotation matrix for such a rotation
directly is a good exercise in linear algebra
Standard approach: express general rotation as
composition of canonical rotations
Rotations about X, Y, Z

Composing Canonical Rotations

Goal: rotate about arbitrary vector A by
Idea: we know how to rotate about X,Y,Z
So, rotate about Y by until A lies in the YZ plane
Then rotate about X by until A coincides with +Z
Then rotate about Z by
Then reverse the rotation about X (by -)
Then reverse the rotation about Y (by -)

Composing Canonical Rotations

First: rotating about Y by until A lies in YZ
How exactly do we calculate ?
Project A onto XZ plane (Throw away y-coordinate)
Find angle to X:

= -(90 - ) = - 90

Second: rotating about X by until A lies on Z

How do we calculate ?

Composing Canonical Rotations

Why are we slogging through all this tedium?
A1: Because youll have to do it on the test
A2: Because it will help with the assignment
Computing intersection between a parabola and ground
plane
y+

dist = ?

3-D Rotation Matrices

So an arbitrary rotation about A composes several
canonical rotations together
We can express each rotation as a matrix
Composing transforms == multiplying matrices
Thus we can express the final rotation as the product of
canonical rotation matrices
Thus we can express the final rotation with a single
matrix!

Composing Matrices
So we have the following matrices:
p: The point to be rotated about A by
Ry : Rotate about Y by
Rx : Rotate about X by
Rz : Rotate about Z by
Rx -1: Undo rotation about X by
Ry-1 : Undo rotation about Y by
In what order should we multiply them?

Compositing Matrices
Short answer: the transformations, in order, are
written from right to left
In other words, the first matrix to affect the vector goes next
to the vector, the second next to the first, etc.

So in our case:
p = Ry-1 Rx -1 Rz Rx Ry p

Rotation Matrices
Notice these two matrices:
Rx : Rotate about X by
Rx -1: Undo rotation about X by
How can we calculate Rx -1?

Rotation Matrices
Notice these two matrices:
Rx : Rotate about X by
Rx -1: Undo rotation about X by
How can we calculate Rx -1?
Obvious answer: calculate Rx (-)
Clever answer: exploit fact that rotation matrices are
orthonormal

Rotation Matrices
Notice these two matrices:
Rx : Rotate about X by
Rx -1: Undo rotation about X by
How can we calculate Rx -1?
Obvious answer: calculate Rx (-)
Clever answer: exploit fact that rotation matrices are orthonormal

What is an orthonormal matrix?

What property are we talking about?

Rotation Matrices
Orthonormal matrix:
orthogonal (columns/rows linearly independent)
normalized (columns/rows length of 1)

The inverse of an orthogonal matrix is just its

transpose:
a
d

e
i

f
j

d
h

e
i

f
j

b
c

e
f

i
j

Rotation Matrix
9 DOFs must reduce to 3
Rows must be unit length (-3 DOFs)
Rows must be orthogonal (-3 DOFs)
Drifting matrices is very bad
Numerical errors results when trying to gradually rotate matrix
by adding derivatives
Resulting matrix may scale / shear
Gram-Schmidt algorithm will re-orthogonalize your matrix

Difficult to interpolate between matrices

Euler Angles
( x, y, z) = RzRyRx
Rotate x degrees about x-axis
Rotate y degrees about y-axis
Rotate z degrees about z-axis

Axis order is not defined

(y, z, x), (x, z, y), (z, y, x)
are all legal
Pick one

Euler Angles
Rotations not uniquely defined
ex: (z, x, y) = (90, 45, 45) = (45, 0, -45)
takes positive x-axis to (1, 1, 1)
cartesian coordinates are independent of one another, but
Euler angles are not

Gimbal Lock
Term derived from mechanical problem that arises in
gimbal mechanism that supports a compass or a gyro

Gimbal Lock

Gimbal Lock
Occurs when two axes are
aligned
Second and third rotations
have effect of transforming
earlier rotations
ex: Rot x, Rot y, Rot z
If Rot y = 90 degrees, Rot z ==
-Rot x