1. Fundamentals of Computer Graphics Part 5 Viewing prof.ing.Václav Skala, CSc. University of West Bohemia Plzeň, Czech Republic ©2002 Prepared with Angel,E.: Interactive Computer Graphics – A Top Down Approach with OpenGL, Addison Wesley, 2001

2. Fundamentals of Computer Graphics2 Classical & Computer Viewing Center of projection (COP) – center of the camera lenses origin of the camera frame Direction of Projection (DOP) – viewing from infinity Projections planar geometric projections non-planar projections

3. Fundamentals of Computer Graphics3 Classical Views principal faces; architectural building-mostly orthogonal faces front, back, top, bottom, right, left faces

4. Fundamentals of Computer Graphics4 Orthographic Projections Multi-view orthographic projection (rovnoběžné promítání) 3 views & orthogonal preserves angles

5. Fundamentals of Computer Graphics5 Axonometric Projections shortening of distances Views: a.trimetric b.top c.side

6. Fundamentals of Computer Graphics6 Oblique Projections Views: a.construction b.top c.side Oblique (kosoúhlá) projection – most general parallel views

7. Fundamentals of Computer Graphics7 Perspective Projections Vanishing point(s) (úběžník) one-point two-points three-points perspectives

8. Fundamentals of Computer Graphics8 Camera positioning ! right-handed x left-handed coordinates glOrtho(...., near,far) measured from the camera glTranslate (0.0, 0.0, -d); /* moves the camera in positive dir.of z Vanishing point(s) (úběžník) one-point two-points three-points perspectives

9. Fundamentals of Computer Graphics9 Camera positioning Order: 1.rotate 2.move away from the origin We want to see objects from distance d and from x axis direction: glMatrixMode(GL_MODEL_VIEW); glLoadIdentity ( ); glTranslate (0.0, 0.0, -d); glRotate(-90.0, 0.0, 1.0, 0.0);

10. Fundamentals of Computer Graphics10 Camera positioning glMatrixMode(GL_MODELVIEW); glLoadIdentity (); glTranslatef(0.0, 0.0, -d); /* 3-rd */ glRotatef(35.26, 1.0, 0.0, 0.0); /* 2-nd */ glRotatef(45.0, 0.0, 1.0, 0.0); /* 1-st */ Isometric view of a cube [-1,-1,-1] x [1,1,1] Order: 1.rotate about y-axis 2.rotate about x-axis 3.move away from the origin corner [-1,1,1] to be transformed to [0,1,  2]  35.26°

11. Fundamentals of Computer Graphics11 Two viewing API’s VRP – View Reference Point – origin is implicit set_view_reference_point(x,y,z); VPN – View Plane Normal – orientation of projection plane – camera back set_view_plane_normal(nx, ny,nz); VUP – View-UP vector - specifies what direction is up from the camera’s perspective set_view_up(vup_x, vup_y, vup_z); Unsatisfactory camera specification Starting point – world frame – description of camera position and orientation; precise type of image – perspective or parallel defined separately – Projection Matrix specification

12. Fundamentals of Computer Graphics12 Two viewing API’s v vector is obtained by VUP vector projection on the view plane; v is orthogonal to normal n This orthogonal system is referred as viewing-coordinate system or u-v-n system with VRP added - desired camera frame The matrix that DOES the change of frames is the view-orientation matrix p = [x,y,z,1] T – view-reference point n = [n x, n y, n z,0] T – view-plane normal v up = [v upx, v upy, v upz,0] T – view-up vector

13. Fundamentals of Computer Graphics13 Two viewing API’s New frame construction view-reference point as its origin view-plane normal as one coordinate direction two other directions u & v Default x, y, z axes become u, v, n now Model-view matrix V = T R ; v & n must be orthogonal n T v = 0 v is a projection of v up into the plane formed by n & v up – it must be a linear combination of these two vectors v =  n +  v up If the length of v is ignored,  = 1 can be set and  = - p T n / n T nv = p – ( p T n / n T n ) nu = v x n

14. Fundamentals of Computer Graphics14 Two viewing API’s Vectors u, v, n can be normalized independently to u’, v’, n’ Matrix M is a rotation matrix that orients u’, v’, n’ system with respect to the original system We want inversion matrix R R = M -1 = M T Finally the model-view matrix V = T R For our isometric example p = (  3/3) [-d,d,d,1] T n = [-1,1,1,0] T v up = [0,1,0,0] T

15. Fundamentals of Computer Graphics15 Look-At Function VRP, VPN & VUP specifies camera position Straightforward method: e – camera position (called eye-point) a – position to look at (called at point) vpn = e – a gluLookAt(eye_x, eye_y, eye_z, at_x, at_y, at_z ) ;

