The Virtual Camera. The Virtual Camera. Setting the View Volume. Perspective Camera

Transcription

1 The Virtual Camera The Virtual Camera The Camera is defined by using a parallelepiped as a view volume with two of the walls used as the near and far view planes OpenGL also allows for a perspective view to be created, this is done by changing the shape of the view volume. Perspective Camera The Camera has an eye positioned at some point in space. Its view volume is a portion of a rectangular pyramid, whose apex is at the eye. The opening of the pyramid is set by the viewangle θ (part b of figure) Two planes are defined perpendicular to the axis of the pyramid : the near and the far plane. Where these planes intersect the pyramid they form rectangular windows which have an adjustable aspect ratio. OpenGL clips points which lie outside the view volume. Points lying inside the the view volume are projected onto the viewplane to a corresponding point P' With a perspective projection the point P' is determined by finding where a line from the eye to P intersects the viewplane. Setting the View Volume OpenGL provides a simple way to set the view volume in a program by setting the projection Matrix This is done using gluperspective as follows

2 OpenGL Code Listing 1: Set Camera Projection Function 1 void SetCameraProjection(Real fov,real w, Real h, Real near, Real far) 2 { 3 glviewport(0,0,w,h); 4 glmatrixmode(gl_projection); 5 glloadidentity(); 6 gluperspective(fov,(real)w/h,near,far); 7 glmatrixmode(gl_modelview); 8 9 } Setting The Perspective The parameter fov, shown as θ in the figure is given in degrees and sets the angle between the top and bottom walls of the pyramid. The parameters w and h sets the aspect ratio of any window parallel to the xy-plane The value N is the distance from the eye to the near plane, and F is the distance from the eye to the far plane. N and F should be positive. Positioning and Pointing the Camera In order to obtain the desired view of a scene, we move the camera from its default position as shown in the previous slide To point it in a particular direction we need to perform rotations and translations which result in changes to the modelview matrix 1 glmatrixmode(gl_modelview); 2 3 glloadidentity(); 4 glulookat(eye.x,eye.y,eye.z, 5 look.x,look.y,look.z, 6 up.x,up.y,up.z); The code moves the camera so that the eye resides at point eye it looks towards the point of interest look The General Camera with Arbitrary Orientation and Position It is useful to attach an explicit co-ordinate system to the camera as shown in the figure above. This co-ordinate system has its origin at the eye and has three axes, usually called the u-,v-, and n-axis which define the orientation of the camera The axes are pointed in directions given by the vectors u,v, and n Because, by default, the camera looks down the negative z-axis, we say in general that the camera looks down the negative n-axis in the direction -n The direction u points off to the right of the camera and the direction v points upward

3 Spherical Geometry Spherical Co-ordinates Using trigonometry we can work out a relationship between spherical coordinates and Cartesian coordinates (u x,u y,u z ) for U the equations are u x = Rcos(φ)cos(θ), u y = Rsin(φ), and u z = Rcos(φ)sin(θ) The above figure shows how a point U is defined in spherical coordinates. R is the radial distance of U from the origin, and φ is the angle that U makes with the xz-plane, know as the latitude of the point U. θ is the azimuth of U, the angle between the xy-plane and the plane through U and the y-axis. φ lies in the interval π 2 φ < π 2 and θ lies in the range 0 θ < 2π We can also invert the relations to express (R, φ, θ) in terms of (u x,u y,u z ) R = u 2 x + u 2 y + u 2 z, φ = sin ( 1 u y ) R, θ = arctan(uz,u x ) The function arctan(,) is the two argument form of the arctangent, defined as (atan2 in C) 8 tan >< 1 (y/x) if x > 0 π + tan arctan(y, x) = 1 (y/x) if x < 0 π/2 if x =0and y > 0 >: π/2 if x =0and y < 0 Example Suppose that Point U is at a distance 2 from the origin, is 60 o up from the xz-plane, and is along the negative x-axis. Hence U is in the xy-plane. Then U is expressed in spherical coordinates as (2, 60 o, 180 o ) To convert this to Cartesian coordinates we use the equations : u x = Rcos(φ)cos(θ), u y = Rsin(φ), u z = Rcos(φ)sin(θ) Where u x =2cos(60 o )cos(180 o )=-1 u y =2sin(60 o )=1.732 u z =2cos(60 o )sin(180 o ) 0 C++ Example 1 #include <iostream> 2 #include <cmath> 3 4 int main() 5 { 6 float deg2rad=m_pi/180.0f; 7 8 float phi=60*deg2rad; 9 float theta=180*deg2rad; 10 float radius=2.0; std::cout<<"x = "<<radius*cos(phi)*cos(theta)<<std::endl; 13 std::cout<<"y = "<<radius*sin(phi)<<std::endl; 14 std::cout<<"z = "<<radius*cos(phi)*sin(theta)<<std::endl; 15 }

