Basic Raster Graphics Trifles make perfection but perfection

Basic Raster Graphics • "Trifles make perfection, but perfection is no trifle" Michael Angelo ++ Topics • Scan conversion – line segments – polygon • Filling – polygon – thick primitives • Clipping – line segments – polygon Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 1

Scan Converting Line Segments • Compute coordinates of pixel that lie on or near an infinitely thin line segment placed on a 2 D integer grid. • -- Criteria – Sequence of pixels should be 'straight' – If slope is between -1 and 1, exactly 1 pixel should be 'illuminated' in each column – All lines should have constant brightness (independent of length and orientation) – Rapid display – Thick lines, dotted lines – Other special effects Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 2

Scan Converting Line Segments • Basic Algorithm : – – Input (X 0, Y 0) (X 1, Y 1) Since y=mx + c – Compute yi for many xi Paint (xi, Floor (yi)) or rather (xi, Floor (0. 5 + yi)) – Inefficient and slow • Basic Incremental Algorithm (DDA) – Since yi = mxi + c yi + 1 = yi + m – Works if -1 � m � 1 Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 3

Basic Incremental Algorithm Procedure Line(X 0, X 1, Y 0, Y 1, Value : integer) var x: integer; dy, dx, y, m : real: begin dy : = Y 1 - Y 0 ; dx : = X 1 - X 0 ; m : = dy/dx; y : = Y 0 ; for x : = X 0 to X 1 do begin Write Pixel (x, Round (y), value); y : = y + m ; end Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 4

Mid point Line Algorithm • Motivated by – floating point computation – orientation dependency in previous algorithm. • Basic idea illustrated for slope between 0 to 1 NE M E – Recall only one pixel in each column – Which pixel (E or NE) can be found if midpoint M is determined to be above (E) or below (NE) the line – The determination is easy if implicit form of line segment is chosen F(x, y) = Ax + By + C F(x, y) = 0 for line segment Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 5

Mid point Line Algorithm • • Implementation – – – Use a decision variable "d" = F(xi+1, yi+1/2) d > 0 implies E Method needed to 'update' d. – Initialization Algorithm generalizes for circles, ellipses, conics. Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 6

Procedure Midpoint line (X 0, Y 0, X 1, Y 1, value : integer) var dx, dy, incr. E, incr. NE, d, x, y : integer ; begin dx : = X 1 - X 0 ; dy : = Y 1 -Y 0 ; d : = 2 * dy - dx incre: = 2 * dx ; incr. NE : = 2* (dy - dx) ; x : = X 0 ; Y : = Y 0 ; Write Pixel (x, y, value); X < X 1 do While X < X 1 do begin if d � 0 then begin d : = d + incr. E ; x : = x + 1 ; end else begin d : =d + incr. NE ; x ++; y ++ ; Write Pixel (x, y, Value) ; end end Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 7

Integer Arithmetic Scan Conversion • Sometimes we want the scan conversion to be biased • Pixels only to the 'right' of the line segment should be turned on. • Midpoint algorithm is 'too' fair ! • Basic Idea : (Illustrated with case when slope >1) – – Store increment separately as numerator and denominator Example : Suppose xmin = 3 and slope = 7/2 Separately store the sequence 3, 23/7, 25/7, 27/7, 29/7 fd Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 8

