Transformations With OpenGL

1
Transformations With OpenGL

• Courtesy of Drs. Carol OSullivan / Yann Morvan
• Trinity College Dublin

2
Open GL Primitives
3
OpenGL

• To create a red polygon with 4 vertices
• glBegin defines a geometric primitive
• GL_POINTS, GL_LINES, GL_LINE_LOOP, GL_TRIANGLES,
  GL_QUADS, GL_POLYGON
• All vertices are 3D and defined using glVertex

glColor3f(1.0, 0.0, 0.0) glBegin(GL_POLYGON)
glVertex3f(0.0, 0.0, 3.0) glVertex3f(1.0, 0.0,
3.0) glVertex3f(1.0, 1.0, 3.0)
glVertex3f(0.0, 1.0, 3.0) glEnd()
4
OpenGL

• We can use per-vertex information.
• To create the RG colour square

glShadeModel(GL_SMOOTH) glBegin(GL_POLYGON)
glColor3f(1.0, 0.0, 0.0) // Red
glVertex3f(0.0, 0.0, 3.0) glColor3f(0.0, 0.0,
0.0) // Black glVertex3f(1.0, 0.0, 3.0)
glColor3f(0.0, 1.0, 0.0) // Green
glVertex3f(1.0, 1.0, 3.0) glColor3f(1.0, 1.0,
0.0) // Yellow glVertex3f(0.0, 1.0,
3.0) glEnd()
5
Geometric Transformations

• Many geometric transformations are linear and can
  be represented as a matrix multiplication.
• Function f is linear iff
• Implications to transform a line we transform
  the end-points. Points between are affine
  combinations of the transformed endpoints.
• Given line defined by points P and Q, points
  along transformed line are affine combinations of
  transformed P? and Q?

6
Homogeneous Co-ordinates

• Basis of the homogeneous co-ordinate system is
  the set of n basis vectors and the origin
  position
• All points and vectors are therefore compactly
  represented using their ordinates

7
Co-ordinate Frame

• A Frame is a point P0 (the origin) and a set of
  vectors vn which define the basis for the vector
  space (the axes).
• Vectors of the frame take the form
• Points defined using the frame are given as
• Vectors are uniquely defined using the ordinates
  an but points require extra information (i.e. the
  origin)
• In computer graphics we use homogeneous
  co-ordinates to express vector and affine
  quantities and transformations.

8
Homogeneous Co-ordinates

• Vectors have no positional information and are
  represented using ao 0 whereas points are
  represented with ao 1
• Examples

Points
Associated vectors
9
Scale

• all vectors are scaled from the origin

Original
scale all axes
scale Y axis
offset from origin
distance from origin also scales
10
Rotation

• Rotations are anti-clockwise about the origin

rotation of 45o about the Z axis
offset from origin rotation
11
Rotation
12
Rotation

• 2D rotation of q about origin
• 3D homogeneous rotations
• Note
• If M-1 MT then M is orthonormal. All
  orthonormal matrices are rotations about the
  origin.

13
Scale
We would also like to scale points thus we need
a homogeneous transformation for consistency
14
Shear

• We shear along an axis according to another axis
  
• Shearing along X axis preserves y and z values.
• Shearing along Y axis preserves x and z values
• Shearing along Z axis preserves x and y values
• Point are stretched along the shear axis in
  proportion to the distance of the point along
  another axis.
• Example shearing along X according to Y

15
Shear
original
shear along x (by y)
shear along x (by z)
16
Translation

• Translation only applies to points, we never
  translate vectors.
• Remember points have homogeneous co-ordinate w
  1

translate along y
17
Affine Transformations

• All affine transformations are combinations of
  rotations, scaling and translations.
• Shear rotation followed by a scale
• Affine transformations preserve
• Collinearity
• Ratios of distances along a line (therefore
  parallelism)

18
Transformation Composition

• More complex transformations can be created by
  concatenating or composing individual
  transformations together.
• Matrix multiplication is non-commutative ? order
  is vital
