CS3500 Computer Graphics Module: Scan Conversion

P. J. Narayanan Spring 2009

CS3500

Graphics in Practice: Summary

Basic primitives: Points, Lines, Triangles/Polygons. Each constructed fundamentally from points. Points can be specied in different coordinate systems. The pipeline of operations on a point is:

Modelling
Object Coords World Coords

View Orientation
Camera Coords

View Mapping
Normalized Coords

Clipping Viewport
Screen Coords

Object Txform

Camera Position

Camera Specs

Window Specs

CS3500

Scan Conversion

Scan Conversion or Rasterization

Primitives are dened using points, which have been mapped to the screen coordinates. In vector graphics, connect the points using a pen directly. In Raster Graphics, we create a discretized image of the whole screen onto the frame buffer rst. The image is scanned automatically onto the display periodically. This step is called Scan Conversion or Rasterization.
CS3500 Scan Conversion

Scan Converting a Point

The 3D point has been transformed to its screen coordinates (u, v). Round the coordinates to frame buffer array indices (i, j). Current colour is dened/known. Frame buffer array is initialized to the background colour. Perform: frameBuf[i, j] currentColour The function WritePixel(x, y, colour) does the above. If PointSize > 1, assign the colour to a number of points in the neighbourhood!
CS3500 Scan Conversion

Scan Converting a Line

Identify the grid-points that lie on the line and colour them. Problem: Given two end-points on the grid, nd the pixels on the line connecting them. Incremental algorithm or Digital Differential Analyzer (DDA) algorithm. Mid-Point Algorithm

CS3500

Scan Conversion

Line on an Integer Grid

1 0 1 0 1 0 1 0 1 0 1 0
CS3500

1 0 1 0

1 0 1 0

Scan Conversion

Incremental Algorithm
Function DrawLine(x1, y1, x2, y2, colour) x x2 x1, y y2 y1, slope y/x x x1, y y1 While (x < x2) WritePixel (x, round(y), colour) x x + 1, y y + slope EndWhile WritePixel (x2, y2, colour) EndFunction

CS3500

Scan Conversion

Points to Consider
If abs(slope) > 1, step through y values, adding inverse slopes to x at each step. Simple algorithm, easy to implement. Need oating point calculations (add, round), which are expensive. Can we do with integer arithmetic only? Yes: Bresenhams Algorithm We will study a simplied version of it called the Mid-Point Line Algorithm.
CS3500 Scan Conversion

Two Options at Each Step!

1 0 1 0 1 0 1 0 1 0 1 1 1 0 0 0 1 1 0 0 1 1 0 0 1 0 1 11 1 0 00 0 1 0 1 0 1 1 0 0 NE 0 0 1 1 1 1 1 0 0 0 1 1 0 0 1 0 1 1 0 0 1 0 11 00M 1 0 1 0 1 1 0 0 1 0

CS3500

Scan Conversion

Mid-Point Line Algorithm

Line equation: ax + by + c = 0, a > 0. Let 0 < slope = y/x = a/b < 1.0 F (x, y) = ax + by + c > 0 for below the line, < 0 for above. NE if d = F (M) > 0; E if d < 0; else any! dE = F (ME) = d + a, dNE = d + a + b. Therefore, E = a, NE = a + b.

1 Initial value: d0 = F (x1 + 1, y1 + 2 ) = a + b /2

Similar analysis for other slopes. Eight cases in total.

CS3500 Scan Conversion

Pseudocode
Function DrawLine (l, m, i, j, colour) a j m, b (l i), x l, y m d 2a + b, E 2a, N E 2(a + b) While (x < i) WritePixel(x, y, colour) if (d < 0) // East d d + E , x x + 1 else // North-East d d + N E , x x + 1, y y + 1 EndWhile WritePixel(i, j, colour) EndFunction
CS3500 Scan Conversion

Example: (10, 10) to (20, 17)

F (x, y) = 7x 10y + 30, a = 7, b = 10 d0 = 2 7 10 = 4, E = 2 7 = 14, NE = 6 d > 0 : NE (11, 11), d = 4 + 6 = 2 d < 0 : E (12, 11), d = 2 + 14 = 12 d > 0 : NE (13, 12), d = 12 + 6 = 6 d > 0 : NE (14, 13), d = 6 + 6 = 0 d = 0 : E (15, 13), d = 0 + 14 = 14 d > 0 : NE (16, 14), d = 14 + 6 = 8 Later, NE (17, 15), NE (18, 16), E (19, 16), NE (20, 17).
CS3500 Scan Conversion

