From Vertices To Fragments-1

Transcription

1 From Vertices To Fragments-1 1

2 Objectives Clipping Line-segment clipping polygon clipping 2

3 Overview At end of the geometric pipeline, vertices have been assembled into primitives Must clip out primitives that are outside the view frustum Algorithms based on representing primitives by lists of vertices Must find which pixels can be affected by each primitive Fragment generation Rasterization or scan conversion 3

4 Required Tasks Modeling Geometry processing Projection Primitive assembly Clipping shading Rasterization or scan conversion fragment processing Hidden surface removal Antialiasing 4

5 Basic Implementation strategies Consider two approaches to rendering a scene with opaque objects Image-based approach For every pixel, determine which object that projects on the pixel is closest to the viewer and compute the shade of this pixel Ray tracing paradigm Object-based approach For every object, determine which pixels it covers and shade these pixels Pipeline approach Must keep track of depths 5

6 Clipping 2D against clipping window 3D against clipping volume Easy for line segments and polygons Hard for curves and text Convert to lines and polygons first 6

7 Clipping 2D Line Segments Brute force approach: compute intersections with all sides of clipping window Inefficient: one division per intersection 7

8 Cohen-Sutherland Algorithm Idea: eliminate as many cases as possible without computing intersections Start with four lines that determine the sides of the clipping window y = y max x = x min x = x max y = y min 8

9 The Cases Case 1: both endpoints of line segment inside all four lines Draw (accept) line segment y = y max x = x min x = x max y = y min Case 2: both endpoints outside all lines and on same side of a line Discard (reject) the line segment 9

10 The Cases Case 3: One endpoint inside, one outside Must do at least one intersection Case 4: Both outside May have part inside Must do at least one intersection y = y max x = x min x = x max 10

11 Defining Outcodes For each endpoint, define an outcode b 0 b 1 b 2 b 3 b 0 = 1 if y > y max, 0 otherwise b 1 = 1 if y < y min, 0 otherwise b 2 = 1 if x > x max, 0 otherwise b 3 = 1 if x < x min, 0 otherwise Outcodes divide space into 9 regions Computation of outcode requires at most 4 subtractions 11

12 The Cohen-Sutherland Line- Clipping Algorithm If both 4-bit codes of the endpoint are zero, the line is Trivially Accepted If the logical AND of the endpoints is not zero, the line is Trivially rejected. 12

13 The Cohen-Sutherland Line- Clipping Algorithm If neither test is successful find an endpoint that lies outside test the code to find the edge that is crossed determine the corresponding intersection point. Clip off the line segment from the outside endpoint to the intersection point by replacing the outside endpoint with the intersection point compute the code of this new endpoint to prepare for the next iteration. 13

14 Example Consider the 5 cases below AB: outcode(a) = outcode(b) = 0 Accept line segment 14

15 Example CD: outcode (C) = 0, outcode(d) 0 Compute intersection Location of 1 in outcode(d) determines which edge to intersect with Note if there were 2 ones in outcode, we might have to do two interesections 15

16 Example EF: outcode(e) logically ANDed with outcode(f) (bitwise) 0 Both outcodes have a 1 bit in the same place Line segment is outside of corresponding side of clipping window reject 16

17 Example GH and IJ: same outcodes, neither zero but logical AND yields zero Shorten line segment by intersecting with one of sides of window Compute outcode of intersection (new endpoint of shortened line segment) Reexecute algorithm 17

18 Efficiency In many applications, the clipping window is small relative to the size of the entire data base Most line segments are outside one or more side of the window and can be eliminated based on their outcodes Inefficiency when code has to be reexecuted for line segments that must be shortened in more than one step 18

19 Cohen Sutherland in 3D Use 6-bit outcodes When needed, clip line segment against planes 19