• We can create an affine transformation
  representing rotation about a point PR
• translate to origin, rotate about origin,
  translate back to original location

19
Transformation Composition
20
Transformation Composition
Rotation in XY plane by q degrees anti-clockwise
about point P
21
Euler Angles

• Euler angles represent the angles of rotation
  about the co-ordinate axes required to achieve a
  given orientation (qx, qy, qz)
• The resulting matrix is
• Any required rotation may be described (though
  not uniquely) as a composition of 3 rotations
  about the coordinate axes.
• Remember rotation does not commute ?? order is
  important
• A frequent requirement is to determine the matrix
  for rotation about an given axis.
• Such rotations have 3 degrees of freedom (DOF)
• 2 for spherical angles specifying axis
  orientation
• 1 for twist about the rotation axis

22
Rotational DOF
Sometimes known as roll, pitch and yaw
23
Rotation about an axis
24
Rotation about an axis

• Assume axis is defined by points P and Q
  therefore pivot point is P and rotation axis
  vector is
• First we translate the pivot point to the origin
  ? T(-P)
• Now we determine a series of rotations to achieve
  the required rotation about the desired vector.
• This is conceptually simpler if we first rotate
  the axis and object so that the axis lines up
  with z say ? R(qy)R(qx)
• Now we rotate about z by the required angle q ?
  R(q)

25
Rotation about an axis

• Then we undo the first 2 rotations to bring us
  back to the original orientation ? R(-qx)R(-qy)
• Finally we translate back to the original
  position ? T(P)
• The final rotation matrix is
• We need to determine Euler angles qx and qy which
  will orient the rotation axis along the z axis.
• We determine these using simple trigonometry.

26
Aligning axis with z
qy
y
x
vz
qy
r
vx
vz
vy
vp
vx
qx
z
vz
vx
qy
27
Aligning axis with z

• Note that as shown the rotation about the x axis
  is anti-clockwise but the y axis rotation is
  clockwise.
• Therefore the required y axis rotation is -qy ?

28
Spherical Co-ordinates

• The set of all normal vectors define a unit
  sphere which is usually used to encode the set of
  all directions.
• Each normal vector now has only 2 degrees of
  freedom usually denoted using spherical
  co-ordinates (angles) (q, f)

29
Normal Vectors

• It is frequently useful to determine the
  relationship between the spherical co-ordinate
  and the vector

30
Transformations and OpenGL

• glRotatef(angle, vx, vy, vz)
• rotates about axis (vx, vy, vz) by angle
  (specified in degrees)
• glTranslate(dx, dy, dz)
• translates by displacement vector (dx, dy, dz)
• glScalef(sx, sy, sz)
• apply scaling of sx in x direction, sy in y
  direction and sz in z direction (note that these
  values specify the diagonal of a required matrix)
• glLoadIdentity()
• creates an identity matrix (used for clearing all
  transformations)
• glLoadMatrixf(matrixptr)
• loads a user specified transformation matrix
  where matrixptr is defined as GLfloat
  matrixptr16

31
Transformations and OpenGL

• OpenGL defines 3 matrices for manipulation of 3D
  scenes
• GL_MODELVIEW manipulates the view and models
  simultaneously
• GL_PROJECTION performs 3D 2D projection for
  display
• GL_TEXTURE for manipulating textures prior to
  mapping on objects
• Each acts as a state parameter once set it
  remains until altered.
• Having defined a GL_MODELVIEW matrix, all
  subsequent vertices are created with the
  specified transformation.
• Matrix transformation operations apply to the
  currently selected system matrix
• use glMatrixMode(GL_MODELVIEW) to select modeling
  matrix

32
Transformations and OpenGL
Vertex Geometry Pipeline
MODELVIEW matrix
PROJECTION matrix
perspective division
viewport transformation
original vertex
final window coordinates
normalised device coordinates (foreshortened)
2d projection of vertex onto viewing plane
vertex in the eye coordinate space
33
Transformations and OpenGL

