Computer Graphics Implementation II

1. Computer Graphics ImplementationII

2. Polygon Filling • Scan-line Conversion Approaches • Area Filling Approaches • Antialiasing • Clipping

3. Polygon Filling • Scan-line Conversion • Area Filling

4. P4 P0 P2 P3 P1 P6 P5 P7 Polygon Filling • Vertex-edge representation  Pixel set representation

5. P4 P0 P2 P3 P1 P6 P5 P7 Scan-line Conversion Check pixel by pixel

6. How to judge a point inside or outside a polygon? • Shoot a radial from the point to intersect with the polygon edges; if there are odd number of intersection points, the point is inside the polygon; if even number, outside. • Odd point: the intersection point is polygon’s vertex (special case).

7. P4 P0 P2 P3 P1 P6 P5 P7 Scan-line Conversion Improved (limit the pixel sets into the bounding box of the polygon for speeding up)

8. Scan-line Conversion • Scan-line polygon-fill algorithm • Taking full advantage of the coherence properties of pixels • Three coherence properties • Area coherence • Scan-line coherence • Edge coherence

9. Area Coherence The screen region between two scan-lines is partitioned into some trapezoids by the polygon. (1) Two types of trapezoid: the one inside the polygon and the one outside polygon. (2) The two types of trapezoids are arranged alternately.

10. Scan-line Coherence Suppose the intersection points of scan-line y=e and polygon edge ei (Pi-1Pi) is xei. Suppose the intersection points sequence arranged by the x-increase is xei1, xei2, xei3 … xein. According to area coherence, we can get: • n is even number • On the scan-line, only the segments (xeik, xeik+1), k=1,3,5,…n–1) are inside the polygon. Scan-line coherence is the reflection of area coherence on a scan-line.

11. Edge Coherence Suppose the intersection point sequence on y=e is xei1, xei2, …xein; point sequence on y=e-1 is xdi1, xdi2, … xdin. If edge er(Pr-1Pr) intersects with both y=e and y=e-1; the corresponding points xer and xdr have following relationship: xer = xdr + 1/mr Thus, we can calculate the intersection points on y=e from the points on y=e-1 Edge coherence is the reflection of area coherence on edges.

12. Polygon Filling • Scan-line Conversion • Area Filling

13. Area Filling • Area Filling:To start from a given interior position (seed) and paint outward from this point until we encounter the specified boundary conditions. • The “area” should be identified with its interior color or boundary color. • Colorate all the interior pixels to a specified color • Colorate all the boundary pixels to the boundary color

14. 种子填充 Two kinds of connectivity 4-connected Neighbourhood 8-connected Neighbourhood

15. 8-connected area 4-connected area 4-connected area and 8-connected area • 4-connected area: Giving any two interior points A and B, we can travel from A to B by the 4-directions moving: right, left, up and down moving. • To filling the 4-connected area, we only need to test its 4-direction neighbors

16. 4-connected area and 8-connected area • The boundary of 8-connected area must be 4-connected • The boundary of 4-connected area is 8-connected

17. Recursive Method for Filling a 4-connected Area The area is identified by the boundary color void AreaFill4(int x, int y, int fillCol, int boundaryCol) { int currentCol = getPixel(x,y); if( (currentCol != boundaryCol)&& (currentCol != fillCol)) { setPixel(x, y, fillCol); AreaFill4(x, y+1, fillCol, boundaryCol); AreaFill4(x, y-1, fillCol, boundaryCol); AreaFill4(x-1, y, fillCol, boundaryCol); AreaFill4(x+1, y, fillCol, boundaryCol); } }

18. Recursive Method for Filling a 4-connected Area The area is identified by the interior color. Called flood-fill algorithm void FloodFill4(int x, int y, int fillCol, int interiorCol) { int currentCol = getPixel(x,y); if( currentCol == interiorCol ) { setPixel(x, y, fillCol); FloodFill4(x, y+1, fillCol, interiorCol); FloodFill4(x, y-1, fillCol, interiorCol); FloodFill4(x-1, y, fillCol, interiorCol); FloodFill4(x+1, y, fillCol, interiorCol); } }

19. Recursive Method for Filling a 4-connected Area F G N M D E A L O H J I C K P B

20. Recursive Method for Filling a 4-connected Area Left pixel to 3 is the last one to be filled.

21. How to expand the algorithm for 4 –connected area to the algorithm for 8-connect area?

