Computer Graphics Using Open-GL F. S. Hill, Jr.

Computer Graphics Using Open-GL F. S. Hill, Jr.

3D Affine Transformations Again we use coordinate frames, and suppose that we have an origin O and three mutually perpendicular axes in the directions i, j, and k (see Figure 5.8). Point P in this frame is given by P = O + Pxi + Pyj + Pzk, and vector V by Vxi + Vyj + Vzk. Px Vx Py Vy P , V Pz Vz

1 0 3-D Affine Transformations The matrix representing a transformation is now 4 x 4, with Q = M P as before. m11 m12 m13 m14 m21 m22 m23 m24 M m31 m32 m33 m34

0 0 0 1 The fourth row of the matrix is a string of zeroes followed a lone one. Translation and Scaling Translation and scaling transformation matrices are given below. The values Sx, Sy, and Sz cause scaling about the origin of the corresponding coordinates.

1 0 T 0 0 0 1 0 0 0 tx sx

0 ty 0 , S 1 tz 0 0 1 0 0

sy 0 0 0 0 sz 0 0 0 0 1

Shear The shear matrix is given below. a: y along z; b: z along x; c: x along y; d: z along y; e: x along z; f: y along z Usually only one of {a,,f} is non-zero. 1 c H e 0

a 1 f 0 b 0 d 0 1 0 0 1 Rotations Rotations are more complicated. We start by defining a roll (rotation counterclockwise around an axis looking toward the origin):

Rotations (2) z-roll: the x-axis rotates to the y-axis. x-roll: the y-axis rotates to the z-axis. y-roll: the z-axis rotates to the x-axis. 0 1 0 cos Rx 0 sin 0 0 cos

sin Rz 0 0 0 sin cos 0 sin 0

cos 0 0 0 1 0 0 cos 0

0 , R y 0 sin 0 1 0 0 0

1 0 sin 1 0 0 cos 0 0 0 0 , 0

1 Rotations (3) Note that 12 of the terms in each matrix are the zeros and ones of the identity matrix. They occur in the row and column that correspond to the axis about which the rotation is being made (e.g., the first row and column for an x-roll). They guarantee that the corresponding coordinate of the point being transformed will not be altered. The cos and sin terms always appear in a rectangular pattern in the other rows and columns.

Example A barn in its original orientation, and after a -70 x-roll, a 30 y-roll, and a -90 z-roll. a). the barn b). -700 x-roll c). 300 y-roll d). -900 z-roll Composing 3D Affine Transformations 3D affine transformations can be composed, and the result is another 3D affine transformation. The matrix of the overall transformation is the

product of the individual matrices M1 and M2 that perform the two transformations, with M2 premultiplying M1: M = M2M1 Any number of affine transformations can be composed in this way, and a single matrix results that represents the overall transformation. Example A barn is first transformed using some M1, and the transformed barn is again transformed using M2. The result is the same as the barn transformed once

using M2M1. Building Rotations All 2D rotations are Rz. Two rotations combine to make a rotation given by the sum of the rotation angles, and the matrices commute. In 3D the situation is much more complicated, because rotations can be about different axes. The order in which two rotations about different axes are performed does matter: 3D rotation matrices do not commute. Building Rotations (2) We build a rotation in 3D by composing three elementary rotations: an x-roll followed by a y-roll, and then a z-roll. The

overall rotation is given by M = Rz(3)Ry( 2)Rx(1). In this context the angles 1, 2, and 3 are often called Euler angles. Building Rotations (3) Eulers Theorem: Any rotation (or sequence of rotations) about a point is equivalent to a single rotation about some axis through that point. Any 3D rotation around an axis (passing through the origin) can be obtained from the product of five matrices for the appropriate choice of Euler angles; we shall see a method to construct the matrices. This implies that three values are required (and

only three) to completely specify a rotation! Rotating about an Arbitrary Axis We wish to rotate around axis u to make P coincide with Q. u can have any direction; it appears difficult to find a matrix that represents such a rotation. But it can be found in two ways, a classic way and a constructive way. z u

Q P x y Rotating about an Arbitrary Axis (2) The classic way. Decompose the required rotation into a sequence of known steps: Perform two rotations so that u becomes aligned with the z-axis.

Do a z-roll through angle . Undo the two alignment rotations to restore u to its original direction. Ru() = Rz( -) Ry( -) Rz() Ry() Rz() is the desired rotation. Rotating about an Arbitrary Axis (3) The constructive way. Using some vector tools we can obtain a more revealing expression for the matrix Ru(b). We wish to express the operation of rotating point P through angle b into point Q. The method, given in Case Study 5.5, effectively establishes a 2D coordinate

