Transformations (p2) (đồ họa máy TÍNH SLIDE)

Camera Analogy and Transformations• Viewing transformations – tripod–define position and orientation of the viewing volume in the world... Coordinate Systems and Transformations• Steps

Transformations

Camera Analogy and Transformations

• Viewing transformations

– tripod–define position and

orientation of the viewing

volume in the world

Coordinate Systems and Transformations

• Steps in Forming an Image

– Specify geometry (world coordinates)

– Specify camera (camera coordinates)

– Project (window coordinates)

– Map to viewport (screen coordinates)

• Each step uses transformations

• Every transformation is equivalent to a change in

coordinate systems (frames)

5

Affine Transformations

• Want transformations which preserve geometry

– lines, polygons, quadrics

• Affine = line preserving

– Rotation, translation, scaling

– Projection

– Concatenation (composition)

Homogeneous Coordinates

• Each vertex is a column vector

• If a is nonzero, then (x, y, z, w) T and (ax, ay, az, aw) T

represent the same homogeneous vertex

• A 3D Euclidean space point (x, y, z) T becomes the

homogeneous vertex (x, y, z, 1.0) T

• As w is nonzero, the homogeneous vertex (x, y, z,

w) T corresponds to the 3D point (x/w, y/w, z/w) T

• Directions (directed line segments) can be

represented with w = 0.0

•  

7

Vertex transformations

• Vertex transformations (rotations, translations,

scaling, and shearing) and projections (such as

perspective and orthographic) can all be

represented by applying an appropriate 4 x 4 matrix

to the vertex coordinates.

• all affine operations are matrix multiplications

• all matrices are stored column-major in OpenGL

• matrices are always post-multiplied

• product of matrix and vector is

=

•  

• Specify operation (glRotate, glOrtho)

– Programmer does not have to remember the exact

matrices

9

Programming Transformations

• Prior to rendering, view, locate, and orient:

– Eye / camera position

– 3D geometry

• Manage the matrices

– Including matrix stack

• Combine (composite) transformations

Transformation Pipeline

• other calculations here

– material  color – shade model (flat) – polygon rendering mode – polygon culling

Modelview

Modelview

Projection

l l l

object eye clip normalized device window

– usually same as window size

– viewport aspect ratio should be same as projection

transformation or resulting image may be distorted

– glViewport(x, y, width, height)

Viewing Transformations

Viewing Transformations

• Position the camera/eye in the scene

– place the tripod down; aim camera

• To "fly through" a scene

– change viewing transformation and

redraw scene

• gluLookAt(eyex, eyey, eyez,

aimx, aimy, aimz,

upx, upy, upz)

– up vector determines unique orientation

– careful of degenerate positions

tripod

Using gluLookAt()

• In the default position, the camera is at the origin, is

looking down the negative z-axis, and has the positive y-axis as straight up This is the same as calling

• gluLookAt(0.0, 0.0, 0.0, 0.0, 0.0,

-100.0, 0.0, 1.0, 0.0);

Default View

• In the default position,

– the camera is at the

Using gluLookAt()

• gluLookAt(4.0, 2.0, 1.0, 2.0, 4.0,

-3.0, 2.0, 2.0, -1.0);

Projection Tutorial

Modeling Transformations

Translation Transformation

• The call glTranslate*(x, y, z) generates T, where

T =

•  

• glScale*(x, y, z) generates S =

•  

Scale Transformation

Rotation Transformation

• The glRotate*() command generates a matrix for

rotation about an arbitrary axis

• Rotating about the Oz

axis glRotate*(a, 0, 0, 1)

•  

General rotations

• The call glRotate*(a, x, y, z) generates R as follows:

– Let v = (x, y, z)T, and u = v/||v|| = (x’, y’, z’) T.

– Also let S =

– and M = uu T + (cos a) (I − uu T ) + (sin a) S

– Then R =

•  

Bài tập

• Xác định ma trận của phép quay glRotatef(30.0f,

1.0f, 1.0f, 0.0f)

Order of transformations

• In general not commutative: order matters!

Rotate then translate

Transformation Tutorial

Compositing Modeling Transformations

• Problem 1: hierarchical objects

– one position depends upon a previous position

– robot arm or hand; sub-assemblies

• Solution 1: moving local coordinate system

– modeling transformations move coordinate system

– post-multiply column-major matrices

– OpenGL post-multiplies matrices

29

Compositing Modeling Transformations

• Problem 2: objects move relative to absolute world

origin

– my object rotates around the wrong origin

• make it spin around its center or something else

• Solution 2: fixed coordinate system

– modeling transformations move objects around fixed

coordinate system

– pre-multiply column-major matrices

