Presentation is loading. Please wait.

Computer Graphics: 2D Transformations

Presentation on theme: "Computer Graphics: 2D Transformations"— Presentation transcript:

Computer Graphics: 2D Transformations
Kocaeli Universitesity Computer Engineering Department Fall 2011 Need to include coordinate transform and hierarchical modeling

Geometric Transformation
What is geometric transformation? Operations that are applied to the geometric description of an object to change its position, orientation, or size are called geometric transformations

2D Transformations y y x x y x

2D Transformations Applications: y y x x y x Animation
Image/object manipulation Viewing transformation etc. x y x 4

2D Transformation Given a 2D object, transformation is to change the object’s Position (translation) Size (scaling) Orientation (rotation) Shapes (shear) Apply a sequence of matrix multiplications to the object vertices

Point Representation We can use a column vector (a 2x1 matrix) to represent a 2D point x y A general form of linear transformation can be written as: x’ = ax + by + c OR y’ = dx + ey + f X’ a b c x Y’ = d e f * y

Translation Re-position a point along a straight line
Given a point (x,y), and the translation distance (tx,ty) The new point: (x’, y’) x’ = x + tx y’ = y + ty (x’,y’) ty (x,y) tx OR P’ = P + T where P’ = x’ p = x T = tx y’ y ty

Translation How to translate an object with multiple vertices?
Translate individual vertices

2D Rotation Default rotation center: Origin (0,0)
> 0 : Rotate counter clockwise q q < 0 : Rotate clockwise

2D Rotation (x,y) -> Rotate about the origin by q (x’, y’) r
f How to compute (x’, y’) ?

2D Rotation (x,y) -> Rotate about the origin by q (x’, y’) r
f How to compute (x’, y’) ? x = r cos (f) y = r sin (f) x’ = r cos (f + q) y’ = r sin (f + q)

2D Rotation x = r cos (f) y = r sin (f)
(x,y) (x’,y’) q x = r cos (f) y = r sin (f) x’ = r cos (f + q) y = r sin (f + q) r f x’ = r cos (f + q) = r cos(f) cos(q) – r sin(f) sin(q) = x cos(q) – y sin(q) y’ = r sin (f + q) = r sin(f) cos(q) + r cos(f)sin(q) = y cos(q) + x sin(q)

2D Rotation x’ = x cos(q) – y sin(q) y’ = y cos(q) + x sin(q) r
(x,y) (x’,y’) q x’ = x cos(q) – y sin(q) y’ = y cos(q) + x sin(q) r f Matrix form? x’ cos(q) -sin(q) x y’ sin(q) cos(q) y =

2D Rotation How to rotate an object with multiple vertices? q
Rotate individual Vertices

2D Scaling Scale: Alter the size of an object by a scaling factor
(Sx, Sy), i.e. x’ = x . Sx y’ = y . Sy x’ Sx x y’ Sy y = (2,2) (4,4) (1,1) (2,2) Sx = 2, Sy = 2

2D Scaling Not only the object size is changed, it also moved!!
(2,2) (4,4) (1,1) (2,2) Sx = 2, Sy = 2 Not only the object size is changed, it also moved!! Usually this is an undesirable effect We will discuss later (soon) how to fix it

Scaling facts

Put it all together Translation: Rotation: Scaling:

Homogeneous Coordinates -1
It is well known that many application involves sequences of geometric transformations For example, an animation might require an object to be translated, rotated and scaled at each increment of the motion If you want to first rotates an object, then scales it, you can combine those two transformation to a composite transformation like the following equation

Homogeneous Coordinates -2
However, it will be difficult to deal with the above composite transformation and translation together. Because, translation is not 2 by 2 matrix representation Consider how the matrix representations discussed in the previous sections can be reformulated so that such transformation sequences can be efficiently processed

Homogeneous Coordinates -3
A standard technique for expanding each two-dimensional coordinate position representation (x, y) to three-element representation, called Homogeneous Coordinates, where homogeneous h is a nonzero value such that A convenient choice is simply to set h=1, so each two-dimensional position is then represented with homogeneous coordinate (x,y,1).

Or, 3x3 Matrix Representations
Translation: Rotation: Scaling: x’ tx x y’ = ty * y x’ cos(q) -sin(q) x y’ sin(q) cos(q) * y = x’ Sx x y’ = Sy * y Why use 3x3 matrices?

