Geometric Transforms

Geometric Transforms

Changing coordinate systems

The plan

• Describe coordinate systems and transforms• Introduce homogeneous coordinates• Introduce numerical integration for animation

• Later:– camera transforms– physics– more on vectors and matrices

World Coordinates

• Objects exist in the world without need for coordinate systems

• But, describing their positions is easier with a frame of reference

• “World” or “object-space” or “global” coordinates

Screen vs World Coordinates

• Some objects only exist on the screen– mouse pointer, “radar” display, score, UI elements

• Screen coordinates typically 2D Cartesian– x, y

• Objects in the world also appear on the screen – need to project world coordinates to screen coordinates– camera transform

Coordinate Transforms

• A Cartesian coordinate system has three things:

• an origin – reference point measurements are taken from

• axes – canonical directions• scale – meaning of units of distance

Types of transforms

• Translation– moving in a fixed position

• Rotation– changing orientation

• Scale– changing size

• All can be viewed either as affecting the model or as affecting the coordinate system

Changing coordinate systems

• Translation: changing the origin of the coordinate system

(0,0)

(0,0)

(5,13)

(2,12)

Changing coordinate systems

• Rotation: changing the axes of the coordinate system

(0,0)

(0,0)

(5,5)

(7,1)

Changing coordinate systems

• Scaling: changing the units of the coordinate system

(0,0)

(0,0)

(4,4)(8,8)

Matrix Transforms

• For "simplicity"s sake, we want to represent our transforms as matrix operations

• Why is this simple?– single type of operation for all transforms– IMPORTANT: collection of transforms can be

expressed as a single matrix• efficiency

Scaling

• If we express our 2D coordinates as (x,y), scaling by a factor a multiplies each coordinate: so (ax, ay)

• Can write as a matrix multiplication:

a 0

0 b

x

y

ax

by=

Scaling Syntax

Matrix.CreateScale( s );– scalar argument s describes amount of scaling

• alternatively,

Matrix.CreateScale( v );– vector argument v describes scale amount in x y z

Rotation

• Similarly, rotating a point by an angle θ:– (x,y) (x cos θ - y sin θ, x sin θ + y cos θ)

cos θ -sin θ

sin θ cos θ

x

y

x cos θ – y sin θ

x sin θ + y cos θ =

Rotation Syntax

Matrix.CreateRotationZ(angle)

• Note, specify the axis about which the rotation occurs– also have CreateRotationX, CreateRotationY

• argument is angle of rotation, in radians

Translation

• Translating a point by a vector involves a vector addition:

– (x,y) + (s,t) = (x+s, y+t)

Translation

• Translating a point by a vector involves a vector addition:

– (x,y) + (s,t) = (x+s, y+t)

• Problem: cannot compose multiplications and additions into one operation

Coordinate Transforms

• Scaling: p’ = Sp• Rotation: p’ = Rp

• Translation: p’ = t + p• Problem: Translation is treated differently.

Homogeneous Coordinates

• Add an extra coordinate w• 2D point written (x,y,w)• Cartesian coordinates of this point are (x/w,

y/w)– w=0 represents points at infinity and should be

avoided if representing location• [Aside: w=0 also used to represent vector, e.g., normal]

– in practice, usually have w=1

Translation now

• (x,y,1) + (s,t,0) = (x+s,y+t, 1)

1 0 s

0 1 t

0 0 1

x

y

1

x+s

y+t

1

=

Composing Translations

1 0 s1

0 1 t1

0 0 1

1 0 s2

0 1 t2

0 0 1

1 0 s1+s2

0 1 t1+t2

0 0 1

=

Translation Syntax

Matrix.CreateTranslation( v );

– vector v is the translation vector

• Also,

Matrix.CreateTranslation( x, y, z);– x, y, z are scalars (floats)

Composing Transformations

• Rotation, scale, and translate are all matrix multiplications

• We can compose an arbitrary sequence of transformations into one matrix

• C = T0T1…Tn-1Tn

• Remember – order matters• In XNA, later transforms are added on the

right

Kinds of Transformations

• Rigid transformations– composed of only rotations and translations– preserve distances between points

• Affine transformations– include scales– preserve parallelism of lines– distances and angles might change

More on Rotations

• R matrix we wrote allows rotation about origin

• Usually, origin and point of rotation do not coincide

More on Rotations

• Want to rotate about arbitrary point• How to achieve this?

More on Rotations

• Want to rotate about arbitrary point• How to achieve this?• Composite transform

– first translate to origin– next, rotate desired amount– finally, translate back– C = T-1RT

More on Order of Operations

• AB != BA in general• But, AB = BA if:

– A is translation, B is translation– A is scale, B is scale– A is rotation, B is rotation– A is rotation, B is scale (that preserves aspect

ratio)

• All in two dimensions, note

Like transforms commute

ISROT

• ISROT: a mnemonic for the order of transformations– Identity: gets you started– Scale: change the size of your model– Rotation: rotate in place– Orbit: rotate about an external point

• first translate• then rotate (about origin)

– Translation: move to final position

3D transforms

• Translation same as in 2D– use 4D homogeneous coordinates x,y,z,w

• Scaling same as 2D• For rotation, need to specify axis

– unique in 2D, but different possibilities available in 3D

– can represent any 3D rotation by a composition of rotations about axes

Transforming objects

• So far, talked about transforming points• How about objects?

• Lines get transformed sensibly with transforms on endpoints

• Polygons same, mutatis mutandis

Hierarchical Models

• Many times, structures (and models) will be built as a hierarchy:

Body

Arm Other limbs...

Hand

Thumb other fingers...

Transforms on Hierarchies

• Transforms applied to nodes higher in the hierarchy are also applied to lower nodes– parent transforms propagate to children

• How to achieve this?• Simple: multiply your transform with your

parent's transform• May want a stack for hierarchy management

– push transform on descending– pop when current node finished

Transforms on Hierarchies

• pseudocode for computing final transform: applyWorld = myWorld * parentWorld;

• applyWorld is the final transform• myWorld is the local transform• parentWorld is the parent node's transform• The power of matrix transforms! Complex

hierarchical models can be expressed simply.

Moving objects

• Want to get things to move• Can adjust transform parameters

– translation amount– rotation, orbit angles

• Just incorporate changes into Update()• Need to do this in a disciplined way

Speed position

• If we know – where an object started– how fast it is moving (and the direction)– and how much time has passed

• we can figure out where it is now

• x(t + dt) = x(t) + v(t)dt• Numerical integration!

Euler integration

• Assumes constant speed within a timestep– still gives an answer if speed changes, but answer

might be wrong

• x(t + dt) = x(t) + v(t)dt• "Explicit integration"• Most commonly used in graphics/game

applications

Implementation

• Time available in Update as gameTimeobject.position += object.velocity *

gameTime.ElapsedGameTime.TotalSeconds;– if speed expressed in distance units per second– assumes that position and velocity are vectors– may have some way of updating velocity

• physics, player control, AI, ...

• Similar approach for angle updates (need angular velocity)

Recap

• How to use world transformations– scale, rotate, translate

• Use of homogeneous coordinates for translation

• Order of operations– ISROT

• Animation and Euler integration

Future lectures

• matrix and vector math• camera transformations• illumination and texture• particle systems

– linear physics