– OpenGL post-multiplies matrices

– must reverse order of operations to achieve desired effect

Connection: Viewing and Modeling

Connection: Viewing and Modeling

• Moving camera is equivalent to moving every object in

the world towards a stationary camera

• Viewing transformations are equivalent to several

OpenGL Viewing Code

• In OpenGL, we can use the built-in transformation calls to specify the viewing transformation

• The camera is positioned in the scene with

translation by [vTx, vTy, vTz] and rotation about the

X, Y, and Z axis:

void setupView(void) { // Inverse viewing transformation glRotatef( -vAngleZ, 0.0, 0.0, 1.0 );

glRotatef( -vAngleY, 0.0, 1.0, 0.0 );

glRotatef( -vAngleX, 1.0, 0.0, 0.0 );

glTranslatef( -vTx, -vTy, -vTz );

void setupView(void) { // Inverse viewing transformation glRotatef( -vAngleZ, 0.0, 0.0, 1.0 );

glRotatef( -vAngleY, 0.0, 1.0, 0.0 );

glRotatef( -vAngleX, 1.0, 0.0, 0.0 );

glTranslatef( -vTx, -vTy, -vTz );

Constructing a Frame

• The cross product between the up and the look-at

vector will get a vector that points to the right.

r = up x a

• Finally, using the vector a and the vector r we can synthesize a new vector u in the up direction:

• Rotation takes the unit world to our desired camera:

• Translation to the eye point:

Composing the Result

• The final camera transformation is:

The Viewing Transformation

• Transforming all points P in the world with E -1 :

• Where these are normalized vectors

a = P eye – P aim

r = up x a

u = a x r

Projection Transformation

Projection Transformation

• To lower dimensional space (here 3D -> 2D)

– Preserve straight lines

• Shape of viewing frustum

• Perspective projection

• Orthographic parallel projection

41

Demo

Orthographic projection

• The viewing volume is a rectangular parallelepiped.

• Vertexes of an object are "projected" towards infinity

• Distance from the camera doesn’t affect how large an

Orthographic projection

• Specify the orthographic viewing frustum by

– specifying minimum and maximum x, y coordinates

– Indicating range of distances along the z-axis by specifying near and far planes

Orthographic Projections matrix

• Here is the orthographic world-to-clip

transformation:

Orthographic Projection in OpenGL

• This matrix is constructed with the following OpenGL call:

glOrtho(left, right, bottom, top, zNear,zFar)

• And the 2D version (another GL utility function):

gluOrtho2D(left, right, bottom, top)

– Just a call to glOrtho() with near = -1 and far = +1

• Usually, the following code is part of the initialization

Perspective Projections

• Artists (Donatello, Brunelleschi, and Da Vinci) during

the renaissance discovered the importance of

perspective for making images appear realistic

• Parallel lines intersect at a point

Perspective projection

• Characteristic of perspective projection is

foreshortening:

– The farther an object is from the camera, the smaller it

appears in the final image

Perspective projection

• glFrustum(left, right, bottom, top,

zNear, zFar)

49

Perspective projection

– fov = vertical field of view in degrees

– aspect = image width / height at near depth

– Can only specify symmetric viewing frustums where the viewing window is centered around the –z axis.

OpenGL Perspective Matrix

• Mapping the perspective viewing frustum in OpenGL

to clip space involves some affine transformations

• OpenGL uses a clever composition of these

transformations with the perspective projection

matrix:

Viewport Transformation

Viewport Transformation

• The viewport is the rectangular region of the

window where the image is drawn

• Defining the Viewport

– glViewport(GLint x, GLint y, GLsizei

width, GLsizei height)

Mapping the Viewing Volume to the Viewport

• The aspect ratio of a viewport should equal the aspect

ratio of the viewing volume

– If the two ratios are different, the projected image will be distorted when mapped to the viewport

Common Transformation Usage

• 3 examples of resize() routine

– restate projection & viewing transformations

• Usually called when window resized

55

resize(): Perspective & LookAt

void resize( int w, int h )

resize(): Perspective & Translate

• Same effect as previous LookAt

GLdouble bottom = -2.5, top = 2.5;

glViewport(0, 0, (GLsizei) w, (GLsizei) h); glMatrixMode(GL_PROJECTION);

Additional Clipping Planes

• At least 6 more clipping planes available

• Good for cross-sections

• Modelview matrix moves clipping plane

Reversing Coordinate Projection

• Screen space back to world space

glGetIntegerv(GL_VIEWPORT, GLint viewport[4]) glGetDoublev(GL_MODELVIEW_MATRIX,

GLdouble *objx, *objy, *objz)

• gluProject goes from world to screen space