4 Direction Cosines The direction of point U in the previous example is given in terms of two angles : the azimuth and the latitude. Directions are often specified in an alternative useful way through direction cosines. The direction cosines of a line through the origin are the cosines of the three angles it makes with the x,y and z axes respectively. Recall that the cosine of the angle between two unit vectors is given by their dot product. Using the given point U we form the position vector (u x,u y,u z ) We also know that the length of the vector is R so we normalise it to unit length thus m = (u x /R, u y /R, u z /R) Direction Cosines II Then the cosine of the angle it makes with the x axis is given by the dot product m i = u x /R which is the first component of m Similarly the second and third components of m are the second and third direction cosines respectively Calling the angles made with the x,y and z axis α, β and γ respectively, we have, for the three direction cosines for the line from 0 to U cos(α) = ux cos(β) = uy and cos(γ) = uz R R, R, Note that the three direction cosines are related, since the sum of their squares is always unity Describing Orientation Describing Orientation Position is easy to describe, but orientation is difficult. It helps to specify orientation using the aviation terms pitch,heading,yaw and roll as shown in the figure above The pitch of an air plane is the angle that its longitudinal axis (running from tail to nose having direction -n) makes with the plane. A roll is a rotation about the longitudinal axis; the roll is the amount of rotation relative to the horizontal. An airplane's heading is the direction it is headed (This is also called azimuth and bearing) To find the heading and the pitch, given n simply express n in spherical coordinates, as shown in the figure The vector n has longitude and latitude given by the angles θ and φ respectively. The heading of the plane is given by the longitude of n and the pitch is given by the latitude of n

5 Finding roll, pitch, and heading given vectors u, v, and n. Assuming the camera is based on a coordinate system with axes in the directions u, v, and n, all unit vectors. The heading and pitch of the camera is denoted by θ and φ. The relationship of Cartesian and spherical coordinates system is given by: Camera n x = cos(φ)cos(θ) n y = sin(φ) n x = sin(φ)cos(θ) { θ = tan 1 ( n z/ n x) φ = sin 1 ( n y) The roll of the camera is the angle its u-axis makes with the horizontal, To find it construct a vector b = j n =(n z, 0, n x) b j =(j n) j =0 bis horizontal b n =(j n) n =0 bis perpendicular to n and therefore lies in the uv-plane Since b = n 2 x + n 2 z b u = u xn z u zn x The angle between b and u is given by cos(roll) = b u b = ( uxnz uznx n 2 x +n 2 z ) ) so the roll of the camera can be expressed as ( roll = cos 1 uxnz uznx n 2 x +n2 z heading = arctan( n z, n x) and pitch = sin 1 ( n y) The above figure shows a camera with the same co-ordinate system attached to it It has u-,v- and n-axes and an origin at position eye b) shows the camera with a roll applied to it c) shows the camera with zero roll or no-roll camera The u-axis of a no-roll camera is horizontal, that is perpendicular to the y-axis of the world Note that a no-roll camera can still have an arbitrary n direction, so it can have any pitch or heading. Camera Control The function glulookat is handy for setting up an initial camera as we usually have a good idea where to place eye and look However it is harder to visualise how to choose up to obtain a certain roll and it is quite difficult to make relative adjustments to the camera later using only glulookat This is due to the fact that glulookat uses Cartesian coordinates whereas orientation deals with angles and rotations about axes. OpenGL doesn't give us direct access to the vectors u,v and n so we need to maintain them in code. What glulookat does What are the directions of u,v and n when we execute glulookat() with given values for eye, look and up If given the locations of eye, look and up, we immediately know than n must be parallel to the vector eye-look, as shown above. so we can set n=eye-look We now need to find a u and a v that are perpendicular to n and to each other. The u direction points off to the side of a camera, so it is natural to make it perpendicular to up which the user has said is the upward direction.

