Lecture 4: Transformations
and Matrices
CSE 40166 Computer Graphics (Fall
2010)
Overall Objective
Define object in object frame
Move object to world/scene frame
Bring object into camera/eye frame
Instancing!
Graphics... how does it work?
Linear Algebra and geometry (magical math)
Frames are represented by tuples and we change frames
(representations) through the use of matrices.
In OpenGL, vertices are modified by the Current
Transformation Matrix (CTM)
4x4 homogeneous coordinate matrix that is part of the state and
applied to all vertices that pass down the pipeline.
Basic Geometric Elements
Scalars: members of sets which can be combined by two
operations (addition, multiplication).
Real numbers.
No geometric properties.
Vectors: a quantity with both direction and magnitude.
Forces, velocity
Synonymous with directed line segment
Has no fixed location in space
Points: location in space. (neither size nor shape).
Basic Geometric Operations
Vector Operations
Dot Product
Viewed as projection of one vector on another
Cross Product
Result is vector perpendicular to originals
(images from wikipedia)
Affine Space
Vectors and points exist without a reference point
Manipulate vectors and points as abstract geometric entities
Linear Vector Space
Mathematical system for manipulating vectors
Affine Space
Vector space + points
Lines, Rays, Segments
Line: Set of all points that pass
through P0 in the direction of d
Ray: a >= 0
Segments: 0 <= a <= 1
Curves and Surfaces
Curves
One parameter entities of the form P(a) where the function is
nonlinear
Surfaces
Entities are formed from two-parameter functions P(a, b)
Planes
A plane can be defined by either a point and two vectors, or
by three non-collinear points.
Normals
Every plane has a vector n normal (perpendicular, orthogonal)
to it.
Surfaces have multiple normals.
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.
convex non-convex
Convex Hull
Smallest convext object containing all points Pi in
P = a1P1 + a2P2 + ... + anPn
Formed by "shrink wrapping" points
Linear Independence and Dimension
Linear Independence
If a set of vectors is linearly independent, we cannot represent one in
terms of the others:
Dimension
In a vector space, the maximum number of linearly independent
vectors is fixed and is called the dimension.
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: v = a1v1 + a2v2
+ ... + anvn
Coordinate Systems
Thus far, we have been able to work with geometric entities
without using any frame of reference or coordinate system
However, we need a frame of reference to relate points and
objects in our abstract mathematical space to our physical
world
Where is a point?
How does object map to world coordinates?
How does object map to camera coordinates?
Representation
Consider a basis v1, v2, ..., vn, a vector v is written as
v = a1v1 + a2v2 + ... + anvn
The list of scalars {a1, a2, ..., an} is the representation of v
with respect to the given basis:
v1 = e1 = (1, 0, 0)T
v2 = e2 = (0, 1, 0)T
v3 = e3 = (0, 0, 1)T
a = [a1, a2, a3]T
Homogeneous Coordinates
Using 3-tuples, it is not possible to distinguish between
points and vectors:
v = [a1, a2, a3]
p = [b1, b2, b3]
By adding a 4th coordinate component, we can use the
same representation for both:
v = [a1, a2, a3, 0]T
p = [b1, b2, b3, 1]T
Change of Representation
We can represent one frame in terms of another by applying a
transformation matrix C:
a = Cb = MTb
where
[a 11 a12 a13 a14]
MT = [a21 a22 a23 a24]
[a 31 a32 a33 a34]
[ 0 0 0 1]
Matrices in Computer Graphics
In OpenGL, we have multiple frames: model, world, camera
frame
To change frames or representation, we use
transformation matrices
All standard transformations (rotation, translation, scaling) can
be implemented as matrix multiplications using 4x4 matrices
(concatenation)
Hardware pipeline optimized to work with 4-dimensional
representations
Affine Transformations
Tranformation maps points/vectors to other points/vectors
Every affine transformation preserves lines
Preserve collinearity
Preserve ratio of distances on a line
Only have 12 degrees of freedom because 4 elements of
the matrix are fixed [0 0 0 1]
Only comprise a subset of possible linear transformations
Rigid body: translation, rotation
Non-rigid: scaling, shearing
Translation
Move (translate, displace) a point to a new location:
P' = P + d
Translation Matrix
P' = P + d
Rotation (about an axis)
Rotation about z axis leaves all points with the same z:
x' = x cos(t) - y sin(t)
y' = x sin(t) + y cos(t)
z' = z
P' = Rz(t)P
Rotation About Z Axis Matrix
Rotation About X Axis Matrix
Rotation About Y Axis Matrix
Scaling
Expand or contract along each axis (fixed point of origin)
P' = SP
Scaling Matrix
If sx, sy, sz are negative, then we will perform reflection.
Concatenation
To form arbitrary affine transformation matrices we can
multiply together translation, rotation, and scaling matrices:
p' = ABCDp
To optimize the computation, we group the transformation
matrices:
p' = Mp where M = ABCD
This saves us the cost of multiplying every vertex by multiple
matrices; instead we multiply by just one.
Order of Transformations
The right matrix is the first applied to the vertex:
p' = ABCp = A(B(Cp))
Sometimes we may use column matrices to represent points,
so this equation becomes:
p'T = pTCTBTAT
OpenGL Matrices
In OpenGL matrices are part of the state
GL_MODELVIEW
GL_PROJECTION
GL_TEXTURE
GL_COLOR
Select which matrix to manipulate by using glMatrixMode:
glMatrixMode(GL_MODELVIEW);
Current Transformation Matrix (CTM)
Conceptually there is a 4x4 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.
Transformation Pipeline
CTM Operations
Loading a 4x4 Matrix:
glLoadIdentity() C <- I
glLoadMatrix(M) C <- M
Postmultiplying by another 4x4 Matrix:
glTranslatef(dx, dy, dz) C <- MT
glRotatef(theta, vx, vy, vz) C <- MTR
glScalef(sx, sy, sz) C <- MTRS
Saving and Restoring Matrix:
glPushMatrix()
glPopMatrix()
Instancing
In modeling, we start with a simple object centered at the origin,
oriented with some axis, and at a standard size.
To instantiate an object, we apply an instance transformation:
Scale
Orient
Locate
Remember the last matrix specified in the program is the
first applied!
Translate, Rotate, Scale (TRS)
Remember the last matrix specified in the program is
the first applied!
For instancing, you want to scale, rotate, and then translate:
glPushMatrix();
glTranslatef(i->x, i->y, 0.0);
glRotatef(i->angle, 0.0, 0.0, 1.0);
glScalef(10.0, 10.0, 1.0);
glCallList(DisplayListsBase + MissileType);
glPopMatrix();