system in the plane of rotation as shown. Rotating about an Arbitrary Axis (4) This defines two orthogonal vectors a and b lying in the plane, and as shown in Figure 5.25b point Q is expressed as a linear combination of them. The expression for Q involves dot products and cross products of various ingredients in the problem. But because each of the terms is linear in the coordinates of P, it can be rewritten as P times a matrix. Rotating about an Arbitrary Axis (5) a).

b). z u a' h a p x Q

b Q a' P y a P Rotating about an Arbitrary Axis (6) c = cos(), s = sin(), and ux, uy, uz are the components of u.

Then c (1 c)u x2 (1 c)u x u y su z Ru ( ) (1 c)u x u z su y 0 (1 c)u y u x su z c (1 c)u y2 (1 c)u y u z su x 0 (1 c)u z u x su y

(1 c)u z u y su x c (1 c)u z2 0 0 0 0 1 Rotating about an Arbitrary Axis (6) Open-GL provides a rotation about an arbitrary axis: glRotated (beta, ux, uy, uz); beta is the angle of rotation. ux, uy, uz are the components of a vector

u normal to the plane containing P and Q. Summary of Properties of 3D Affine Transformations Affine transformations preserve affine combinations of points. Affine transformations preserve lines and planes. Parallelism of lines and planes is preserved. The columns of the matrix reveal the transformed coordinate frame. Relative ratios are preserved. Summary of Properties of 3D Affine Transformations (2)

The effect of transformations on the volumes of objects. If 3D object D has volume V, then its image T(D) has volume |det M | V, where |det M| is the absolute value of the determinant of M. Every affine transformation is composed of elementary operations. A 3D affine transformation may be decomposed into a composition of elementary transformations. See Case Study 5.3. Transforming Coordinate Systems We have a 2D coordinate frame #1, with origin O and axes i and j. We have an affine

transformation T(.) with matrix M, where T(.) transforms coordinate frame #1 into coordinate frame #2, with new origin O = T(O), and new axes i = T(i) and j = T(j). Transforming Coordinate Systems (2) Now let P be a point with representation (c, d, 1)T in the new system #2. What are the values of a and b in its representation (a, b, 1)T in the original system #1?

The answer: simply premultiply (c, d, 1)T by M: (a, b, 1)T = M (c, d, 1)T Transforming Coordinate Systems (3) We have the following theorem: Suppose coordinate system #2 is formed from coordinate system #1 by the affine transformation M. Further suppose that point P = (Px, Py, Pz,1) are the coordinates of a point P expressed in system #2. Then the coordinates of P expressed in system #1 are MP. Successive Transformations

Now consider forming a transformation by making two successive changes of the coordinate system. What is the overall effect? System #1 is converted to system #2 by transformation T1(.), and system #2 is then transformed to system #3 by transformation T2(.). Note that system #3 is transformed relative to #2. Successive Transformations (2) Point P has representation (e, f,1)T with respect to system #3. What are its coordinates (a,

b,1)T with respect to the original system #1? y P b f e d system #3

T2 c T1 system #2 system #1 a x Successive Transformations (3) To answer this, collect the effects of each transformation: In terms of system #2 the point P has coordinates (c, d, 1)T = M2(e, f, 1)T. And in terms of system #1 the point (c, d, 1)T has

coordinates (a, b, 1)T = M1( c, d, 1)T. So (a, b, 1)T = M1(d, c, 1)T = M1M2(e, f, 1)T The essential point is that when determining the desired coordinates (a, b, 1)T from (e, f, 1)T we first apply M2 and then M1, just the opposite order as when applying transformations to points. Successive Transformations (4) To transform points. To apply a sequence of transformations T1(), T2(), T3() (in that order) to a point P, form the matrix M = M3 x M2 x M1. Then P is transformed to MP; pre-multiply by Mi. To transform the coordinate system. To apply a sequence of transformations T1(), T2(), T3() (in that order) to the coordinate system, form the

matrix M = M1 x M2 x M3. Then P in the transformed system has coordinates MP in the original system. To compose each additional transformation Mi you must post-multiply by Mi. Open-GL Transformations Open-GL actually transforms coordinate systems, so in your programs you will have to apply the transformations in reverse order. E.g., if you want to translate the 3 vertices of a triangle and then rotate it, your program will have to do rotate and then translate.

Using Affine Transformations in Open-GL glScaled (sx, sy, sz); glTranslated (tx, ty, tz); glRotated (angle, ux, uy, uz); // 2-d: sz = 1.0 //2-d: tz = 0.0 // 2-d: ux = uy = 0.0; uz = 1.0 The sequence of commands is glLoadIdentity(); glMatrixMode (GL_MODELVIEW); // transformations 1, 2, 3, .... (in reverse order)