Scan Converting Circles

Need to consider only with centre at origin: x2 + y 2 = r2. For arbitrary centre, add (xc, yc) to each point. 8-way symmetry: Only an eighth of the circle need to be scan converted! If (x, y) on circle, (x, y), (y, x) are also on the circle! Easy way: y = r2 x2, but oating point calculations!
CS3500 Scan Conversion

1 0 1 0 1 0 1 0 1 0 1 0

Back to Two Points??

1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0M 1 0 1 1 0 0 1 1 0 0 SE 1 0 11 00 1 0 1 0 1 0 1 0 E

Choice between E and SE neighbours between the vertical and the 45 degree lines.
CS3500 Scan Conversion

Mid-Point Circle Algorithm

Circle equation: x2 + y 2 r2 = 0 F (x, y) = x2 + y 2 r2 < 0 for inside circle, > 0 for outside. SE if d = F (M) > 0; E if d < 0; else any! dE = F (ME) = d + 2x + 3, Therefore, E = 2x + 3, dSE = d + 2(x y) + 5. SE = 2(x y) + 5.

5 1 Initial value: d0 = F (1, r 2 ) = 4 r

CS3500 Scan Conversion

Pseudocode
Function DrawCircle (r, colour) x 0, y r, d 1 r CirclePoints (x, y, colour) While (x < y) if (d < 0) // East d d + 2 x + 3, x x + 1 else // South-East d d + 2 (x y) + 5, x x + 1, y y 1 CirclePoints (x, y, colour) EndWhile EndFunction
CS3500 Scan Conversion

Eliminate Multiplication?
Current selection is E: What are the new s? = 2(x + 1) + 3 = E + 2 E = 2(x + 1 y) + 5 = SE + 2 SE Current selection is SE: What are the new s? = 2(x + 1) + 3 = E + 2 E = 2(x + 1 (y 1)) + 5 = SE + 4 SE if (d < 0) // East d d + E , E += 2, SE += 2, x++ else // South-East d d + SE, E += 2, SE += 4, x++, y = y 1
CS3500 Scan Conversion

Patterned Line
Represent the pattern as an array of booleans/bits, say, 16 pixels long. Fill rst half with 1 and rest with 0 for dashed lines. Perform WritePixel(x, y) only if pattern bit is a 1. if (pattern[i]) WritePixel(x, y) where i is an index variable starting with 0 giving the ordinal number (modulo 16) of the pixel from starting point.
CS3500 Scan Conversion

Shared Points/Edges
It is common to have points common between two lines and edges between two polygons. They will be scan converted twice. Sometimes harmful. Not efcient.

Solution: Treat the intervals closed on the left and open on the right. [xm, xM ) & [ym, yM ) Thus, edges of polygons on the top and right boundaries are not drawn.
CS3500 Scan Conversion

CS3500

Scan Conversion

Clipping
Often, many points map to outside the range in the normalized 2D space. Think of the FB as an innite canvas, of which a small rectangular portion is sent to the screen. Lets get greedy: draw only the portion that is visible. That is, clip the primitives to a clip-rectangle. Scissoring: Doing scan-conversion and clipping together.
CS3500 Scan Conversion

Clipping Points
Clip rectangle: (xm, ym) to (xM , yM ). For (x, y): xm x xM , ym y yM

Can use this to clip any primitives: Scan convert normally. Check above condition before writing the pixel. Simple, but perhaps we do more work than necessary. Analytically clip to the rectangle, then scan convert.
CS3500 Scan Conversion

Clipping Lines

CS3500

Scan Conversion

Intersecting Line Segments

Innite line equation: ax + by + c = 0. Not good for line segments! P = P1 + t (P2 P1), 0 t 1. Represent sides of clip-rectangles and lines for clipping this way, with two parameters t and s. Solve for s, t. Both should be within [0, 1].

CS3500

Scan Conversion

Cohen-Sutherland Algorithm
Identify line segments that can be accepted trivially. Identify line segments that can be rejected trivially. For the rest, identify the segment that falls within the cliprectangle. For ease of this, assign outcodes to each of the 9 regions.

CS3500

Scan Conversion

Region Outcodes
Bits from left to right: y > yM y < ym x > xM x < xm
1001 yM 0001 0000 0010 1000 1010