6 What glulookat does II An easy way to build a vector that is perpendicular to two given vector is to form their cross product, so we set u=up x n The user should not choose an up direction that is parallel to n, because u then would have zero length. We choose u=up x n rather than n x up so that u will point to the right as we look along -n With u and n formed it is easy to determine v as it must be perpendicular to both and is thus the cross product of u and n thus v=n x u Notice that v will usually not be aligned with up as v must be aimed perpendicular to n whereas the user provides up as a suggestion of upwardness and the only property of up that is used is its cross product with n glulookat III To summarise, given eye look and up, we form n = eye look u = up n and v = n u and then normalise the vectors to unit length. How glulookat modifies the modelview Matrix How glulookat modifies the modelview Matrix This means that V must transform eye into the origin, u into the vector i, v into j, and nk The modelview is the product of two matrices the matrix V that accounts for the transformation of the world point into camera coordinates. and M that embodies all of the modelling transformations applied to the points. The function glulookat builds the V matrix and post-multiplies the current matrix by it. Because the job of the V matrix is to convert world co-ordinates to camera coordinates it must transform the camera's coordinate system into the generic position for the camera as shown in the figure. The easiest way to define V is to use the following matrix V = u x u y u z d x v x v y v z d y n x n y n z d z Where (d x,d y,d z )=( eye u, eye v, eye n) The matrix V is created by glulookat and post-multiplies the current matrix.