• The MODELVIEW matrix is a 4x4 affine
  transformation matrix and therefore has 12
  degrees of freedom
• The MODELVIEW matrix is used for both the model
  and the camera transformation
• rotating the model is equivalent to rotating the
  camera in the opposite direction ? OpenGL uses
  the same transformation matrix
• this sometimes causes confusion!

34
Transformations and OpenGL

• Each time an OpenGL transformation M is called
  the current MODELVIEW matrix C is altered

glTranslatef(1.5, 0.0, 0.0) glRotatef(45.0, 0.0,
0.0, 1.0)
35
Transformations and OpenGL

• Transformations are applied in the order
  specified (with respect to the vertex) which
  appears to be in reverse

glMatrixMode(GL_MODELVIEW) glLoadIdentity() glTr
anslatef(1.5, 0.0, 0.0) glRotatef(45.0, 0.0,
0.0, 1.0) glVertex3f(1.0, 0.0, 0.0)
original
rotate
translate
36
Camera Model Transformations

• Given that camera and model transformations are
  specified using a single matrix we must consider
  the effect of these transformations on the
  coordinate frames of the camera and models.
• Assume we wish to orbit an object at a fixed
  orientation
• translate object away from camera
• rotate around X to look at top of object
• then pivot around objects Y in order to orbit
  properly.

37
Camera Model Transformations

• If the GL_MODELVIEW matrix is an identity matrix
  then the camera frame and the model frame are the
  same.
• i.e. they are specified using the same
  co-ordinate system
• If we issue command glTranslatef(0.0, 0.0, -10.0)
  and then create the model
• a vertex at 0, 0, 0 in the model will be at 0,
  0, -10 in the camera frame
• i.e. we have moved the object away from the
  camera
• This may be viewed conceptually in 2 ways
• we have positioned the object with respect to the
  world frame
• we have moved the world-frame with respect to the
  camera frame

38
Camera Model Transformations
objects new Y
rotate
translate
39
Camera Model Transformations

• A local frame view is usually adopted as it
  extends naturally to the specification of
  hierarchical model frames.
• This allows creation of jointed assemblies
• articulated figures (animals, robots etc.)
• In the hierarchical model, each sub-component has
  its own local frame.
• Changes made to the parent frame are propagated
  down to the child frames (thus all models in a
  branch are globally controlled by the parent).
• This simplifies the specification of animation.

40
Aside Display Lists

• It is often expensive to compute or create a
  model for display.
• we would prefer not to have to recalculate it
  each time for each new animation frame.
• Display lists allow the creation of an object in
  memory, where it resides until destroyed.
• Objects are drawn by issuing a request to the
  server to display a given display list.

number of list IDs to create
list glGenLists(1) glNewList(list,
GL_COMPILE) create_model() glEndList() glCallL
ist(list) glDeleteLists(list, 1)
begin specification of the list
GLint of first list ID
user specified model code
used later to display the list
delete when finished (specifying number of lists)
41
Model Transformations

• As the MODELVIEW matrix is changed objects are
  created with respect to a changing
  transformation.
• This is often termed the current transformation
  matrix or CTM.
• The CTM behaves like a 3D pointer, selecting new
  positions and orientations for the creation of
  geometries.
• The only complication with this view is that each
  new CTM is derived from a previous CTM, i.e. all
  CTMs are specified relative to previous versions.
• A scaling transformation can cause some confusion.

42
Scaling Transformation and the CTM
glMatrixMode(GL_MODELVIEW) glLoadIdentity() glTr
anslatef(3, 0, 0) glTranslatef(1, 0,
0) gluCylinder()
glMatrixMode(GL_MODELVIEW) glLoadIdentity() glTr
anslatef(3, 0, 0) glScalef(0.5, 0.5,
0.5) glTranslatef(1, 0, 0) gluCylinder()
43
Hierarchical Transformations

• For geometries with an implicit hierarchy we wish
  to associate local frames with sub-objects in the
  assembly.
• Parent-child frames are related via a
  transformation.