20 Liang-Barsky Clipping Consider the parametric form of a line segment p(a) = (1-a)p 1 + ap 2 1 a 0 p 1 p 2 We can distinguish between the cases by looking at the ordering of the values of a where the line determined by the line segment crosses the lines that determine the window 20

21 Liang-Barsky Clipping In (a): 1>a 4 > a 3 > a 2 > a 1 >0 Intersect right, top, left, bottom: shorten In (b): 1>a 4 > a 2 > a 3 > a 1 >0 Intersect right, left, top, bottom: reject 21

22 Advantages Can accept/reject as easily as with Cohen-Sutherland Using values of a, we do not have to use algorithm recursively as with C-S Extends to 3D 22

23 Parametric Lines and Intersections For L 1 x=x0 l1 + t(x1 l1 x0 l1 ) y=y0 l1 + t(y1 l1 y0 l1 ) For L 2 x=x0 l2 + t(x1 l2 x0 l2 ) y=y0 l2 + t(y1 l2 y0 l2 ) The Intersection Point: x0 l1 + t 1 (x1 l1 x0 l1 ) = x0 l2 + t 2 (x1 l2 x0 l2 ) y0 l1 + t 1 (y1 l1 y0 l1 ) = y0 l2 + t 2 (y1 l2 y0 l2 ) 23

24 Clipping Lines Clipping Lines by Solving Simultaneous Equations Two sets of simultaneous equations of this parametric form can be solved for parameters t edge for the edge and t line for the line segment. The value of t edge and t line can be checked to see whether both lie in [0,1]; if they do, the intersection point is a true clip-rectangle intersection. Shortcoming: considerable calculation and testing 24

25 Cyrus-Beck/Liang-Barsky Parametric Line Clipping Use parametric line formulation P(t) = P 0 + (P 1 P 0 )t Find the four t s for the four clip edges, then decide which form true intersections and calculate (x, y) for those only (< 2)

26 C-B/L-B Param. Line Clipping-2 Now solve for the value of t at the intersection of P 0 P 1 with the edge E i : N i [P(t) P Ei ] = 0 First, substitute for P(t): N i [P 0 + (P 1 P 0 )t P Ei ] = 0 Next, group terms and distribute dot product: N i [P 0 P Ei ] + N i [P 1 P 0 ]t = 0 Let D be the vector from P 0 to P 1, D= (P 1 P 0 ), and solve for t: N i [ P 0 N D i Note that this gives a valid value of t only if the denominator of the expression is nonzero. For this to be true, it must be the case that: N i 0 (the normal should not be 0; this could occur only as a mistake) D 0 (P 1 P 0 ) N i D 0 (edge E i and line D are not parallel; if they are, no intersection). The algorithm checks these conditions. t P Ei ]

27 C-B/L-B Param. Line Clipping-3 Eliminate t s outside [0,1] on the line Which remaining t s produce interior intersections? Can t just take the innermost t values! Move from P 0 to P 1 ; for a given edge, just before crossing: if N i D < 0 Potentially Entering (PE), if N i D > 0 Potentially Leaving (PL) Pick inner PE, PL pair: t E for P PE with max t t L for P PL with min t, and t E > 0, t L < 1. If t L < t E, no intersection

28 A Parametric Line-Clipping Algorithm(1) Liang-Barsky 1.For each clip edge (to upright rectangle), we can easily calculate a value t corresponding to the intersection point between the edge and the line segment. 2.We get four values of in t total. 3.Intersections can be classified as PE or PL on the basis of the angle between P 0 P 1 and the normal of the edge. < 90, PL (N i. D <0 ) >90, PE (N i. D >0 ) PE: Point Entering the clipping rectangle PL: Point Leaving the clipping rectangle 28

29 A Parametric Line-Clipping Algorithm(2) Liang-Barsky 4.Divide t into two groups({t 0, t 0 } {t 1, t 1 }) according to its corresponding intersection belongs to PE or PL. 5.We get t 0 = max (t 0, t 0,0) t 1 = min(t 1, t 1,1) If t 0 < t 1, the line segment between [t 0, t 1 ] is visible, otherwise, the whole line is invisible 29