Why Use 3x3 Matrices? So that we can perform all transformations using matrix/vector multiplications This allows us to pre-multiply all the matrices together The point (x,y) needs to be represented as (x,y,1) -> this is called Homogeneous coordinates! How to represent a vector (vx,vy)?

Composing Transformation
Composing Transformation – the process of applying several transformation in succession to form one overall transformation If we apply transforming a point P using M1 matrix first, and then transforming using M2, and then M3, then we have: (M3 x (M2 x (M1 x P )))

Composing Transformation
Composing Transformation – the process of applying several transformation in succession to form one overall transformation If we apply transforming a point P using M1 matrix first, and then transforming using M2, and then M3, then we have: (M3 x (M2 x (M1 x P ))) = M3 x M2 x M1 x P M (pre-multiply) 25

Composing Transformation
Matrix multiplication is associative M3 x M2 x M1 = (M3 x M2) x M1 = M3 x (M2 x M1) Transformation products may not be commutative A x B != B x A Some cases where A x B = B x A A B translation translation scaling scaling rotation rotation uniform scaling rotation (sx = sy) translation rotation?

Example1: General Two-Dimensional Pivot-Point Rotation
(xr,yr) So we can generate a 2D rotation about any other pivot point (x, y) by performing the following sequence of translate-rotate-translate operations BURDAAAAAA

Example1 (Cont) Translate the object so that the pivot-point position is moved to the coordinate origin Rotate the object about the coordinate origin Translate the object so that the pivot point is returned to its original position

Example2: Scaling without translation
Translate the object to so that the fixed point coincides with the coordinate origin Scale the object with respect to the coordinate origin Use the inverse of the translation in step (1) to return the object to its original position

Example2 (Cont) (xr,yr) Translate Scale Translate

Some Other Transformations
Shearing and Reflections

Shearing Y coordinates are unaffected, but x coordinates are translated linearly with y That is: y’ = y x’ = x + y * h x h x y = * y

Shearing in Y Shearing will not change the area of the object
x x y = g * y Shearing will not change the area of the object Interesting Facts:

Reflection

Reflection

Reflection

Reflection about X-axis

Reflection about X-axis
x x y = * y

Reflection about Y-axis

Reflection about Y-axis
x x y = * y

What’s the Transformation Matrix?

What’s the Transformation Matrix?
x x y = * y

More about reflection? Reflection about y=x Reflection about y=-x

Rotation Revisit The standard rotation matrix is used to rotate about the origin (0,0) cos(q) -sin(q) 0 sin(q) cos(q) 0 What if I want to rotate about an arbitrary center?

Arbitrary Rotation Center
To rotate about an arbitrary point P (px,py) by q: (px,py)

Arbitrary Rotation Center
To rotate about an arbitrary point P (px,py) by q: Translate the object so that P will coincide with the origin: T(-px, -py) (px,py)

Arbitrary Rotation Center
To rotate about an arbitrary point P (px,py) by q: Translate the object so that P will coincide with the origin: T(-px, -py) Rotate the object: R(q) (px,py)

Arbitrary Rotation Center
To rotate about an arbitrary point P (px,py) by q: Translate the object so that P will coincide with the origin: T(-px, -py) Rotate the object: R(q) Translate the object back: T(px,py) (px,py)

Arbitrary Rotation Center
Translate the object so that P will coincide with the origin: T(-px, -py) Rotate the object: R(q) Translate the object back: T(px,py) Put in matrix form: T(px,py) R(q) T(-px, -py) * P x’ px cos(q) -sin(q) px x y’ = py sin(q) cos(q) py y

Scaling Revisit The standard scaling matrix will only anchor at (0,0)
Sx 0 Sy 0 What if I want to scale about an arbitrary pivot point?

Arbitrary Scaling Pivot
To scale about an arbitrary fixed point P (px,py): (px,py)

Arbitrary Scaling Pivot
To scale about an arbitrary fixed point P (px,py): Translate the object so that P will coincide with the origin: T(-px, -py) (px,py)

Arbitrary Scaling Pivot
To scale about an arbitrary fixed point P (px,py): Translate the object so that P will coincide with the origin: T(-px, -py) Scale the object: S(sx, sy) (px,py)

Arbitrary Scaling Pivot
To scale about an arbitrary fixed point P (px,py): Translate the object so that P will coincide with the origin: T(-px, -py) Scale the object: S(sx, sy) Translate the object back: T(px,py) (px,py)

Similar presentations

Ads by Google