• Transformation linkage is described by a tree
• Each node has its own local co-ordinate system.

44
Hierarchical Transformations
R
R
R
T
Hierarchical transformation allow independent
control over sub-parts of an assembly
45
translate base
rotate joint1
rotate joint2
complex hierarchical transformation
46
OpenGL Implementation
glMatrixMode(GL_MODELVIEW) glLoadIdentity() glTr
anslatef(bx, by, bz) create_base() glTranslat
ef(0, j1y, 0) glRotatef(joint1_orientation)
create_joint1() glTranslatef(0, uay, 0)
create_upperarm() glTranslatef(0,
j2y) glRotatef(joint2_orientation)
create_joint2() glTranslatef(0, lay, 0)
create_lowerarm() glTranslatef(0, py,
0) glRotatef(pointer_orientation)
create_pointer()
47
Hierarchical Transformations

• The previous example had simple one-to-one
  parent-child linkages.
• In general there may be many child frames derived
  from a single parent frame.
• we need some mechanism to remember the parent
  frame and return to it when creating new
  children.
• OpenGL provide a matrix stack for just this
  purpose
• glPushMatrix() saves the CTM
• glPopMatrix() returns to the last saved CTM

48
Hierarchical Transformations
Each finger is a child of the parent (wrist) ?
independent control over the orientation of the
fingers relative to the wrist
49
Hierarchical Transformations
50
glMatrixMode(GL_MODELVIEW) glLoadIdentity() glTr
anslatef(bx, by, bz) create_base() glTranslat
ef(0, jy, 0) glRotatef(joint1_orientation)
create_joint1() glTranslatef(0, ay, 0)
create_upperarm() glTranslatef(0,
wy) glRotatef(wrist_orientation)
create_wrist() glPushMatrix() // save frame
glTranslatef(-xf, fy0, 0) glRotatef(lowerfinge
r1_orientation) glTranslatef(0, fy1, 0)
create_lowerfinger1() glTranslatef(0, fy2,
0) glRotatef(upperfinger1_orientation)
create_fingerjoint1() glTranslatef(0, fy3,
0) create_upperfinger1() glPopMatrix() //
restore frame glPushMatrix() // do finger
2... glPopMatrix() glPushMatrix() // do
finger 3... glPopMatrix()
Finger1
51
OpenGL Objects GLU

• GLU provides functionality for the creation of
  quadric surfaces
• spheres, cones, cylinders, disks
• A quadric surface is defined by the following
  implicit equation

use to initialise a quadric
GLUquadricObj gluNewQuadric(void) gluDeleteQuadr
ic(GLYquadricObj obj)
delete when finished
52
OpenGL Objects GLU Spheres
void gluSphere(GLUquadricObj obj, double radius,
int slices, int stacks)
gluSphere(obj, 1.0, 5, 5)
gluSphere(obj, 1.0, 10, 10)
gluSphere(obj, 1.0, 20, 20)
53
Other GLU Quadrics
void gluCylinder(GLUquadricObj obj, double
base_radius, double top_radius, double height,
int slices, int stacks)
gluCylinder(obj, 1.0, 1.0, 2.0, 20, 8)
gluCylinder(obj, 1.0, 1.0, 2.0, 8, 8)
gluCylinder(obj, 1.0, 0.3, 2.0, 20, 8)
54
Other GLU Quadrics
void gluDisk(GLUquadricObj obj, double
inner_radius, double outer_radius, int slices,
int rings)
gluCylinder(obj, 1.0, 0.0, 2.0, 20, 8)
gluDisk(obj, 0.0, 2.0, 10, 3)
gluDisk(obj, 0.5, 2.0, 10, 3)
55
OpenGL Objects GLUT
void glutSolidTorus(double inner_radius, double
outer_radius, int nsides, int rings)
glutWireTeapot(1.0)
glutWireTorus(0.3, 1.5, 20, 20)
size
glutSolidTorus(0.3, 1.5, 20, 20)
glutSolidTeapot(1.0)
glutSolidDodecahedron()