30 A Parametric Line-Clipping Algorithm(3) Liang-Barsky precalculate N i for each edge for (each line segment to be clipped){ If (P 0 = P 1 ) Line is degenerate so clip as a point; else{ t e =0; t l =1; for (each candidate intersection with a clip edge){ if (N i * D!=0) { // ignore edges parallel to line calculate t; use sign of N i * D to categorize as PE or PL; if (PE) t e =max(t e. t); if (PL) t l =min(t l. t); } } if (t e > t l ) return nil; else return P(t e ) and P(t l ) as true clip intersections; } } 30

31 Calculations for Parametric Line Clipping for Upright Clip Rectangle D = P 1 P 0 = (x 1 x 0, y 1 y 0 ) Leave P Ei as an arbitrary point on the clip edge; it s a free variable and drops out Clip Edge i Normal N i P Ei P 0 -P Ei t N i ( P P ) 0 Ei N D i left: x = x min (-1,0) (x min, y) (x 0 - x min,y 0 -y) ( x x ) 0 min ( x x ) 1 0 right: x = x max (1,0) (x max,y) (x 0 - x max,y 0 -y) ( x x ) 0 max ( x x ) 1 0 bottom: y = y min (0,-1) (x, y min ) (x 0 -x,y 0 - y min ) ( y y ) 0 min ( y y ) 1 0 top: y = y max (0,1) (x, y max ) (x 0 -x,y 0 - y max ) ( y y ) 0 max ( y y ) 1 0

32 Polygon Clipping Not as simple as line segment clipping Clipping a line segment yields at most one line segment Clipping a polygon can yield multiple polygons However, clipping a convex polygon can yield at most one other polygon 32

33 Tessellation and Convexity One strategy is to replace nonconvex (concave) polygons with a set of triangular polygons (a tessellation) Also makes fill easier Tessellation code in GLU library 33

34 Edge-by-Edge Polygon Clippping For rectangular clipping regions Cohen-Sutherland Liang-Barsky 34

35 Clipping as a Black Box Can consider line segment clipping as a process that takes in two vertices and produces either no vertices or the vertices of a clipped line segment 35

36 Pipeline Clipping of Line Segments Clipping against each side of window is independent of other sides Can use four independent clippers in a pipeline 36

37 Sutherland-Hodgerman The algorithm clips against a single, infinite clip edge and outputs another series of vertices defining the clipped polygon. In a second pass, the partially clipped polygon is then clipped against the second clip edge, and so on. Polygon Clipping 37

38 Four possible cases At each step, zero, one, or two vertices are added to the output list of vertices that defines the clipped polygon. Output intersection points as new polygon vertices as they are found Can be pipelined, introduce spurious edges, Generalizes to 3D 38

39 Examples of Polygon Clipping new edges may be introduced on the border of the clip rectangle (a). 39

40 Bounding Boxes Rather than doing clipping on a complex polygon, we can use an axis-aligned bounding box or Volume (AABB) Smallest rectangle aligned with axes that encloses the polygon Simple to compute: max and min of x and y 40

41 Bounding boxes Can usually determine accept/reject based only on bounding box reject accept requires detailed clipping 41

42 Other Volumes Sphere Ellipsoid Usage: Clipping collision detection 42

43 43 3D Clipping Plane-Line Intersections Three dimensions: add front and back clippers ) ( ) ( p p n p p n a o 0 n ))) ( ( (( P P a P P

44 Clipping and Normalization General clipping in 3D requires intersection of line segments against arbitrary plane Example: oblique view 44

45 Normalized Form top view before normalization after normalization Normalization is part of viewing (pre clipping) but after normalization, we clip against sides of right parallelepiped Typical intersection calculation now requires only a floating point subtraction, e.g. is x > x max 45