Clipping

1. Clipping Jian Huang, CS594 This set of slides reference slides devised at Ohio State and MIT.

2. Object Space World Space Eye Space Clipping Space Screen Space Viewing Pipeline Revisited Canonical view volume • Object space: coordinate where each component is defined • World space: all components put together via affine transformation. (camera, lighting defined in this space) • Eye space: camera at the origin, view direction coincides with the z axis. Hither and Yon perpendicular to the z axis • Clipping space: All point is in homogeneous coordinate. Perspective division gets everything into 3D image space. • 3D image space (Canonical view volume): a parallelpipied shape defined by (-1:1,-1:1,0,1). Objects distorted. • Screen space: x and y mapped to screen pixel coordinates

3. Why do clipping • Clipping is a visibility preprocess. In real-world scenes clipping can remove a substantial percentage of the environment from consideration. • Clipping offers an important optimization

4. What is clipping, two views • Clipping is to spatially partition geometric primitives, according to their containment within some region. Clipping can be used to: • Distinguish whether geometric primitives are inside or outside of a viewing frustum or picking frustum • Detecting intersections between primitives • Clipping is to subdivide geometric primitives. Several other potential applications. • Binning geometric primitives into spatial data structures • computing analytical shadows.

5. Point Clipping (x, y) is inside iff AND

6.  y < ymax y > ymin ymax interior = ymin x > xmin x < xmax xmin xmax Line Clipping - Half Plane Tests • Modify endpoints to lie in rectangle • “Interior” of rectangle? • Answer: intersection of 4 half-planes • 3D ? (intersection of 6 half-planes)

7. Line Clipping • Is end-point inside a clip region? - half-plane test • If outside, calculate intersection betwee line and the clipping rectangle and make this the new end point • Both endpoints inside: trivial accept • One inside: find intersection and clip • Both outside: either clip or reject (tricky case)

8. Cohen-Sutherland Algorithm (Outcode clipping) • Classifies each vertex of a primitive, by generating an outcode. An outcode identifies the appropriate half space location of each vertex relative to all of the clipping planes. Outcodes are usually stored as bit vectors.

9. Cohen-Sutherland Algorithm (Outcode clipping) if (outcode1 == '0000' and outcode2 == ‘0000’) then line segment is inside else if ((outcode1 AND outcode2) == 0000) then line segment potentially crosses clip region else line is entirely outside of clip region endif endif

10. The Maybe cases? • If neither trivial accept nor reject: • Pick an outside endpoint (with nonzero outcode) • Pick an edge that is crossed (nonzero bit of outcode) • Find line's intersection with that edge • Replace outside endpoint with intersection point • Repeat outcode test until trivial accept or reject

11. The Maybe case

12. The Maybe Case

13. One Plane At a Time Clipping(a.k.a. Sutherland-Hodgeman Clipping) • The Sutherland-Hodgeman triangle clipping algorithm uses a divide-and-conquer strategy. • Clip a triangle against a single plane. Each of the clipping planes are applied in succession to every triangle. • There is minimal storage requirements for this algorithm, and it is well suited to pipelining. • It is often used in hardware implementations.

14. Sutherland-HodgmanPolygon Clipping Algorithm • Subproblem: • clip a polygon (input: vertex list) against a single clip edges • output the vertex list(s) for the resulting clipped polygon(s) • Clip against all four planes • generalizes to 3D (6 planes) • generalizes to any convex clip polygon/polyhedron • Used in viewing transforms

15. Polygon Clipping At Work