22. void AreaFill8(int x, int y, int fillCol, int boundaryCol) { int currentCol = getPixel(x,y); if((currentCol != boundaryCol) && (currentCol != fillCol)) { setPixel(x, y, fillCol); AreaFill8(x, y+1, fillCol, boundaryCol); AreaFill8(x, y-1, fillCol, boundaryCol); AreaFill8(x-1, y, fillCol, boundaryCol); AreaFill8(x+1, y, fillCol, boundaryCol); AreaFill8(x+1, y+1, fillCol, boundaryCol); AreaFill8(x+1, y-1, fillCol, boundaryCol); AreaFill8(x-1, y+1, fillCol, boundaryCol); AreaFill8(x-1, y-1, fillCol, boundaryCol); } }

23. Comparison Between Scan-line Conversion (A) and Area Filling (B) • Basic idea:A changes the edge list representation into lattice representation. It uses the coherences of polygons. B does not change the representation of the area, but the color. It uses the connectivity of area. • The requirements: For area filling, a seed point inside the area is needed. • Boundary: For A, the number of the intersection points of each scan line with edges should be even. For B, the boundary of 4-connected area is closed 8-connected area and the boundary of 8-connected area is closed 4-connected area.

24. Antialiasing • Aliasing Problems of Raster Graphics • Antialiasing Methods

25. Aliasing Problems of Raster Graphics • What’s aliasing? The distortion of information due to low-frequency sampling ( undersampling ) is called aliasing

26. y 9 8 7 6 5 4 3 2 1 0 x 0 1 2 3 4 5 6 7 8 9 Aliasing Problems of Raster Graphics --- Jagged Boundaries

27. Aliasing Problems of Raster Graphics --- Shape Distortion Slim Primitives are lost

28. Aliasing Problems of Raster Graphics --- Sparking The slim primitive sparks when it is moved

29. Antialiasing • Aliasing Problems of Raster Graphics • Antialiasing Methods

30. Antialiasing Methods • Adopting area-sampling instead of point-sampling • Supersampling

31. Area-sampling Using transitional color scales on the edges

32. Using Transitional Color Scales on the Edges

33. Area-sampling • Exact area-sampling is time-consuming • Some approximate algorithms are always used • Wu’s algorithm for drawing antialiasing lines • Pitteway and Watkinson’s algorithm for drawing antialiasing polygons

34. Supersampling for Antialiasing • Hardware method: adopting high resolution raster display • Software method: sampling objects at a high resolution and displaying the results at a lower resolution • High resolution sampling: partition each pixel as several sub-pixels, such as the 3*3 partition. Then compute color for all the sub-pixels • Low resolution display: compute the pixel’s color by adding up all its sub-pixels’ color with a weighting mask

35. C B A 1 2 1 E D F 4 2 2 I H G 1 2 1 Supersampling for Antialiasing Weight mask for the 3*3 partition 3*3 partition Pixel color = (ColA + 2*ColB + ColC + 2*ColD + 4*ColE + 2*ColF + ColG + 2*ColH + ColI ) / 16

36. 2 3 3 2 1 1 4 2 4 8 6 6 4 2 6 9 9 6 3 3 12 8 12 12 8 4 4 16 3 6 12 9 9 6 3 4 6 6 4 2 2 8 2 3 3 2 1 1 4 Supersampling for Antialiasing Weight mask for the 7*7 partition

37. Clipping

38. Clipping

39. Line Clipping Clipping endpoints xmin< x < xmaxandymin<y<ymax point inside Endpoint analysis for lines: if both endpoints in , do “trivial acceptance” if one endpoint inside, one outside, must clip if both endpoints out, don’t know Brute force clip: solve simultaneous equations using y = mx + b for line and four clip edges slope-intercept formula handles infinite lines only doesn’t handle vertical lines (Xmax , Ymax) (Xmin , Ymin)

40. Parametric Line Formulation For Clipping Parametric form for line segment X = x0 + t(x1 – x0) 0 <t< 1 Y = y0 + t(y1 – y0) P(t) = P0 + t(P1 – P0) “true,” i.e., interior intersection, if sedge and tline in [0,1]

41. Divide plane into 9 regions Compute the sign bit of 4 comparisons between a vertex and an edge ymax – y; y – ymin; xmax – x; x – xmin (>0 “0”; otherwise “1”) point lies inside only if all four sign bits are 0, otherwise exceeds edge 4 bit outcode records results of four bounds tests: “1” First bit: outside halfplane of top edge, above top edge Second bit: outside halfplane of bottom edge, below bottom edge Third bit: outside halfplane of right edge, to right of right edge Fourth bit: outside halfplane of left edge, to left of left edge o1=o2 =0, accept; AND(o1, o2) <>0 (in same side), discard. Outcodes for Cohen-Sutherland Line Clipping in 2D Clip Rectangle