16. Fundamentals of Computer Graphics16 Others Viewing APIs For some applications others viewing transformations are needed flight simulation applications – roll, pitch, yaw –angles are specified relative to the center of mass –distance is counted from the center of mass of the vehicle astronomy etc. requires polar or spherical coordinates –elevation, azimuth camera can rotate – twist angle

17. Fundamentals of Computer Graphics17 Camera is pointing in the negative z-direction, d < 0 x / z = x p / d x p = x / (z /d) y p = y / (z /d) division by z describes non-uniform foreshortening Perspective transformation preserves lines, but it is not affine it is irreversible Perspective Projections

18. Fundamentals of Computer Graphics18 for w  0 - point represented as p = [ wx, wy, wz, w] T Usually w = 1 p = [ x, y, z, 1] T q = M p q = [ x, y, z, z/d] T q’ = [ x / (z/d), y / (z/d), d, 1] T = [ x p, y p, z p, 1] T Perspective Projections Perspective transformation can be represented by 4 x 4 matrix - perspective division must be part of the pipeline

19. Fundamentals of Computer Graphics19 Orthogonal or orthographic projection is a special case After projection: x p = x y p = y z p = 0 Orthogonal Projections

20. Fundamentals of Computer Graphics20 We haven’t taken properties of the camera so far –angle of view –view volume frustrum – truncated pyramid objects not within the view volume are said to be clipped out Projections in OpenGL

21. Fundamentals of Computer Graphics21 Perspective viewing in OpenGL Typical sequence: glMatrixMode (GL_PROJECTION); glLoadIdentity ( ); glFrustrum(xmin, xmax, ymin, ymax, near, far); near & far distances must be positive and measured from the COP be careful about the signs !

22. Fundamentals of Computer Graphics22 Perspective viewing in OpenGL Typical sequence: glMatrixMode (GL_PROJECTION); glLoadIdentity ( ); gluPerspective (fovy, aspect, near, far); fovy – view angle in y-axis aspect – aspect ratio width/height

23. Fundamentals of Computer Graphics23 Parallel viewing in OpenGL Typical sequence: glMatrixMode (GL_PROJECTION); glLoadIdentity ( ); glOrtho (xmin, xmax, ymin, ymax, near, far); /* restriction far > near */

24. Fundamentals of Computer Graphics24 Algorithms object space image space –z-buffer – requires depth or z-buffer Hidden Surface Removal Typical sequence: glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); glEnable(GL_DEPTH_TEST); Clear the buffer before new rendering glClear(GL_DEPTH_BUFFER_BIT); /* study example in chapter 5.6 */

25. Fundamentals of Computer Graphics25 Projection Normalization – converts all projections into orthogonal projections by first distorting objects – result after projection is the same a.perspective view b.orthographic projection of distorted objects Projection Normalization

26. Fundamentals of Computer Graphics26 glOrtho defines mapping to the standard volume - canonical volume Operations: translate to the center scaling Projection matrix P = S T Orthogonal-Projection Matrices

27. Fundamentals of Computer Graphics27 P = S T Orthogonal-Projection Matrices Study Oblique projection on your own – chapter 5.7.3.

28. Fundamentals of Computer Graphics28 Perspective normalization – canonical pyramid x =  zy =  z (speeds-up pyramidal clipping) near plane z = z min far plane z = z max values are negative and therefore z max > z min Perspective-Projection Matrices

29. Fundamentals of Computer Graphics29 Consider a matrix N p = [ x, y, z, 1] T q = [ x’, y’, z’, w’] T q = N p x’ = xy’ = y z’ =  z +  w’ = -z after dividing x’’ = - x /dy’’ = -y /d z’’ = -(  +  / z)w’’= 1 if orthographic projection is applied along to z axis p’ = M orth N p = [ x, y, 0, -z ] T Perspective-Projection Matrices

30. Fundamentals of Computer Graphics30 Pyramidal sides x =  z y =  z are transformed to x =  1 y =  1 front plane z = z min to back plane z = z max to Perspective-Projection Matrices If then z = z min is mapped to z’’ = -1 z = z max is mapped to z’’ = +1

31. Fundamentals of Computer Graphics31 Matrix N transforms the viewing frustrum to a right parallelpiped and an orthogonal projection in the transformed volume yields to the same image as does perspective projection. N is called perspective normalization matrix Perspective-Projection Matrices Study a non-symmetric frustrum transformations, shadows Chap.5.9. on your own

32. Fundamentals of Computer Graphics32 Conclusion - Chapter5 You have learnt mathematical background and API for projections – parallel, oblique and perspective Try to find a solution for: 1.define transformations needed for flight simulator as a composition of existing ones 2.application of projections for a display walls (4 x 3 screens, using non-symmetric viewing frustrum) 3.imagine a cube in perspective projection. Observer is –in front of the object –inside of the object what he will see, what you will get if you use geometric transformations and projection matrices and what OpenGL gives you? Discuss results!