Unit-5 Geometric Objects and Transformations-II Course code: 10CS65 | Computer Graphics and Visualization Unit-5 Geometric Objects and Transformations-II Engineered for Tomorrow Prepared by :Asst. Prof. Sandhya Kumari Department : Computer Science and Engineering Date : dd.mm.yyyy

Geometric Objects and Transformations-II Transformations in homogeneous coordinates Concatenation of transformations OpenGL transformation matrices Interfaces to three-dimensional applications Quaternions.

Transformation in Homogeneous Coordinates Translation Scaling Inversion operations: T-1 = T ( -x , -y , -z ) S-1 = S ( 1/x , 1/ y , 1/ z )

Transformation in Homogeneous Coordinates Rotation in x-y plane Rotation in y-z plane Rotation in z-x plane R-1 () = R ( - ) = RT ()

Transformations Concatenation well known strategy q = C B A p interpretation q = C (B (A p) ) Transformation q = M p

Rotation About a Fixed Point Rotation about the fixed point M = T(pf ) Rz(  ) T(- pf )

Rotation About a Fixed Point Rotation about the fixed point M = T(pf ) Rz(  ) T(- pf )

Rotations in E3  Rxy Ryz  Cube can be rotated about all x, y, z axis In our case the transformation matrix is defined M = Rzx Ryz Rxy = Ry Rx Rz Rzx

Rotations in E3 Transformation is defined by the instance transformation M M = T R S (order is substantial!) Each occurrence of an object in the scene is an instance of the object’s prototype To obtain proper size, location, orientation – instance transformation to the prototype is to be applied

Rotations About an Arbitrary Axis Given: points p1 , p2 and rotation angle  objects to be rotated Define vectors u = p1 - p2 and v = u / |u| - normalized v = [ x , y , z ]T x2 + y2 + z2 = 1 – directional cosines cos( x ) = x , cos( y ) = y , cos( z ) = z cos2( x ) + cos2( y ) + cos2 ( z ) = 1  only two directions angles are independent !!

Rotations About an Arbitrary Axis Transformation R = Rx(-x) Ry(-y) Rz() Ry(y) Rx(x)

Rotations About an Arbitrary Axis Object is moved to the origin Rotation about x axis

Rotations About an Arbitrary Axis Object is moved to the origin Rotation about y axis note the “-” position Complete transformation M = T(p0) Rx(-x) Ry(-y) Rz() Ry(y) Rx(x) T(- p0)

OpenGL Transformation Matrices Three matrices as a part of the state in OpenGL Only Model-View will be used CMT – current transformation matrix – can be changed by OpenGL functions – 4 x 4 size Supported operations: translation, scaling & rotation – last two with the fixed point in the origin C  I initialization C  CT translation C  CS scaling C  CR rotation

OpenGL Transformation Matrices Most systems allow to set directly or load or post-multiply the CMT with an arbitrary matrix M , scaling & rotation – last two with the fixed point in the origin C  M loading C  CM post-multiplication

OpenGL Transformation Matrices OpenGL model-view (GL_MODELVIEW) and projection (GL_PROJECTION) matrices (actually their product) are applied to ALL primitives – we should consider them as one CMT matrix – can be manipulated individually using glMatrixMode function glLoadMatrixf(pointer_to_matrix); /* vector of 16 position – column first order */

OpenGL Transformation Matrices glLoadIdentity ( ); /* loads identity matrix */ glRotatef(angle, vx, vy, vz); /* f – float used */ /* specifies general rotation angle in degrees, v – specifies the vector – fixed point P0 is the origin */ glTranslatef(dx, dy, dz); /* translation */ glScalef ( sx, sy, sz); /* scaling */

Rotation about a Fixed Point glMatrixMode(GL_MODELVIEW); glLoadIdentity ( ); glTranslatef(4.0, 5.0, 6.0); glRotatef(45.0, 1.0, 2.0, 3.0); glTranslatef(-4.0, -5.0, -6.0); /* rotates objects about the vector (1.0, 2.0, 3.0) with the angle 45° */ NOTE: we need not to form the rotation matrices as shown recently – try to make it on your own

Transformation Order The sequence specified recently: C  I, initialization C  CT (4.0, 5.0, 6.0), translation C  CR (45.0, 1.0, 2.0, 3.0), rotation C  CT (-4.0, -5.0, -6.0), translation back in each step the CTM matrix is post-multiplied forming new CTM matrix C = T (4.0, 5.0, 6.0) R(45.0, 1.0, 2.0, 3.0) T (-4.0, -5.0, -6.0) Each vertex specified after the model-view matrix has been specified will be multiplied p’ = C p

Spinning of the Cube Three callback functions: glutDisplayFunc(display); glutIdleFunc(spincube); glutMouseFunc(mouse); void display(void); /* visibility made by HW – GL_DEPTH.... */ {glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity ( ); glRotatef(theta[0];1.0, 0.0, 0.0); glRotatef(theta[1];0.0, 1.0, 0.0); glRotatef(theta[2];0.0, 0.0, 1.0); colorcube ( ); glutSwapBuffers ( ); /* swaps the buffers – drawing to the display */ } /* theta vector – global variable */

Spinning of the Cube void spincube ( ); { theta[axis] +=2.0; if (theta[axis] >360.0) theta[axis] -=360.0; glutPostRedisplay ( ); } void mouse (int btn, int state, int x, int y); { if (btn==GLUT_LEFT_BUTTON && state == GLUT_DOWN) axis=0; if (btn==GLUT_MIDDLE_BUTTON && state == GLUT_DOWN) axis=1; if (btn==GLUT_RIGHT_BUTTON && state == GLUT_DOWN) axis=2; } void mykey(char key, int mouse x, int mouse y); { if (key==‘q’ | | key==‘Q’ ) exit ( ); } /* simple termination */

Loading, Pushing & Popping glLoadMatrixf(myarray); /* 4 x 4 matrix of floats -column first order from a vector */ glMultMatrixf(myarray); /* multiplies the current matrix by user specified matrix */ Sequence example GLfloat myarray [16]; for ( i=0; i<3; i++) for ( j=0; j<3; j++) myarray[4*j+i] = m[i][j];

Loading, Pushing & Popping Sometimes it is reasonable to return the transformations back after they have been applied to some objects. Instead of re-computation the stack mechanism can be utilized glPushMatrix ( ); /* local transformation specifications */ glTranslatef ( .....); ................ /* DRAW OBJECTS HERE */ ................ /* recover recent state */ glPopMatrix ( );

Quaternion’s A quaternion consists of Scalar part and vector part , Let a be the quaternion and is defined as a=(q0, q1, q2, q3) i.e., a = ( q0 , q) Where q=(q1, q2, q3) so, we can call Quaternion is an extension to complex numbers