ym 0101 xm 0100 xM 0110

CS3500

Scan Conversion

Overall Algorithm
Accept: Reject: code1 | code0 == 0 code1 & code0 != 0

Else, identify one of the boundaries crossed by the line segment and clip it to the inside. Do it in some order, say,
TOP, RIGHT, BOTTOM , LEFT . BOTTOM

We also have: TOP = 1000, 0001, RIGHT = 0010

CS3500

= 0100,

LEFT

Scan Conversion

Intersecting with Right/Top

if (code & RIGHT) // Intersects right boundary // Adjust right boundary to the intersection with xM y y0 + (y1 y0) (xM x0) / (x1 x0) x xM ComputeCode(x, y) if (code & TOP) // Intersects top boundary // Adjust top boundary to the intersection with yM x x0 + (x1 x0) (yM y0) / (y1 y0) y yM ComputeCode(x, y)
CS3500 Scan Conversion

Whole Algorithm
0 code0 ComputeCode(x0, y0), code1 1 if (! (code1 | code0)) Accept and Return 2 if (code1 & code0) Reject and Return 3 code code1 ? code1 : code0 4 if (code & TOP) Intersect with yM line. 5 elsif (code & RIGHT) Intersect with xM line. 6 elsif (code & BOTTOM) Intersect with ym line. 7 elsif (code & LEFT) Intersect with xm line. 8 if (code == code1) Replace EndPoint1. 9 else Replace EndPoint0. 10 Goto step 1.
CS3500 Scan Conversion

4 to accept and 3 to reject.

CS3500

Scan Conversion

Discussion
Simple logical operations to check intersections etc. Not efcient, as external intersections are not eliminated. In the worst case, 3 intersections may be computed and then the line segment could be rejectd. 4 intersections may be computed before accepting a line segment.

CS3500

Scan Conversion

Clipping Polygons
Restrict drawing/lling of a polygon to the inside of the clip rectangle. A convex polygon remains convex after clipping. A concave polygon can be clipped to multiple polygons. Can perform by intersecting to the four clip edges in turn.

CS3500

Scan Conversion

An Example

CS3500

Scan Conversion

An Example

CS3500

Scan Conversion

Sutherland-Hodgman Algorithm
Input: A list of vertices v1, v2, , vn. Implied edges from vi to vi+1 and from vn to v1. Output: Another list of vertices giving the clipped polygon. Method: Clip the entire polygon to the innite line for each clip edge in turn. Four passes, the output of each is a partially clipped polygon used as input to the next. Post-processing to eliminate degenerate edges.
CS3500 Scan Conversion

Algorithm Detail
Process edges one by one and clip it to a line. Start with the edge E(vn, v1). Compare the current edge E(vi1, vi) with the current clip line. Clip it to lie within the clip rectangle. Repeat for the next edge E(vi, vi+1). Till all edges are processed. When processing E(vi1, vi), treat vi1 as the in vertex and vi as the out vertex.
CS3500 Scan Conversion

At Each Step ...

in vertex: s (already handled). out vertex: p. Four cases:
p p p p In Out s In Out s

In Out

In Out

CS3500

Scan Conversion

Function SuthHodg()
p last(inVertexList) // Copy, not remove while (notEmpty(inVertexList)) s p, p removeNext(inVertexList) if (inside(p, clipBoundary)) if (inside(s, clipBoundary)) addToList(p, outVertexList) // Case 1 else i intersect(s, p, clipBoundary) // Case 4 addToList(i, outVertexList), addToList(p, outVertexList) elsif (inside(s, clipBoundary)) // Case 2 addToList(intersect(s, p, clipBoundary), outVertexList)
CS3500 Scan Conversion

Complete Algorithm
Invoke SuthHodg() 4 times for each clip edge as clipBoundary. The outVertexList after one run becomes the inVertexList for the next. Uses list data structures to implement polygons. Function inside() determines if a point is in the inside of the clip-boundary. We can dene it as being on the left when looking from rst vertex to the second. Can be extended to clip to any convex polygonal region!
CS3500 Scan Conversion

Filled Rectangles
Write to all pixels within the rectangle. Function FilledRectangle (xm, xM , ym, yM , colour) for xm x xM do for ym y yM do WritePixel (x, y. colour) EndFunction How about non-upright rectangles? General polygons?

CS3500

Scan Conversion