16. Sutherland-Hodgman SHclippedge(var: ilist, olist: list; ilen, olen, edge : integer) s = ilist[ilen];     olen = 0; for i = 1 to ilen do d := ilist[i]; if (inside(d, edge) then if (inside(s, edge) then-- case 1 addlist(d, olist);     olen := olen + 1; else                                          -- case 4 n := intersect(s, d, edge); addlist(n, olist);addlist(d, olist);    olen = olen + 2; elseif (inside(s, edge) then            -- case 2 n := intersect(s, d, edge);addlist(n, olist);  olen ++; s = d; end_for;

17. Sutherland-Hodgman SHclip(var: ilist, olist: list; ilen, olen : integer) SHclippedge(ilist, tmplist1, ilen, tlen1, RIGHT); SHclippedge(tmplist1, tmplist2, tlen1, tlen2, BOTTOM); SHclippedge(tmplist2, tmplist1, tlen2, tlen1, LEFT); SHclippedge(tmplist1, olist, tlen1, olen, TOP);

18. With Pictures

19. Sutherland-Hodgman • Advantages: • Elegant (few special cases) • Robust (handles boundary and edge conditions well) • Well suited to hardware • Canonical clipping makes fixed-point • implementations manageable • Disadvantages: • Only works for convex clipping volumes • Often generates more than the minimum number of triangles needed • Requires a divide per edge

20. Interpolating Parameters

21. y x z image plane near far 3D Clipping (Planes) • Red Polygon – Clip • Transform into 4D Clipping space (canonical viewing volume) Homogenous co-ordinates

22. Naïve 3D Euclidean Space Clipping After perspective projection, Euclidean space is not linear!!

23. Difficulty with Euclidean Space Clipping • Clipping will handle most cases. However, there is one case in general that cannot be handled this way. • Parts of a primitive lie both in front of and behind the viewpoint. This complication is caused by our projection stage. • It has the nasty habit of mapping objects in behind the viewpoint to positions in front of it. • Solution: clip in homogeneous coordinate

24. 4DPolygonClip • Use Sutherland Hodgman algorithm • Use arrays for input and output lists • There are six planes of course !

25. 4D Clipping • OpenGL uses -1<=x<=1, -1<=y<=1, -1<=z<=1 • We use: -1<=x<=1, -1<=y<=1, -1<=z <=0 • Must clip in homogeneous coordinates: • w>0: -w<=x<=w, -w<=y<=w, -w<=z<=0 • w<0: -w>=x>=w, -w>=y>=w, -w>=z>=0 • Consider each case separately • What issues arise ?

26. 4D Clipping • Point A is inside, Point B is outside. Clip edge AB x = Ax + t(Bx – Ax) y = Ay + t(By – Ay) z = Az + t(Bz – Az) w = Aw + t(Bw – Aw) • Clip boundary: x/w = 1 i.e. (x–w=0); w-x = Aw – Ax + t(Bw – Aw – Bx + Ax) = 0 Solve for t.

27. W=-X W=X P1=[1,2,3,4] W=1 P2=[-1,-2,-3,-4] Still have issues with 4D Clipping • P1 and P2 map to same physical point ! • Solution: • Clip against both regions • Negate points with negative W

28. P1 W=1 -Inf Inf Still have issues with 4D Clipping P2 • Line straddles both regions • After projection one gets two line segments • How to do this? Only before the perspective division

29. More on Perspective Transform • There are a number of perspective matrices depending on the field of view desired, and the near and far plane. But same essential idea: a perspective matrix moves the depth value z into the fourth column, where it will used to divide through the x and y values • when the final homogeneous coordinate is translated back into a 3D point (3D image space), z is usually referred to as ‘depth’ of the point

30. More on perspective transforms

31. More on Perspective Transform • Perspective projections categorized by the number of axis the view plane cuts (ie 1-point, 2-point or 3-point perspective) • the plane cuts the z axis, lines parallel to the z meets at infinity; lines parallel to the x or y axis will not meet at infinity. 1-point perspective. • the plane cuts the x and z axis, lines parallel to the x/z axis meet at infinity; lines parallel to the y axis will not meet at infinity. 2-point perspective. • if the plane cuts the x, y, and z axis then lines parallel to the x, y, or z axis will meet at infinity. This is 3-point perspective.

32. More on Homogeneous Coordinates • To 4D: (x,y,z) -> (x,y,z,1) • Back to 3D: (x,y,z,w) -> (x/w, y/w, z/w) • A point is on a plane if the point satisfies 0 == A*x + B*y + C*z + D • Point P: (x,y,z,1). • Representing a plane N = (A,B,C,D). Point P is on the plane, if P dot N == 0

33. Transforming Normals

34. Transforming Normals • Transform P to P’ -> P’ = M * P (M is known) • and transform N to N’ -> N’ = Q * N • Let Q be our transformation matrix for N. • We want to make sure that after transformation, N’ is the normal of the transformed plane. That is, N’T * P’ = 0 • We get: N’T * P’ = (Q * N)T * (M * P) = NT * QT * M * P = 0

35. Transforming Normals • So, need QT *M = Identity • Then, QT = M –1 • Still, we want N’ = Q * N. • Q = (M –1)T

36. Object Space World Space Eye Space Clipping Space Screen Space Viewing Pipeline Revisited Canonical view volume • Object space: coordinate where each component is defined • World space: all components put together via affine transformation. (camera, lighting defined in this space) • Eye space: camera at the origin, view direction coincides with the z axis. Hither and Yon perpendicular to the z axis • Clipping space: All point is in homogeneous coordinate. Perspective division gets everything into 3D image space. • 3D image space (Canonical view volume): a parallelpipied shape defined by (-1:1,-1:1,0,1). Objects distorted. • Screen space: x and y mapped to screen pixel coordinates

37. Right-Handed Or Left-Handed • Usually use right-handed coordinate (convention in math) • Left-handed good for screen • To convert, just flip x or y or z. (any one of the three)

38. How about the viewing pipeline? • The range of z for the canonical view volume is [0,1]. x and y still remain the same. • Is converting back and forth (flipping) a major issue?