Integer Arithmetic Scan Conversion Algorithm : Procedure Left integer); Edge (X 0, X 1, Y 0, Y 1, Value : begin var x, y, num, denom, increment : integer; X: = X 0; Y: = Y 0; num : = X 1 -X 0; denom : = Y 1 -Y 0; increment : = denom ; for Y: = Y 0 to Y 1 do begin Write Pixel (X, Y, value); increment : = increment + numerator; if increment > denom then begin X: = x +1; increment : = increment - denom; end {if} end {for loop} end ( proc left edge ) Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 9

Clipping Line Segments • Large number of line segments generated, but many of them 'invisible' • Simple case: line segments clipped against an axis aligned rectangular window • Brute force method – Think of line segments as lines – Intersect given line segment with line segment of clip window – Is this point within the window ? – Too many calculations ! Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 10

Clipping Line Segments • Cohen-Sutherland algorithm computes outcodes 1001 1000 0001 0101 – – 0100 1010 0110 To trivially accept a line segment, check the out codes of the two ends. If both the out codes are 0000, then the line segment is accepted. To trivially reject a line segment, logically AND the outcodes of the ends. If the result is greater than 0 , then REJECT. Big advantage: If trivial accepts and rejects can't be done, we can identify which clip window line segment (when extended) does intersect the given line segment. Point of intersection is computed only in this case Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 11

Procedure Clip (X 0, Y 0, X 1, Y 1, Xmin Xmax, Ymin, Ymax : real type edge = (Left, Right, Bottom, Top); outcode = Set of edge; var accept, done : boolean; Outcode 0, Outcode 1, Outcode. Out : outcode; x, y : real ; procedure Comp. Out. Code (x, y : real; var code : outcode ); begin code : = [ ] if y > ymax then code : = code + {Top}; else if y < ymin then code : = code + {Bottom}; if x > xmax then code : = code + {Right}; else if x < xmin then code : = code + {Left}; end ; begin accept : = false ; done : = false ; Comp. Out. Code (X 0, Y 0, Outcode 0); Comp. Out. Code (X 1 Y 1, Outcode 1) repeat if (Outcode 0 = [ ]) and (outcode 1 = [ ])then begin accept : = true : done : = true ; end else if (outcode 0 * outcode 1) <> [ ] then done : = true else Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 12

begin if outcode 0 <> [ ] then outcode. Out : = outcode 0 then outcode. Out : = outcode 1 ; if Top in outcode. Out then begin x: = X 0 + (X 1 - X 0)/(Y 1 - Y 0) (Ymax -Y 0); y: = Ymax end else if Bottom in outcode. Out then begin X: = X + (X 1 -Xo) * (Ymin-Y 0) / (Y 1 -Y 0); X: = Ymin ; end else if Right in outcode. Out then begin y: = Y 0 + (Y 1 -Yo) * (Xmax-X 0) / (X 1 -X 0): x: = Xmax end if (outcode. Out = outcode 0) then begin X 0 : =x; Y 0 : =y; Comp. Out. Code (X 0, Y 0, Outcode. O); end else begin X 1: =x; Y 1: = y; Comp. Out. Code (X 1, Y 1, Outcode 1); end until (done): Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 13

Parametric Line Clipping • If clip window is not necessarily axis aligned, the method of Cohen-Sutherland is awkward • Parametric method works even if clipwindow is any convex polygon (not necessarily rectangular) • Also useful if the line segment is in three space (3 D) • Basic Idea : – Given P 0, P 1 the equation of the line segment P(t) = P 0 t + (1 - t) P 1. . . t P 1 P 0 – For an 'interesting' intersection, the value of parameter 't' at point of intersection [0, 1]. Thus line segments can be 'shortened' or clipped. Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 14

Parametric Line - Clipping • Some intersections are 'potentially' entering and some are leaving P 0 P 1 Pb Ni Pa P(t) Ni P 1 P 0 • P 0 Mathematics P 1 Pb • Leaving if angle is < 90 (sign of denominator) D = Ni. (P 1 P 0) > 0 Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 15

Parametric Line Clipping procedure cyrus_beck (P 0, P 1, Pa, Pb, Pc, Pd : point; var t. E, t. L : real; var trivial : boolean); begin calculate Ni and select point "a" for each edge if P 1 = Po then trivial: = point_in_polygon (Po, Pa, Pb, Pc, Pd) else begin t. E : = 0; t. L : = 1 ; for each edge of polygon do begin if Ni D <> 0 then begin 1. Calculate t 2. Use sign of Ni. D to categorize as entering or leaving 3. if entering then t. E : = max (t. E, t); 4. if leaving then t. L : =min (t. L, t); end if t. E > t. L then trivial : = true ; end Example t. L=1 P 1 N t. E=0 t P 0 N Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 16

Clipping Polygons • • All the edges of polygons can't be treated as line segments and clipped Clip convex and concave polygons against clip windows Input Window Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 17

Basic Sutherland Hodgman Algorithm const max = 20 ; type vertex = point; edge = array [1. . 2] of vertex ; vertex. Array = array [1. . Max} of vertex ; procedure clip (in : vertex. Array: var out : vertexarray ; inlength : integer ; var outlength : integer ; bdy : edge); Var s, p, i : vertex; j : integer ; begin outlength : = 0; s : = in [inlength] ; for j : = 1 to inlength do begin p : = in [j] ; if Inside (p, bdy) then if Inside (s, bdy) then Output (P, outlength, out); else begin intersect (i, s, p, bdy); Output (i, outlength, out); Output (p, outlength out); end else if Inside (s, bdy) then begin Intersect (i, s, p, bdy) ; Output (i, outlength, out) end s : = p ; end {for} end Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 18

Polygon Clipping (Finer Points) • Make code use less memory ; procedure clip takes a new parameter ; 1. Clip (in, out, inlength, outlength, bdy, range); 2. Replace an 'output' statement ( procedure call) by checks if range < total then clip again else output. 3. Requires a new initialization step. • Topological analysis necessary Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 19

Filling Polygons • Shading a polygon with some color or stipple pattern gives it 'character' • Shading a rectangle is easy, but watch out for xor mode drawing when two rectangles intersect Common point • Convention: a 'boundary' pixel is not considered to be part of the primitive if the halfplane defined by the edge of pixel lies below or to the left of the edge. (Pixel on top and right part of rectangle won't be drawn). Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 20

Filling Polygons • For arbitrary simple polygons (Convex, concave, and containing holes), a traversal is made from the bottom to the top. For a single ordinate, 'spans' of the input polygon are filled with the desired shade. • Three steps in filling – Compute intersection points – Sort – Draw when the 'parity' bit is set. (Parity, initially even, is toggled at each intersection point) Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 21

Simple Ordered Edge List Consider the polygon shown in Figure. Solid area scan conversion The polygon vertices are Intersections with the half interval scan lines are Scan line 1. 5 : (8, 1. 5), (1, 1. 5) Scan line 2. 5 : (8, 2. 5), (1, 2. 5) Scan line 3. 5 : (8, 3. 5), (5. 5, 3. 5), (4. 5, 3. 5), (1, 3. 5) Scan line 4. 5 : (8, 4. 5), (6. 5, 4. 5), (3. 5, 4. 5), (1, 4. 5) Scan line 5. 5 : (8, 5. 5), (7. 5, 5. 5), (2. 5, 5. 5), (1, 5. 5) Scan line 6. 5 : (1. 5, 6. 5), (1, 6. 5) Scan line 7. 5 : none Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 22

Simple Ordered Edge List • The complete list sorted in scan line order from the top to the bottom, and then from left to right is (1, 6. 5), (1. 5. 6. 5), (1, 5. 5), (2. 5, 5. 5), (7. 5, 5. 5), (8, 5. 5), (1, 4. 5), (3. 5, 4. 5), (6. 5, 4. 5), (8, 4. 5), (1, 3. 5), (4. 5, 3. 5), (5. 5, 3. 5), (8, 3. 5), (1, 2. 5), (8, 2. 5), (1, 1. 5), (8, 1. 5) • • Extracting pairs of intersections from the list and applying the algorithm given above yields the pixel activation list (1, 6) (1, 5), (2, 5), (7, 5) (1, 4), (2, 4), (3, 4), (6, 4) (7, 4) (1, 3), (2, 3) (3, 3), (4, 3), (5, 3), (6, 3), (7, 3) (1, 2), (2, 2) (3, 2), (4, 2), (5, 2), (6, 2), (7, 2) (1, 1), (2, 1) (3, 1), (4, 1), (5, 1), (6, 1), (7, 1) The result is shown in figure. Notice that both vertical edges and the bottom edge are drawn correctely. Results of solid area scan conversion of polygon Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 23

Scan Line (Edge List) Algorithm • Implementation issues – Special cases for parity rule can be handled by "if intersection points ordinate is the same as that of ymax of an edge, the intersection is not counted. " Scan left – 'Left' edges implies 'inside' part should be shaded – Data preparation and filling: basic algorithm 1. For each polygon edge, and for all scan lines, compute point of intersection 2. Sort first by y and then, within a single y (ordinate), by x 3. Extract pairs from the output. Activate pixels x such that for each pair (x 1 y) and (x 2 y) Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 24

Scan Line (Edge List) Algorithm • Example: Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 25

Edge Sets Active Edges Scan line 1 2 3 4 5 6 7 8 B C A D y-bucket sort 1 null 2 x. BA, ymin= 6, x. BC, ymin= 4 3 null 4 x. CD, ymin= 8 5 null 6 x. AD, ymin= 8 7 null 8 null Active Edge List Scan line 3 : x. BA+ x. BA, x. BC, x. BC Scan line x. BA + 3 x. BA, x. CD + x. CD, x. CD Scan line 7 : x. CD + 3 x. CD, x. AD, + x. AD, x. AD Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 26

Scan Line Filling • More efficiency can be obtained by using 'scan line coherence' (edges are not likely to change much from scan line to scan line) • Sorting, computing intersections, done on the fly • Preprocessing: – – – Global edge table (ET) contains all edges sorted by smaller y coordinate. (Bucket sort) Within each edge table bucket, edges kept in order of increasing x-coordinate of lower endpoint Each entry contains Ymax of edge Xmin x coordinate of bottom poit 1/m inverse slope flag left edge or right edge. Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 27

Scan Line Filling • Example C ymax Polygon and scan line 8 Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 28

Active Edge Scan Line Algorithm 1. Set y to smallest y coordinate that has an entry in ET 2. Initialize AET : = nil 3. Repeat until AET and ET are empty: 3. 1 Move entering edges 3. 2 Fill in desired edges 3. 3 Remove leaving edges 3. 4 Update y to next scan line 3. 5 Update AET using x : = x + 1/m 3. 6 Resort the AET Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 29

Active Edge Scan Line Algorithm 1. Set y to the smallest y coordinate that has an entry in the ET; i. e. y for the first nonempty bucket 2. Initialize the AET to be empty 3. Repeat until the AET and ET are empty: 3. 1 Move from ET bucket y to the AET those edges whose ymin = y (entering edges), maintaing AET sort order on x 3. 2 Fill in desired pixel values on scan line y by using pairs of x coordinates from the AET 3. 3 Remove from the AET those entries for which y = ymax (edges not involved in the next scan line) 3. 4 Increment y by 1 (to the y coordinate of the next scan line) 3. 5 For each nonvertical edge remaining in the AET, update x for the new y 3. 6 Because the previous step may have caused the AET to become out of order on x, resort the AET Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 30

Active Edge Scan Line Algorithm Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 31

Image Space Filling Algorithms • Edge fill: For each scan line intersecting a polygon edge at (x 1 y 1) complement all pixels whose midpoint lie to the right of (x 1 y 1) i. e. for (x 1 y 1) such that • x + 1 > x 1 2 Example Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 32

Image Space Filling Algorithms Edge Fill Algorithm Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 33

Image Space Filling Algorithms • Fence fill : ( A 'fence' is an absicssa) For each scan line intersecting a polygon edge : – If intersection is to left of fence, complement all pixels to the right of the intersection and to left of fence – Otherwise, complement all pixels to the left of or on the intersection and to the right of fence Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 34

Image Space Filling Algorithms Fence Fill Algorithm Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 35

Edge Flag Algorithm • Edge flag : Analogous to scan line, but in device space 1. Outline contour • 2. Fill it inside Example Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 36

Edge Flag Algorithm The edge flag algorithm Contour outline : Using the half scan line convention for each edge of the polygon, set the leftmost pixel whose midpoint lies to the right of the intersection; i. e. , for x + 1/2 > xint, to the boundary value. Fill : For each scan line intersecting the polygon begin Inside = FALSE for x = 0 (left) to x = Xmax (right) if the pixel at x is set to the boundary value then negate Inside If Inside = TRUE then set the pixel at x to the polygon value else reset the pixel at x to the background value end if next x end { for } Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 37

Image Space Filling Algorithms • Other algorithms Seed fill : 1. Push seed pixel to stack 2. While not empty stack do begin • • pop(s) set pixel value recursively seed fill (nbrs, pixel) Example Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 38

Image Space Filling Algorithms Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 39

A Scan Line Seed Fill Algorithm Scan line seed fill algorithm A seed pixel on a span is popped from a stack containing the seed pixel The span containing the seed pixel is filled to the right and left of seed pixel along a scan line until a boundary is found. The algorithm remembers the extreme left and the extreme right pixel in the span as xleft and xright. In the range of xleft � xright the scan lines immediately above & immediately below the current scan line are examined to see if they completely contain either boundary pixels or previously filled points. If these scan lines do not contain either boundary or previously filled pixels, then in the range Xleft � x � Xright the extreme right pixel in 0 each span is marked as a seed pixel and pushed onto the stack. Project-Impact/CSE/IITB/93 CG/Mod-2/SC/ 40