Filled Polygons
For each scan line, identify spans of the polygon interior. Strictly interior points only. For each scan line, the parity determines if we are inside or ouside the polygon. Odd is inside, Even is outside. Trick: End-points count towards parity enumeration only if it is a ymin point. Span extrema points and other information can be computed during scan conversion. This information is stored in a suitable data structure for the polygon.
CS3500 Scan Conversion

Parity Checking
D

F C E

CS3500

Scan Conversion

Edge Coherence
If scan line y intersects with an edge E, it is likely that y + 1 also does. (Unless intersection is the ymax vertex.) When moving from y to y + 1, the X-coordinate goes from x to x + 1/m. 1/m = (x2 x1)/(y2 y1) = x / y Store the integer part of x, the numerator (x) and the denominator (y) of the fraction separately. For next scan line, add x to numerator. If sum goes > y, increment integer portion, subtract y from numerator.
CS3500 Scan Conversion

Scan Converting Filled Polygons

Find intersections of each scan line with polygon edges. Sort them in increasing X-coordinates. Use parity to nd interior spans and ll them. Most information can be computed during scan conversion. A list of intersecting polygons stored for each scan line. Use edge coherence for the computation otherwise.
CS3500 Scan Conversion

Special Concerns
Fill only strictly interior pixels: Fractions rounded up when even parity, rounded down when odd. Intersections at integer pixels: Treat interval closed on left, open on right. Intersections at vertices: Count only ym vertex for parity. Horizontal edges: Do not count as ym!

CS3500

Scan Conversion

Filled Polygon Scan Conversion

Perform all of it together. Each scan line should not be intersected with each polygon edge! Edges are known when polygon vertices are mapped to screen coordinates. Build up an edge table while that is done. Scan conversion is performed in the order of scan lines. Edge coherence can be used; an active edge table can keep track of which edges matter for the current scan line.
CS3500 Scan Conversion

Edge Table for a Polygon

Construct a bucket-sorted table of edges, sorted into buckets of ym for the edge. Each bucket y contains a list of edges with y = ym, in the increasing order of x coordinate of the lower end point. Each edge is represented by its yM for the edge, x of the lower (that is ym) point, and the slope as a rational number. This is the basis for constructing the Active Edge Table to compute the spans.
CS3500 Scan Conversion

Polygon and Edge Table

35 30 25 20 15 10 5
5 10 15 20 25 30 35

25

30, 20, 15, 5 30, 5, 0, 10 32, 30, 5, 22 20, 15, 10, 15

32, 20, 15, 7

...
20 10 5

... ...
10, 15, 15, 5

CS3500

Scan Conversion

Active Edge Tables

Start with the lowest y value and an empty AET. Insert edges from bucket y of ET to AET. (They have y = ym and are sorted on x.) Remove edges from AET where y is the yM point. Between pairs of AET entries lie spans. Fill them. Compute next point on edge using coherence. (Increment y by 1 and numerator by x, etc. Or vice versa) Continue above 4 steps till ET and AET are empty.
CS3500 Scan Conversion

Active Edge Table: Snapshots

y = 15 y = 22 y = 27

AET

20, 9, 10, 15

32, 31, 5, 22

AET

30, 5, 0, 10

32, 32, 5, 22

AET

30, 5, 0, 10

30, 14, 15, 5

32, 24, 15, 7

32, 34, 5, 22

CS3500

Scan Conversion

Pattern Filling
A rectangular bit-map with the desired pattern can be used to ll the interior with a pattern. If pattern(i mod M, j mod N ), draw pixel, else ignore. i, j are row, col indices. Lower left corner at 0 and 0. M, N are the pattern height and width.

CS3500

Scan Conversion

Scan Conversion: Summary

Filling the frame buffer given 2D primitives. Convert an analytical description of the basic primitives into pixels on an integer grid in the frame buffer. Lines, Polygons, Circles, etc. primitives. Filled and unlled

Efcient algorithms required since scan conversion is done repeatedly. 2D Scan Conversion is all, even for 3D graphics.
CS3500 Scan Conversion

Scan Conversion: Summary

High level primitives (point, line, polygon) map to window coordinates using transformations. Creating the display image on the Frame Buffer is important. Needs to be done efciently. Clipping before lling FB to eliminate futile effort. After clipping, line remains line, polygons can become polygons of greater number of sides, etc. General polygon algorithm for clipping and scan conversion are necessary.
CS3500 Scan Conversion