7 The Camera Revisited In order to have full control over the viewing of a scene we need to create our own Camera After each change to the camera's state the camera will tell OpenGL where the current View of the scene is by modifying the GL_MODELVIEW matrix When we use the Camera class we create a camera by setting the EYE, LOOK as points and UP as a vector. We then call the functions roll, pitch, yaw and slide to move the camera's position. A Camera Class m_eye m_look m_up m_u m_v m_n m_modelview m_projection Building the Camera 1 void Camera :: Set( 2 const Vector &_eye, 3 const Vector &_look, 4 const Vector &_up 5 ) 6 { 7 // make U, V, N vectors 8 m_eye=_eye; 9 m_look=_look; 10 m_up=_up; m_n=m_eye-m_look; 13 m_u=m_up.cross(m_n); 14 m_v=m_n.cross(m_u); 15 // now normalize 16 m_u.normalize(); 17 m_v.normalize(); 18 m_n.normalize(); 19 SetModelViewMatrix(); 20 } setting the ModelView matrix 1 void Camera::SetModelViewMatrix() 2 { 3 // grab a pointer to the matrix so we can index is quickly 4 Real *M=(Real *)&m_modelview.m_m; 5 6 M[0] = m_u.m_x; M[4] = m_u.m_y; M[8] = m_u.m_z; M[12] = -m_eye.dot(m_u); 7 M[1] = m_v.m_x; M[5] = m_v.m_y; M[9] = m_v.m_z; M[13] = -m_eye.dot(m_v); 8 M[2] = m_n.m_x; M[6] = m_n.m_y; M[10] = m_n.m_z; M[14] = -m_eye.dot(m_n); 9 M[3] = 0; M[7] = 0; M[11] = 0; M[15] = 1.0; 10 // now load them GL modelview matrix 11 m_modelview.loadmodelview(); 12 } 1 void Matrix::LoadModelView() const 2 { 3 glmatrixmode(gl_modelview); 4 glloadmatrixf(m_opengl); 5 }

8 Scale 2.0 r l 0 0 r+l r l Orthographic Projection Translate t b 0 t+b t b f+n f n f n void Camera::SetOrthoProjection() 2 { 3 m_projection.identity(); 4 5 m_projection.m_m[0][0]=2.0f /(m_r-m_l); 6 m_projection.m_m[0][3]=-((m_r+m_l)/(m_r-m_l)); 7 8 m_projection.m_m[1][1]=2.0f/(m_t-m_b); 9 m_projection.m_m[1][3]=-((m_t+m_b)/(m_t-m_b)); m_projection.m_m[2][2]=2.0f / (m_fr-m_nr) ; 12 m_projection.m_m[2][3]=-((m_fr+m_nr) /(m_fr-m_nr)); m_projection.m_m[3][3]=1.0f; m_projection.loadprojection(); 17 } ( ) fovy f = cot 2 f aspect f 0 0 f+n f n Perspective Projection 2fn f n 1 void Camera::SetPerspProjection() 2 { 3 float f= 1.0/tan((m_fov * M_PI / 360.0f)/2.0); 4 m_projection.identity(); 5 6 m_projection.m_m[0][0]=f/m_aspect; 7 m_projection.m_m[1][1]=f; 8 9 m_projection.m_m[2][2]=(m_zfar+m_znear)/(m_znear-m_zfar); 10 m_projection.m_m[2][3]=(2*m_zfar*m_znear)/(m_znear-m_zfar); m_projection.m_m[3][2]=-1; // need to transpose to get the correct values 15 m_projection.transpose(); 16 m_projection.loadprojection(); 17 } Slide 1 void Camera :: Slide( 2 const Real _du, 3 const Real _dv, 4 const Real _dn 5 ) 6 { 7 // slide eye by amount du * u + dv * v + dn * n; 8 m_eye.m_x += _du * m_u.m_x + _dv * m_v.m_x + _dn * m_n.m_x; 9 m_eye.m_y += _du * m_u.m_y + _dv * m_v.m_y + _dn * m_n.m_y; 10 m_eye.m_z += _du * m_u.m_z + _dv * m_v.m_z + _dn * m_n.m_z; 11 SetModelViewMatrix(); 12 } 1 void Camera::MoveEye( 2 const Real _dx, 3 const Real _dy, 4 const Real _dz 5 ) 6 { 7 m_eye.m_x+=_dx; 8 m_eye.m_y+=_dy; 9 m_eye.m_z+=_dz; 10 m_n=m_eye-m_look; 11 m_u.set(m_up.cross(m_n)); 12 m_v.set(m_n.cross(m_u)); 13 // normalize the vectors 14 m_u.normalize(); 15 m_v.normalize(); 16 m_n.normalize(); 17 // pass to OpenGL 18 SetModelViewMatrix(); 19 } 1 void Camera::MoveLook( 2 const Real _dx, 3 const Real _dy, 4 const Real _dz 5 ) 6 { 7 m_look.m_x+=_dx; 8 m_look.m_y+=_dy; 9 m_look.m_z+=_dz; 10 m_n=m_eye-m_look; 11 m_u.set(m_up.cross(m_n)); 12 m_v.set(m_n.cross(m_u)); 13 // normalise vectors 14 m_u.normalize(); 15 m_v.normalize(); 16 m_n.normalize(); 17 // pass to OpenGL 18 SetModelViewMatrix(); 19 }

9 Rotating the Camera To roll the camera is to rotate it about its own n- axis. This means that both the directions u and v must be rotated as shown below We form two new axes u' and v' that lie in the same plane as u and u, yet have been rotated through the angle α radians. To do this we need to form u' as the appropriate linear combination of u and v and similarly for v' rolling the Camera u = cos(α)u + sin(α)v v = sin(α)u+cos(α)v To roll the camera we need to replace the current u and v axes with the new u' and v' axes 1 void Camera:: RotAxes( 2 Vector& io_a, 3 Vector& io_b, 4 const Real _angle 5 ) 6 { 7 // rotate orthogonal vectors a (like x axis) and b(like y axis) through angle degrees 8 // convert to radians 9 Real ang = M_PI/180.0f*_angle; 10 // pre-calc cos and sine 11 Real c = cos(ang); 12 Real s = sin(ang); 13 // tmp for io_a vector 14 Vector t( c * io_a.m_x + s * io_b.m_x, c * io_a.m_y + s * io_b.m_y, c * io_a.m_z + s * io_b.m_z); 15 // now set to new rot value 16 io_b.set(-s * io_a.m_x + c * io_b.m_x, -s * io_a.m_y + c * io_b.m_y, -s * io_a.m_z + c * io_b.m_z); 17 // put tmp into _a' 18 io_a.set(t.m_x, t.m_y, t.m_z); 19 } 1 void Camera :: Roll( 2 const Real _angle 3 ) 4 { 5 RotAxes(m_u, m_v, -_angle); 6 SetModelViewMatrix(); 7 } 8 9 void Camera :: Pitch( 10 const Real _angle 11 ) 12 { 13 RotAxes(m_n, m_v, _angle); 14 SetModelViewMatrix(); 15 } void Camera :: Yaw( 18 const Real _angle 19 ) 20 { 21 RotAxes(m_u, m_n, _angle); 22 SetModelViewMatrix(); 23 } Using the Camera 1 #include <ngl/camera.h> 2 #include <ngl/vector.h> 3 4 ngl::camera cam; 5 6 // set the different vectors for the camera positions 7 ngl::vector EYE(0,5,8); 8 ngl::vector LOOK=0.0; 9 ngl::vector UP(0,1,0); float aspect=1024.0/768.0; cam.set(eye,look,up); 14 cam.setshape(45.0f,aspect, 0.2f,20.0f,ngl::PERSPECTIVE);

10 PathCamera The paths camera inherits all the features of the main Camera class and extends it to have the eye and look follow a path The path is created using two BezierCurves from the BezierCurve class The paths may be constructed using a series of points or from a file (exported from maya) 1 #include "ngl/beziercurve.h" 2 #include "ngl/pathcamera.h" 3 #include "ngl/vector.h" 4 5 ngl::pathcamera *pcam; 6 7 // Bezier Curve method 8 ngl::beziercurve curve; 9 curve.addpoint(5,1,0); 10 curve.addpoint(2,3,5); 11 curve.addpoint(-2,3,5); 12 curve.addpoint(-5,1,0); 13 curve.setlod(100); 14 curve.createknots(); 15 curve.createdisplaylist(); ngl::beziercurve curve2; 18 curve2.addpoint(2,0.1,1); 19 curve2.addpoint(1,0.5,-3); 20 curve2.addpoint(-1,0.5,-3); 21 curve2.addpoint(-2,0.1,1); 22 curve2.setlod(100); 23 curve2.createknots(); 24 curve2.createdisplaylist(); pcam = new ngl::pathcamera(ngl::vector(0,1,0),curve,curve2,0.001,ngl::perspective); 27 pcam->createcurvesfordrawing(400); 28 float aspect=1024.0/720.0; 29 // finally set the shape of the camera 30 pcam->setshape(45.0,aspect,0.5,50.0,ngl::perspective); 31 // set the active camera 32 pcam->use(); pcam->updatelooped(); 36 1 #include "ngl/beziercurve.h" 2 #include "ngl/pathcamera.h" 3 #include "ngl/vector.h" 4 5 ngl::pathcamera *pcam; 6 // file method 7 8 pcam = new ngl::pathcamera(ngl::vector(0,1,0),"loop.dat",0.001,ngl::perspective); 9 10 // end file method 11 */ 12 // now we set the level of detail for the curve 13 pcam->createcurvesfordrawing(400); // finally set the shape of the camera 16 pcam->setshape(45.0,1024.0/720.0,0.5,50.0,ngl::perspective); 17 // set the active camera 18 pcam->use();

11 1 import maya.openmaya as OM 2 import maya.openmayaanim as OMA 3 import maya.cmds as cmds 4 5 def ExportCurvesToOpenGLCamera(fname,eyeCurve,lookCurve) : 6 # get the control points of both the curves 7 EyePoints=cmds.getAttr( lookcurve+".cv[*]" ) 8 LookPoints=cmds.getAttr( eyecurve+".cv[*]" ) 9 # open the file 10 ofile=open(fname,'w') 11 #write out the number of cp in each curve 12 ofile.write("%d %d\n" %( len(eyepoints),len(lookpoints)) ) 13 # get curve Transformaiton matrix values 14 Ltx=cmds.getAttr(lookCurve+".xformMatrix") 15 Etx=cmds.getAttr(eyeCurve+".xformMatrix") 16 # create an empty matrix for both the curves 17 LtxM = OM.MMatrix() 18 EtxM = OM.MMatrix() # Create a matrix using the list 21 OM.MScriptUtil.createMatrixFromList( Ltx, LtxM) 22 OM.MScriptUtil.createMatrixFromList( Etx, EtxM) for n in range(0,len(eyepoints)) : 26 # convert the CP to a Point 27 worldpos = OM.MPoint(EyePoints[n][0],EyePoints[n][1],EyePoints[n][2]) 28 # multiply this by the TX matrix 29 e = worldpos*etxm 30 # write to the file 31 ofile.write("%f %f %f \n" %(e[0],e[1],e[2])) for n in range(0,len(lookpoints)) : 34 worldpos = OM.MPoint(LookPoints[n][0],LookPoints[n][1],LookPoints[n][2]) 35 e = worldpos*ltxm 36 ofile.write("%f %f %f \n" %(e[0],e[1],e[2])) ofile.close() ExportCurvesToOpenGLCamera("/Users/jmacey/Cam.txt","curve2","curve1") References Computer Graphics With OpenGL, F.S. Hill jr, Prentice Hall (most images from the instructors pack of this book) Basic Algebra and Geometry. Ann Hirst and David Singerman. Prentice Hall 2001 "Essential Mathematics for Computer Graphics fast" John VinceSpringer- Verlag London "Geometry for Computer Graphics: Formulae, Examples and Proofs" John Vince Springer-Verlag London 2004