Watt Section 5.2, some typos
• Define a focal distance, d , and shift the origin to be at that distance (note d is negative)
P(x v
,y v
,z v
) y v
P(x s
,y s
) d
-z v x v

• Similar triangles gives: x

 x d z y v P(x s
,y s
) y

 d y z
P(x v
,y v
,z v
) d
View Plane
-z v

• Using homogeneous coordinates we can write:



 x y d












 z x y z d






P
 


1


0


0
0
0
0
0
1
0
0
1
1 d
0
0
0
0






P

• The image has a finite width and height
• Edges define clipping planes that cut off geometry outside the view
• Also define near and far clipping planes
– Clip things behind the camera and very distant
– Far plane can be problematic: Use tricks like “fog” to blend it out

x v
Image
Plane
Near Clip
Plane
View
Volume
Left Clip
Plane f
Far Clip
Plane
-z v
Right Clip
Plane

• gluPerspective(…)
– Field of view (determines focal distance)
– Aspect ratio (should match window aspect ratio)
– Near and far clipping planes
• Assumes that the image is centered in the image plane

• Image corners should be (-1,-1), (1,1) instead of (w,-h ), ( w,h )
• We need depth information to decide what’s in front
• Useful properties:
– Points on the image plane should map to z s
=0
– Points on the far clip plane should map to z s
=1
– Intersections of lines and planes in view space should map to their intersections in screen space
• Straight lines should transform to straight lines
• Planes should transform to planes

• Intersections pts maintained if: z s
=A+B/z v
• Desired mapping of image plane and far plane x s gives constraints. Solving equation gives:
 d x wz v v y s
 d y hz v v z s
 f (
(
1 f

 d d z v
)
)

• Using homogeneous coordinates we can write:





 x y z w s s s s











 d
0
0
0 w 0 d h
0
0 f
0
( f
0
 d )
1
 df
0
0
( f
0
 d )









 x v y v z v
1





• Note: w s width is homogeneous coordinate, w is window

• The transformation taking view to screen space can be decomposed into two components:
– One scales the space to make the side clipping planes of the form x=z, y=z
– The other deforms space to take the frustum to a box, with the focal point at -


• We really want the near clip plane to map to z s
=0
• Change focal dist to near clip dist, modify image size (or specify field of view and derive image size)
Image
Plane
New Image
Plane

• Previous case assumed that view window was centered with corners (-w,-h), (w,h)
• General case uses arbitrary area on image plane
(x min
,y min
), (x max
,y max
)
• OpenGL: glFrustum(...)
– Corners of frustum in image plane
– Near and far clip planes

• Shear the volume so that the central axis lies on the n-axis
– This is a shear, because rectangles on planes n=constant must stay rectangles
• Shear takes old window midpoint to (0, 0, d) - this means that matrix is:



1


0


0
0
0
1
0
0
0
0
1
0

 x min y min

2
 d y max
2
0 d
1 x max










v n u v n u

• It may seem sensible to specify a very near clipping plane and a very far clipping plane
– Sure to contain entire scene
• But, a bad idea:
– OpenGL only has a finite number of bits to store screen depth
– Too large a range reduces resolution in depth - wrong thing may be considered “in front”
• Distant stuff is very small anyway!

• Points in screen space are in homogeneous form
– Clipping (described next) must be done in this form
• “Perspective divide”, converts homogeneous points into 3D screen points
– x,y range from –1 to 1, z from 0 to 1
– Do lighting here
• Viewport transformation scales and translates x,y to fill the window in the screen: glViewport(…)

• Convert world to view: Translation and rotation
• Convert view to screen: Translation, possibly shearing, scaling and perspective
• Convert screen to window: Scale and translate
• All managed by OpenGL
– You just give the parameters

• Parts of the geometry to be rendered may lie outside the view volume
– View volume maps to memory addresses
– Out-of-view geometry generates invalid addresses
•
Clipping removes parts of the geometry that are outside the view
• Best done in screen space before perspective divide

• Points are trivial to clip - just check which side of the clip planes they are on (dot product)
• Many algorithms for clipping lines exist
– Next lecture
• Two main algorithms for clipping polygons exist
– Sutherland-Hodgman (today)
– Weiler (next lecture)

• Hard cases:

• Clip the polygon against each edge of the clip region in turn
– Clip polygon each time to line containing edge
– Only works for convex clip regions (Why?)

• To clip a polygon to a line:
– Consider the polygon as a list of vertices
– One side of the line is inside the clip region, the other outside
– Think of the process as rewriting the polygon, one vertex at a time
– Check start vertex: if “inside”, emit it, otherwise ignore it
– Process vertex list proceeding as follows…

• Look at the next vertex in the list:
– polygon edge crosses clip edge going from out to in: output crossing point, next vertex
– polygon edge crosses clip edge going from in to out: output crossing
– polygon edge goes from out to out: output nothing
– polygon edge goes from in to in: output next vertex

Inside Outside Inside Outside s
Inside Outside Inside Outside p p i s p
Output p s i p
Output i s
No output Output i,p

• In 3D, clip against planes instead of lines
– Six planes to clip against
– Inside/Outside test still works
• Suitable for hardware implementation
– Only need the clip edge, the endpoints of the current edge, and the last output point
– Polygon edges are output as they are found, and passed right on to the next clip region edge