This method makes Open-GL do the work of transforming for you. Example We have version 1 of The easy way lets GL the house defined do the transforming. a). b). (vertices set), but y what we really want to draw is version 2. We could write routines to transform 23 the coordinates this #1

is the hard way. #2 x 32 23 Example: the Easy Way (2) We cause the desired transformation to be applied automatically to each vertex. Just as we know the window to viewport mapping is quietly applied to each vertex as part of the graphics pipeline, we can have an additional transformation be applied as well.

It is often called the current transformation, CT. We enhance moveTo() and lineTo() so that they first apply this transformation to the argument vertex, and then apply the window to viewport mapping. Example (3) When glVertex2d()is called with argument V, the vertex V is first transformed by the CT to form point Q. Q is then passed through the window to viewport mapping to form point S in the screen window. Example (4) How do we extend moveTo() and lineTo() so they carry out this additional mapping? The transform is done automatically by OpenGL!

OpenGL maintains a so-called modelview matrix, and every vertex that is passed down the graphics pipeline is multiplied by this modelview matrix. We need only set up the modelview matrix once to embody the desired transformation. Example (5) The principal routines for altering the modelview matrix are glRotated(), glScaled(), and glTranslated(). These dont set the CT directly; instead each one postmultiplies the CT (the modelview matrix) by a particular matrix, say M, and puts the result back into the CT. That is, each of these routines creates a matrix

M as required for the new transformation, and performs: CT = CT *M. Example (6) glScaled (sx, sy, sz); // 2-d: sz = 1.0 glTranslated (tx, ty, tz); //2-d: tz = 0.0 glRotated (angle, ux, uy, uz); // 2-d: ux = uy = 0.0; uz = 1.0 This method makes Open-GL do the work of transforming for you. Example (7) Of course, we have to start with some MODELVIEW matrix: The sequence of commands is glMatrixMode (GL_MODELVIEW);

glLoadIdentity(); // transformations 1, 2, 3, .... (in reverse order) Wrapper code for routines to manipulate the CT is in Figure 5.33. Example (8) Code to draw house #2: note translate is done before rotate (reverse order). setWindow(...); setViewport(..); // set window to viewport // mapping initCT(); // get started with identity // transformation

translate2D(32, 25); // CT includes translation rotate2D(-30.0); // CT includes translation and // rotation house(); // draw the transformed house Example 2: Star A star made of interlocking stripes: starMotif() draws a part of the star, the polygon shown in part b. (Help on finding polygons vertices in Case Study 5.1.) To draw the whole star we draw the motif five times, each time rotating the motif through an additional 72. a). b).

(x1,y1 ) Example 3: Snowflake The motif and the figure are shown below. glScaled() is used to reflect the motif to get a complete branch and then to restore the original axis. Rotate by 60o between b). branches. a). 30 o line Example 4: Dino Patterns The dinosaurs are distributed around a circle in both versions. Left: each dinosaur is rotated so that its feet point toward the origin; right: all the dinosaurs are upright.

Example 4 (2) drawDino() draws an upright dinosaur centered at the origin. In a) the coordinate system for each motif is rotated about the origin through a suitable angle, and then translated along its y-axis by H units. Note that the CT is reinitialized each time through the loop so that the transformations dont accumulate. An easy way to keep the motifs upright (as in part b) is to pre-rotate each motif before translating it. Affine Transformations Stack It is also possible to push/pop the current

transformation from a stack in OpenGL, using the commands glMatrixMode (GL_MODELVIEW); glPushMatrix(); //or glPopMatrix(); Affine Transformations Stack (2) The implementation of pushCT() and popCT() uses OpenGL routines glPushMatrix() and glPopMatrix(). Caution: Note that each routine must inform OpenGL which matrix stack is being affected. In OpenGL, popping a stack that contains only one matrix is an error; test the number of matrices using OpenGLs query function glGet(G L_MODELVIEW_STACK_DEPTH).

Affine Transformations Stack (3) pushCT(void) { glMatrixMode(GL_MODELVIEW); glPushMatrix(); // push a copy of the top matrix } checkStack(void) { if (glGet (GL_MODELVIEW_STACK_DEPTH) 1) ) // do something else popCT(); } popCT(void) { glMatrixMode(GL_MODELVIEW); glPopMatrix(); // pop the top matrix from the stack }

Example 5: Motif Tilings are based on the repetition of a basic motif both horizontally and vertically. Consider tiling the window with some motif, drawn centered in its own coordinate system by routine motif(). Copies of the motif are drawn L units apart in the x-direction, and D units apart in the y-direction, as shown in part b). Example 5 (2) The motif is translated horizontally and vertically to achieve the tiling.

Recently Viewed Presentations