42. Outcodes for Cohen-Sutherland Line Clipping in 3D Very similar to 2D Divide volume into 27 regions (Picture a Rubik’s cube) 6-bit outcode records results of 6 bounds tests First bit: outside back plane, behind back plane Second bit: outside front plane, in front of front plane Third bit: outside top plane, above top plane Fourth bit: outside bottom plane, below bottom plane Fifth bit: outside right plane, to right of right plane Sixth bit: outside left plane, to left of left plane Bottom plane 000000 (above) 000100 (below) Front plane 010000 (in front) 000000 (behind) Top plane 001000 (above) 000000 (below) Back plane 000000 (in front) 100000 (behind) Left plane 000001 (to left of) 000000 (to right of) Right plane 000000 (to left of) 000010 (to right of)

43. If we can neither trivially reject/accept, divide and conquer subdivide line into two segments; then T/A or T/R one or both segments: use a clip edge to cut line use outcodes to choose edge that is crossed Edges where the two outcodes differ at that particular bit are crossed pick an order for checking edges top – bottom – right – left compute the intersection point the clip edge fixes either x or y can substitute into the line equation iterate for the newly shortened line “extra” clips may happen (e.g., E-I at H) Cohen-Sutherland Algorithm D C I B A H G Clip rectangle F E 1010 0100

44. ComputeOutCode(x0, y0, outcode0) ComputeOutCode(x1, y1, outcode1) repeat check for trivial reject or trivial accept pick the point that is outside the clip rectangle if TOP then x = x0 + (x1 – x0) * (ymax – y0)/(y1 – y0); y = ymax; else if BOTTOM then x = x0 + (x1 – x0) * (ymin – y0)/(y1 – y0); y = ymin; else if RIGHT then y = y0 + (y1 – y0) * (xmax – x0)/(x1 – x0); x = xmax; else if LEFT then y = y0 + (y1 – y0) * (xmin – x0)/(x1 – x0); x = xmin; if (x0, y0 is the outer point) then x0 = x; y0 = y; ComputeOutCode(x0, y0, outcode0) else x1 = x; y1 = y; ComputeOutCode(x1, y1, outcode1) until done Pseudocode for the Cohen- Sutherland Algorithm • y = y0 + slope*(x - x0) and x = x0 + (1/slope)*(y - y0)

45. Cyrus-Beck/Liang-Barsky Parametric Line Clipping-1 Use parametric line formulation P(t) = P0 + (P1 – P0)t Determine where the line intersects the infinite line formed by each edge by solving for t 4 times. Decide which of these intersections actually occur on the rectangle For any point PEi on edge Ei

46. Now solve for the value of t at the intersection of P0 P1 with the edge Ei: Ni • [P(t) – PEi] = 0 First, substitute for P(t): Ni • [P0 + (P1 – P0)t – PEi] = 0 Next, group terms and distribute dot product: Ni • [P0 – PEi] + Ni • [P1 – P0]t = 0 Let D be the vector from P0to P1=(P1– P0), and solve for t: 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: Ni 0 (that is, the normal should not be 0; this could occur only as a mistake) D 0 (that is, P1P0) Ni • D 0 (edge Ei and line D are not parallel; if they are, no intersection). The algorithm checks these conditions. C-B/L-B Param. Line Clipping-2

47. Eliminate t’s outside [0,1] on the line (does not to be processed) Which remaining t’s produce interior intersections? Can’t just take the innermost t values! (decide PE and PL) Move from P0 to P1; for a given edge, just before crossing: if Ni • D < 0 Potentially Entering (PE), if Ni • D > 0 Potentially Leaving (PL) Pick inner PE, PL pair: tE for PPE with max t, tL for PPL with min t, and tE > 0, tL < 1. If tL < tE, no intersection (Line 2) C-B/L-B Param. Line Clipping-3

48. Pseudocode for Cyrus-Beck/ Liang-Barsky Line Clipping Algorithm Pre-calculate Ni and select PEi for each edge; for each line segment to be clipped if P1 = P0 then line is degenerate so clip as a point; else begin tE = 0; tL = 1; for each candidate intersection with a clip edge if Ni • D  0 then {Ignore edges parallel to line} begin calculate t; {of line and clip edge intersection} use sign of Ni• D to categorize as PE or PL; if PE then tE = max(tE,t); if PL then tL = min(tL,t); end if tE > tLthen return nil else return P(tE) and P(tL) as true clip intersections end

49. D = P1 – P0 = (x1 – x0, y1 – y0) Leave PEi as an arbitrary point on the clip edge; it’s a free variable and drops out Clip Edgei Normal Ni PEi P0-PEi left: x = xmin (-1,0) (xmin, y) (x0- xmin,y0-y) right: x = xmax (1,0) (xmax,y) (x0- xmax,y0-y) bottom: y = ymin (0,-1) (x, ymin) (x0-x,y0- ymin) top: y = ymax (0,1) (x, ymax) (x0-x,y0- ymax) Calculations for Parametric Line Clipping Algorithm

50. Sutherland-Hodgman Polygon Clipping