Забыли?

?

# View Transformation

код для вставкиСкачать
```View Transformation
CSC 830 Note 3
Course note credit to Prof. Seth Teller, MIT
View Transformation
Transform (i.e., express) geometry into coordinates that are
well-suited to (simple) clipping and projection hardware
Positioning Synthetic Camera
What are our вЂњdegrees of freedomвЂќ in camera
positioning?
To achieve effective visual simulation, we want:
1) the eye point to be in proximity of modeled scene
2) the view to be directed toward region of interest,
and
3) the image plane to have a reasonable вЂњtwistвЂќ
Eye Coordinates
Eyepoint at origin
u axis toward вЂњrightвЂќ of image plane
v axis toward вЂњtopвЂќ of image plane
view direction along negative n axis
Transformation to Eye
Coordinates
Our task: construct the transformation M
that re-expresses world coordinates in the
viewer frame
Machinery: Changing
Orthobases
Suppose you are given an
orthobasis u, v, n
What is the action of the
matrix M with
rows u, v, and n as below?
Applying M to u, v, n
Two equally valid interpretations, depending on
reference frame:
1: Think of uvn basis as a rigid object in a fixed
world space
Then M вЂњrotatesвЂќ uvn basis into xyz basis
2: Think of a fixed axis triad, with вЂњlabelsвЂќ from
xyz space
Then M вЂњreexpressesвЂќ an xyz point p in uvn
coords!
It is this second interpretation that we use today
to вЂњrelabelвЂќ world-space geometry with eye space
coordinates
Positioning Synthetic Camera
Given eyepoint e, basis Л†u, Л†v, Л†n
Deduce M that expresses world in eye coordinates:
Overlay origins, then change bases:
Positioning Synthetic Camera
Check: does M re-express world geometry in eye coordinates?
Positioning Synthetic Camera
Camera specification must include:
World-space eye position e
World-space вЂњlookat directionвЂќ -n
Are e and -n enough to determine the camera DOFs
(degrees of freedom)?
Positioning Synthetic
Camera
Are e and -n enough to determine the camera DOFs?
No. Note that we were not given u and v!
(Why not simply require the user to specify them?)
We must also determine u and v, i.e., camera вЂњtwistвЂќ about n.
Typically done by specification of a world-space вЂњup vectorвЂќ
provided by user interface, e.g., using gluLookat(e, c, up)
вЂњTwistвЂќ constraint: Align v with world up vector (How?)
Positioning Synthetic
Camera
Where are we?
What is Projection?
Any operation that reduces dimension (e.g., 3D to 2D)
Orthographic Projection
Perspective Projection
Orthographic Projection
вЂў focal point at infinity
вЂў rays are parallel and orthogonal to the image plane
Image
F
W
I
World
World
Image
F
Comparison
Simple Perspective Camera
вЂў
вЂў
вЂў
вЂў
camera looks along z-axis
focal point is the origin
image plane is parallel to xy-plane at distance d
d is call focal length
Similar Triangles
Y
[Y, Z]
[(d/Z)Y, d]
Z
[0, 0]
[0, d]
вЂў Similar situation with x-coordinate
вЂў Similar Triangles:
point [x,y,z] projects to [(d/z)x, (d/z)y, d]
Projection Matrix
Projection using homogeneous coordinates:
вЂ“ transform [x, y, z] to [(d/z)x, (d/z)y, d]
пѓ©пЂ d
пѓЄпЂ пѓЄпЂ 0
пѓЄпЂ 0
пѓЄпЂ пѓЄпЂ пѓ«пЂ 0
0
d
0
0
0 0пѓ№пЂ пѓ©пЂ xпѓ№пЂ пѓєпЂ пѓЄпЂ пѓєпЂ пѓ©пЂ d
пѓ№пЂ 0 0пѓєпЂ пѓЄпЂ yпѓєпЂ d
= [dx dy dz z ] пѓћ пѓЄпЂ x
y dпѓєпЂ пѓєпЂ пѓЄпЂ пѓєпЂ пѓ«пЂ пѓ»пЂ z
z
d 0пѓєпЂ пѓЄпЂ z пѓєпЂ Divide by 4th coordinate
1 0пѓєпЂ пѓ»пЂ пѓЄпЂ пѓ«пЂ 1пѓєпЂ пѓ»пЂ (the вЂњwвЂќ coordinate)
вЂў 2-D image point:
вЂў discard third coordinate
вЂў apply viewport transformation to obtain
physical pixel coordinates
Perspective Projection
Perspective Projection
z = 0 not allowed (what happens to points on plane z = 0?)
Operation well-defined for all other points
Perspective Projection
Matrix formulation using вЂњhomogeneous 4-vectorsвЂќ:
Finally, recover projected point using homogenous convention:
Divide by 4th element to convert 4-vector to 3-vector:
Are we ready to
rasterize? Not yet.
вЂў It is difficult to do clipping directly
in the viewing frustum
The View Frustum
Canonical View Volume
Matrix Formulation
Perspective Projection
Suppose we have transformed from World to Eye to Canonical
coordinates
How do we project onto вЂњimage planeвЂќ?
Simply ignore z coordinate!
Qualitative Features of
Perspective Projection
Equal-sized objects at different depths project to different
sizes!
Perspective projection does not preserve shape of planar figures!
Families of parallel lines
have вЂњvanishing pointsвЂќ
projection of point at
infinity in direction of lines
Continue with
OpenGL
OpenGL
п‚§ OpenGL is a low-level graphics API
п‚§ Window system independent
п‚§ No facility for window events/user input
п‚§ Can use additionally libraries (eg. GLUT)
п‚§ Vertex driven
п‚§ Primitives assembled from vertices
п‚§ ***OpenGL is a state machine***
OpenGL
Commands or display list
per vertex
operations
&
primitive
assembly
Rasterization
per pixel
operations
Frame
Buffer
Clearing the Buffers
Clears the buffers using the specified values
glClearColor(GLclampf
GLclampf
GLclampf
GLclampf
red,
green,
blue,
alpha)
glClear(GLbitfield mask)
Masks:
GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT,
GL_ACCUM_BUFFER_BIT, GL_STENCIL_BUFFER_BIT
Drawing Primitives
Begin/End drawing a primitive
glBegin(GLenum mode)
glEnd()
Modes:
GL_POINTS, GL_LINES, GL_TRIANGLES,
GL_TRIANGLE_STRIP, GL_QUADS,
GL_POLYGON
Drawing Primitives
Draw a vertex of a primitive
glVertex3f(GLfloat x,
GLfloat y,
GLfloat z)
Variants:
glVertex3fv(const GLfloat *v)
2d,3d,4d, shorts, ints, floats, doubles
The vertex is drawn according to the current state
Elements of Current
State
Current:
п‚§ Color
п‚§ Normal
п‚§ Texture coordinates
п‚§ Drawing mode
п‚§ Matrix mode
п‚§ Matrix on:
п‚§ Modelview stack
п‚§ Perspective stack
п‚§ Texture stack
Drawing Example
Draw a simple square:
glBegin(GL_POLYGON);
glVertex3f(-0.5, 0.5,0.5);
glVertex3f( 0.5, 0.5,0.5);
glVertex3f( 0.5,-0.5,0.5);
glVertex3f(-0.5,-0.5,0.5);
glEnd();
Changing the Current
Color
Set the current color:
glColor3f(GLfloat red,
GLfloat green,
GLfloat blue)
Variants:
glColor4f(red, green, blue, alpha)
bytes, unsigned bytes,
shorts, ints, floats, doubles
Drawing Example
Adding color:
glBegin(GL_POLYGON);
glColor3f(1,0,0);
glVertex3f(-0.5, 0.5,0.5);
glVertex3f( 0.5, 0.5,0.5);
glVertex3f( 0.5,-0.5,0.5);
glVertex3f(-0.5,-0.5,0.5);
glEnd();
Changing the Current
Normal
Set the current normal:
glNormal3f(GLfloat nx,
GLfloat ny,
GLfloat nz)
Variants:
glNormal3fv(const GLfloat *v)
bytes, shorts, ints, floats, doubles
Drawing Example
Adding normals:
glBegin(GL_POLYGON);
glColor3f(1,0,0);
glNormal3f(0,0,1);
glVertex3f(-0.5, 0.5,0.5);
glVertex3f( 0.5, 0.5,0.5);
glVertex3f( 0.5,-0.5,0.5);
glVertex3f(-0.5,-0.5,0.5);
glEnd();
Transformation Pipeline
Stages of vertex transformations:
Modelview
Matrix
Object
coords
Projection
Matrix
Camera
coords
Viewport
Mapping
Normalized
coords
Window
coords
Transformation Pipeline
Matrices are set up on stacks
Matrix commands are post-multiplied onto the
current matrix
the last command issued is
the first transformation applied to the object
Can save/restore the current matrix
Transformation Pipeline
Save/Restore the current matrix:
glPushMatrix()
glPopMatrix()
Change the current matrix stack:
glMatrixMode(GLenum mode)
GL_MODELVIEW, GL_PROJECTION,
GL_TEXTURE
Transformation Pipeline
Translate:
glTranslatef(GLfloat x,
GLfloat y,
GLfloat z)
Scale:
glScalef(GLfloat x,
GLfloat y,
GLfloat z)
Transformation Pipeline
Rotate:
glRotatef(GLfloat
GLfloat
GLfloat
GLfloat
angle,
x,
y,
z)
angle is given in degrees
X,y,z is the unit rotation axis
Transformation Pipeline
Hierarchical Modelling:
glTranslatef(waistx,waisty,waistz);
glPushMatrix();
glRotatef(ra,rx,ry,rz);
// draw right arm
glPopMatrix();
glPushMatrix();
glRotatef(la,lx,ly,lz);
// draw left arm
glPopMatrix();
Drawing Example
Adding transformations:
glMatrixMode(GL_MODELVIEW);
glBegin(GL_POLYGON);
glTranslatef(0,0,0);
glRotatef(0,0,1,0);
glScalef(1,1,1);
glColor3f(1,0,0);
glNormal3f(0,0,1);
glVertex3f(-0.5, 0.5,0.5);
glVertex3f( 0.5, 0.5,0.5);
glVertex3f( 0.5,-0.5,0.5);
glVertex3f(-0.5,-0.5,0.5);
glEnd();
Cameras
Perspective Camera
glFrustum(GLdouble left, GLdouble right,
GLdouble bottom, GLdouble top,
GLdouble near, GLdouble far)
Orthographic Camera
glOrtho(GLdouble left, GLdouble right,
GLdouble bottom, GLdouble top,
GLdouble near, GLdouble far)
Shading
Setting the Shading Model
glShadeModel(GLenum mode)
Modes:
GL_FLAT
GL_SMOOTH
- FLAT shading
- GOURAUD shading
Lights
Defining Lights
glLightfv(GLenum light, GLenum pname,
GLfloat *param)
glEnable(GL_LIGHTING)
glEnable(GL_LIGHT0)
Parameters:
GL_AMBIENT
GL_DIFFUSE
GL_SPECULAR
GL_POSITION
вЂ“
RGBA ambient intensity
RGBA diffuse intensity
RGBA specular intensity
light position
Lights
Setting the Ambient Light
glLightModelfv(GLenum pname,
GLfloat *param)
Parameters:
GL_LIGHT_MODEL_AMBIENT
- global RGBA ambient intensity
Materials
Defining Material Properties
glMaterialfv(GLenum face, GLenum pname,
GLfloat *param)
Faces:
GL_FRONT, GL_BACK, GL_FRONT_AND_BACK
Parameters:
GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR,
GL_EMISSION, GL_SHININESS
Drawing Example
Adding Lighting:
float lPos[] = {1.0,1.0,1.0,1.0};
glLightfv(GL_LIGHT0,GL_POSITION,lPos);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glShadeModel(GL_SMOOTH);
float diffuse[] = {1.0,0.0,0.0,1.0};
glMaterialfv(GL_FRONT,GL_DIFFUSE,diffuse);
// Setup camera
// Draw objects
Event Driven
Programming
п‚§ Program responds to events
п‚§ Events are handled by user defined
callback functions
п‚§ Callbacks must know context and
event type (passed through variables)
Event Driven
Programming
Display
Handler
Keyboard
Handler
Mouse
Handler
Main
Event
Loop
Simple GLUT Example
Displaying a square
int main (int argc, char *argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
int windowHandle
= glutCreateWindow("Simple GLUT App");
glutDisplayFunc(redraw);
glutMainLoop();
return 0;
}
Display Callback
Called when window is redrawn
void redraw()
{
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_QUADS);
glColor3f(1, 0, 0);
glVertex3f(-0.5, 0.5, 0.5);
glVertex3f(0.5, 0.5, 0.5);
glVertex3f(0.5, -0.5, 0.5);
glVertex3f(-0.5, -0.5, 0.5);
glEnd(); // GL_QUADS
glutSwapBuffers();
}
More GLUT
Additional GLUT functions
glutPositionWindow(int x,int y);
glutReshapeWindow(int w, int h);
Additional callback functions
glutReshapeFunction(reshape);
glutMouseFunction(mousebutton);
glutMotionFunction(motion);
glutKeyboardFunction(keyboardCB);
glutSpecialFunction(special);
glutIdleFunction(animate);
Reshape Callback
Called when the window is resized
void reshape(int w, int h)
{
glViewport(0.0,0.0,w,h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0,w,0.0,h, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
Mouse Callbacks
Called when the mouse button is pressed
void mousebutton(int button, int state, int x, int y)
{
if (button==GLUT_LEFT_BUTTON && state==GLUT_DOWN)
{
rx = x; ry = winHeight - y;
}
}
Called when the mouse is moved with button down
void motion(int x, int y)
{
rx = x; ry = winHeight - y;
}
Keyboard Callbacks
Called when a button is pressed
void keyboardCB(unsigned char key, int x, int y)
{
switch(key)
{ case 'a': cout<<"a Pressed"<<endl; break; }
}
Called when a special button is pressed
void special(int key, int x, int y)
{
switch(key)
{ case GLUT_F1_KEY:
cout<<вЂњF1 Pressed"<<endl; break; }
}
Animation Callbacks
Called when the system is idle
void animationCB()
{
float time = glutGet(GLUT_ELAPSED_TIME);
glRotated(time,0.0,1.0,0.0);
glutPostRedisplay();
}
Menu Callbacks
Creating a menu
enum { M_NONE, M_OPEN, M_SAVE, M_EXIT };
glutCreateMenu(menuFunc);
glutAddMenuEntry("Open", M_OPEN);
glutAddMenuEntry("-----------------------", M_NONE);
glutAddMenuEntry("Exit", M_EXIT);
glutAttachMenu(GLUT_RIGHT_BUTTON);
Called when a menu button is pressed
void menuFunc(int value)
{
switch(value)
{ case M_EXIT: exit(0); break; }
}
```
###### Документ
Категория
Презентации
Просмотров
10
Размер файла
706 Кб
Теги
1/--страниц
Пожаловаться на содержимое документа