Rasterization

by William Shoaff with lots of help

Contents

• Contents
• Rasterization
• The DDA Algorithm
  • Lines with shallow slope
  • Steep lines
• Bresenham's Algorithm
  • Code for Bresenham's Algorithm
  • Lines of arbitrary slope
  • Bresenham's Circle Algorithm
  • Code for Bresenham's circle algorithm
• Polygon Filling Algorithms
• A Scan Line Fill Algorithm
• Bibliography

Audio Clips

1.

Bresenham's Algorithms

2.

Scan Line Filling Polygons

Rasterization

Rasterization is the process of converting a vertex representation to a pixel representation; rasterization is also called scan conversion. Included in this definition are geometric objects such as circles where you are given a center and radius. In these notes I will cover:

• The digital differential analyzer (DDA) which introduces the basic concepts for rasterization.
• Bresenham's algorithm which improves on the DDA.
• The scan line fill for polygons.
• And, time permitting, flood and boundary fill algorithms.

Scan conversion algorithms use incremental methods that exploit coherence. An incremental method computes a new value quickly from an old value, rather than computing the new value from scratch, which can often be slow. Coherence in space or time is the term used to denote that nearby objects (e.g., pixels) have qualities similar to the current object.

The DDA Algorithm

Let $p_0=(x_0,\,y_0)$ and $p_1=(x_1,\,y_1)$ be two endpoints of a line segment. We will assume that these points are in device space so that the coordinates $x_0,\,y_0,\,x_1,\,y_1$ are integers. The point-intercept form of the equation of the line from p₀ to p₁ is

y=mx+b

where the slope is

$$m=\frac{y_1-y_0}{x_1-x_0}$$

and the y intercept is

b = y₁ - mx₁,

although it is not necessary to compute the y intercept.

Notice that if x is incremented to x+1, then y changes to y+m. Similarly, if y is incremented to y+1, then x changes to $x+\frac{1}{m}$. Of course, the slope (or its reciprocal) often won't be integers. Let's consider the two cases where these increments occur.

Lines with shallow slope

Pretend the slope is between minus one and one ( $-1\leq m \leq 1$) With little lost of generality, pretend x₀ <x₁ so the line is drawn from left to right. We know that if $(x,\,y)$ is on the line, then so is (x+1, y+m), and we simply iterate on this fact. The pseudo-code for the algorithm is given below.

The DDA code is presented in ../dda.html

Steep lines

In the second case the slope is less than minus one or greater than one (m < -1 or 1 < m). In this case we interchange roles of x and y. That is, starting from the lowest y value, increment y by 1 and increment x by 1/m.

Example 1:

Given end-points $p_0=(1,\,3)$ and $p_1=(8,\,9)$, find the pixels illuminated by the DDA algorithm.

In this case, the slope is m=6/7, which is a shallow line. Thus, x is incremented by 1 and y by m at each step. The first point is $(1,\,3)$. The next point on the line is $(2,\,27/7)$, which is rounded to the pixel value $(2,\,4)$. Continuing, the plotted pixels are:

Step	y	pixel
1	21/7	$(1,\,3)$
2	27/7	$(2,\,4)$
3	33/7	$(3,\,5)$
4	39/7	$(4,\,6)$
5	45/7	$(5,\,6)$
6	51/7	$(6,\,7)$
7	57/7	$(7,\,8)$
8	63/7	$(8,\,9)$

What pixels illuminated by the DDA algorithm given end-points $p=(1,\,3)$ and $q=(8,\,11)$?

Bresenham's Algorithm

The DDA algorithm requires floating point arithmetic and rounding inside the main loop. Bresenham's algorithm works solely with integers and integer arithmetic.

Let $p_0=(x_0,\,y_0)$ and $p_1=(x_1,\,y_1)$ be two endpoints of a line segment (in device coordinate, so $x_0,\,y_0,\,x_1,\,y_1$ are integers). The implicit equation of the line from p₀ to p₁ is

Ax+By+C=0

where

$$A=(y_1-y_0) = \triangle y,$$

$$B=-(x_1-x_0) = -\triangle x,$$

and

C= -(Ax₀ + By₀).

We'll pretend that

• x₀ < x₁ so the line is drawn from left to right and $B =-\triangle x = -(x_1-x_0) < 0$;
• the slope is between 0 and 1 ( $0 \leq m \leq 1$), so that $0 \leq A \leq -B$.

Since slope is between 0 and 1, and since x₀ < x₁, the only two valid moves are

$$\mbox{Right (R):}\: x \rightarrow x+1$$

or

$$\mbox{Diagonally up (D):}\: x \rightarrow x+1,\: y \rightarrow y+1.$$

Now define an error e = Ax+By+C which measures whether or not a point $(x,\,y)$ is on the line or not. Consider an R move, the error becomes

e_R = A(x+1) + By + C = e + A.

Consider a D move, the error becomes

e_D = A(x+1) + B(y+1) + C = e + A + B.

We want to move in whichever direction produces a smaller error.

If $\mid e_R\mid\,<\, \mid e_D\mid$ move to right; if $\mid e_D\mid\,\leq\, \mid e_R\mid$ move to diagonally up. The sign of the difference

$$\mid e_R\mid - \mid e_D\mid$$

can be used to judge which of these errors is smaller. Notice that the errors $e_R,\,e_D$ can be either non-negative (+) or negative (-). There are four possible combinations:

eR	eD	$\mid e_R \mid - \mid e_D \mid$	next pixel
+	+	-B > 0	D
+	-	er + eD = 2e+2A+B	don't know
-	+	can't happen
-	-	B < 0	R

Notice that in the $(+,\,+)$ case we have

$$\mid e_R \mid - \mid e_D \mid = e_r - e_D = (e+A) - (e+A+B) = -B,$$

and the $(-,\, -)$ case is similar. The $(-,\, +)$ can not happen since B is less than zero. That is, if e+A < 0 then e_D = e+A+B <0 also.

Bresenham uses the indeterminate $(+,\,-)$ case, where we don't know which direction to move, to define a biased error

g = e_R + e_D = 2e + 2A + B,

which can be use in all cases to determine the move that produces the smallest error.

If e_R and e_D are both non-negative, then so is g and the above chart shows that a diagonal move is best. If e_R and e_D are both negative, so is g and so we move to the right as the chart indicates. In the indeterminate case, if g is non-negative we move diagonally, while if g is negative, we move to the right.

Now once a move is made we must update the biased error. For a diagonal move:

g_D = g + 2A + 2B.

For a right move:

g_R = g + 2A.

Finally, we need an initial value for the biased error. But this is easy since g = 2e+2A +B and the first point in on the line so the error e is zero: The initial value of the biased error is

g=2A+B.

Code for Bresenham's Algorithm

We'll only develop the code for Bresenham's algorithm for the special case discuss above. Let $p_0=(x_0,\,y_0)$ and $p_1=(x_1,\,y_1)$ be line segment end-points, pretend the slope of line is between 0 and 1 and let x₀ < x₁.

The Bresenham line code is presented in ../bresenham.html

Example 2:

Given end-points $p_0=(1,\,3)$ and $p_1=(8,\,9)$, find the pixels illuminated by Bresenham's algorithm.

Here we have the change in y is A = 9 - 3 = 6 and minus the change in x is B = -(8 - 1) = -7. The initial biased error is g = 2A+B = 5. The biased error update for a diagonal move is diagonalInc = 2(A+B) = -2, and the biased error update for a right move is rightInc = 2A=12.

Step	old g	pixel	new g
1	5	$(1,\,3)$	3
2	3	$(2,\,4)$	1
3	1	$(3,\,5)$	-1
4	-1	$(4,\,6)$	11
5	11	$(5,\,6)$	9
6	9	$(6,\,7)$	7
7	7	$(7,\,8)$	5
8	5	$(8,\,9)$	3

Lines of arbitrary slope

The remaining question is how do we scan convert a line when the slope is not between 0 and 1 or the first x coordinate is not less than the second.

Bresenham's Circle Algorithm

Now let's consider how we can use the ideas developed above to rasterize a circle.

Let

x² + y² -r² = 0

be the equation of a circle centered at the origin with integer radius r. Starting at the top of the circle $(0,\,r)$, we want to determine which pixels to illuminate in the clockwise direction until we hit the line x=y. The remainder of the circle can be determined by symmetry, in particular if $(x,\,y)$ is on the circle, then so are

$$(x,\,-y),\,(-x,\,y),\,(-x,\,-y),\,(y,\,x),\,(y,\,-x),\,(-y,\,x),\quad\mbox{and}\quad (-y,\,-x).$$

At each step we choose to move either to the right (R): x=x+1, or diagonally down (D): $x=x+1,\,y=y-1$. Define the error to be

e = x² + y² - r².

If we move right, then the error will become

e_R = (x+1)² + y² - r² = e + (2x+1).

If we move diagonally down, then the error will become

e_D = (x+1)² + (y-1)² - r² = e + (2x+1) - (2y-1).

The errors $e_R,\,e_D$ can be either non-negative (+) or negative (-). There are four possibilities:

eR	eD	$\mid e_R \mid - \mid e_D \mid$	next pixel
+	+	2y-1 > 0	D
+	-	er + eD	don't know
-	+	can't happen
-	-	-(2y-1) < 0	R

The ``biased'' error g = e_R+e_D = 2e + (4x+2) - (2y-1) = 2e+4x-2y+3 is used in all cases. If e_R and e_D are both non-negative, then so is g and so we move diagonally down. If e_R and e_D are both negative, then so is g and so we move to the right. In indeterminate case, if g is non-negative, move diagonally down; if g is negative, move to the right.

We also need the initial value for g: It is g = 3 - 2r, since the initial point $(0,\,r)$ is on the circle.. And we need updates for the biased error for diagonal and right moves. Note that a diagonal and right moves results in changes to the biased error:

$$g_D = g + 4x - 4y + 10,\quad g_R = g + 4x + 6.$$

Code for Bresenham's circle algorithm

The Bresenham circle code is presented in ../brescircle.html Note that symmetricplot(x, y) calls plot with all 8 values $(\pm x,\,\pm y),\, (\pm y,\,\pm x)$.

Polygon Filling Algorithms

We want to develop scan conversion algorithms that generate all pixels in the interior of a polygon. There are two general classes of polygon filling algorithms:

• Fill algorithms that spread out from a seed
• Scan-line algorithms which fill a polygon one scan line at time

Flood fill and boundary fill algorithms are examples of the first class. Flood fill algorithm color all pixels (recursively) adjacent to the seed that are not equal to a given boundary color. Boundary fill algorithm color all pixels interior to a region's boundary. Fill algorithms are common in ``paint'' programs.

Scan line algorithms typically work only with polygons but fill algorithms work for more general objects Scan line algorithms can be used for hidden surface removal.

A Scan Line Fill Algorithm

Following convention, a raster will be defined as a two dimensional grid numbers from $(0,\,0)$ in the upper left corner to $(x_{\max}-1,\,y_{\max}-1)$ in the lower left corner. To be specific, let's use the HDTV resolution of $1080\times 1920$which has a 9 to 16 aspect ratio. Here's a small $10\times 10$ raster.

We want to fill a polygon defined by 3 or more vertices. We will make some assumptions (which are not quite right, but they get us started). First, we define scan-line order:

$$(x_1,\,y_1) \leq (x_2,\,y_2)\:\mbox{in scan-line order if}$$

y₁ < y₂

or

$$y_1 = y_2 \quad\mbox{and} \quad x_1 \leq x_2$$

1.

An infinite line intersects a closed bounded region R an even number of times (this is a little white lie)

2.

We can fill a polygon one scan line at a time, by filling between successive intersections of a scan line with polygon edges.

The basic algorithm is:

Given a polygon P, with edges $e_1,\,e_2,\,\ldots,\,e_n$

1.

Use DDA or Bresenham's algorithm to find each pixel on P's boundary

2.

Sort the pixels in scan-line order, storing them in a list L

3.

Pull off pairs of points $(x_1,\,y_1),\,(x_2,\,y_2)$ from L and color each pixel $(x,\,y)$ such that

$$x_1 \leq x \leq x_2$$

(Note it must be the case that y₁=y=y₂)

You've been lied to, scan-lines that hit polygon vertices intersect the region an odd number of times and horizontal edges have infinitely many intersections with a scan-line Corrections are:

• Don't process horizontal edges
• When a scan-line hits a vertex
  • record two intersection when the vertex is a local maxima or local minima
  • record one intersection when the vertex is between edges that continue increasing or decreasing

For a high resolution device there may be thousands of intersections, so even an $n\log n$ sort routine may take time Bucket sorting (a form of hashing) can save time

• For each scan-line, create a list (bucket) of pixels
• When an pixel $(x,\,y)$ is found to be on an edge, place it in the bucket corresponding to y
• For each scan-line only the pixels in its bucket need to be sorted

However, not all pixels need to be save, we can compute them on the fly. There are three quantities that need to be stored in a record place into a scan line list of buckets indexed by the y values of the scan lines (0 to $y_{\max}-1=1919$). The record looks like

$$\begin{array}{\vert c\vert c\vert c\vert}\hline \delta y & \delta x & x \\ \hline\end{array}$$

For each non-horizontal edge, let

$$(x_1,\,y_1) \leq (x_2,\,y_2)$$

denote end points. So that y₂-y₁+1 scan-lines are intersected by the edge, and let

$$\delta y = y_2 - y_1 + 1$$

be denote number of scan-lines that are active for this edge.

Starting at the top pixel of the edge $(x_1,\,y_1)$, when y is incremented by 1, x will change by

$$\delta x = 1/m$$

where m is the slope of the edge.

For each non-horizontal edge $(x_1,\,y_1)$ to $(x_2,\,y_2)$,

• if high point ( $(x_1,\,y_1)$) on edge is a local maximum, store
  
  $$\begin{array}{ll} \delta y = y_2-y_1+1, & \quad\mbox{(number... ...quad\mbox{(value at maximum $y=y_1$ for the edge)} \end{array}$$
  
  
  in the y-bucket of the maximum y=y₁ for the edge
• else, store
  
  $$\begin{array}{ll} \delta y-1, & \quad\mbox{(number of scan l... ... x+\delta x, & \quad\mbox{(value of $x$ at $y+1$)} \end{array}$$
  
  
  in the y-bucket at y+1 where y=y₁ is the high point for the edge.

Now, the algorithm to fill the polygon is:

1.

Starting from top scan-line, pull off all pairs of stored data from the highest (lowest value) scan line and place them in an active edge list.

2.

Plot all points on the scan-line between the x values.

3.

Update: $\delta y \rightarrow \delta y-1,\, x \rightarrow x + \delta x$.

4.

If $\delta y$ becomes zero, drop corresponding triple from active-edge list

5.

Increment scan line by 1, merge any data from the bucket list into active-edge list, sorted on x values

6.

Repeat steps 2 through 4 until all active edges have been processed.

Active-Edge List Example

Consider the polygon defined by vertices

$$P_0=(0,0),\, P_1=(8,1),\, P_2=(9,5),\, P_3=(5,7)$$

• Edge 1: $P_0=(0,0),\, P_1=(8,1)$
  
  $$\delta y = 1-0 + 1 = 2$$
  
  
  
  
  $$\delta x = 1/m = 8$$
  
  
  
  
  $$\mbox{store $\delta y = 2,,\,\delta x = 8,\, x=0$ in bucket $0$}$$
  
  

• Edge 2: $P_1=(8,\,1),\, P_2=(9,\,5)$
  
  $$\delta y = 5-1+1 = 5$$
  
  
  
  
  $$\delta x = 1/m = 1/4$$
  
  
  
  
  $$\mbox{store $\delta y-1 = 4,\,\delta x = 1/4,\,x+\delta x = 8.25$ in bucket $y=2$}$$
  
  

• Edge 3: $P_2=(9,\,5),\, P_3=(5,\,7)$
  
  $$\delta y = 7-5+1 = 3$$
  
  
  
  
  $$\delta x = 1/m = -2$$
  
  
  
  
  $$\mbox{store $\delta y-1 = 2,\,\delta x = -2,\,x+\delta x =7$ in bucket $y=6$}$$
  
  

• Edge 4: $P_3=(5,\,7),\, P_0=(0,\,0)$
  
  $$\delta y = 7-0 +1 = 8$$
  
  
  
  
  $$\delta x = 1/m = 5/7$$
  
  
  
  
  $$\mbox{store $\delta y =8,\,\delta x = 5/7,\,x= 0$ in bucket $0$}$$
  
  

The scan line bucket-list then looks like:

bucket	$\delta y,\,\delta x,\,x$	$\delta y,\,\delta x,\,x$
0	8, 5/7, 0	2, 8, 0
1
2	4, 1/4, 8.25
3
4
5
6	2, -2, 7
7
8
9

(Note the edge information for edge 4 was placed before the edge information for edge 1: why?

Now we pull off from the top the first non empty list from the scan line buckets.

Active-Edge List:

y=0

8, 5/7, 0

2, 8, 0

From this active edge list we plot: $(0,\,0)$.

• Update Active-Edge List

  y=1

  7, 5/7, 5/7

  1, 8, 8

  (Note no data from the scan line buckets to merge with the active edge list)
• Plot $(1,\,1),(2,\,1),\,(3,\,1),\,(4,\,1),\,(5,\,1),\,(6,\,1),\,(7,=,1),\,(8,\,1)$ (Note some leave right edges open, so the last pixel would not be lit)
• Update Active-Edge List

  y=2

  6, 5/7, 10/7

  0, 8, 16

  The second record indicates it is no longer an active edge ( $\delta y =0$) so it is dropped and the data from the scan line buckets (y=2 is merged with the active edge list)

  y=2

  6, 5/7, 10/7

  4, 1/4, 8.25

• Plot $(1,\,2),\,(2,\,2),\,(3,\,2),\,(4,\,2),\,(5,\,2),\,(6,\,2),\,(7,\,2),\,(8,\,2)$
• Update Active-Edge List

  y=3

  5, 5/7, 15/7

  3, 1/4, 8.5

• Plot $(2,\,3),\,(3,\,3),\,(4,\,3),\,(5,\,3),\,(6,\,3),\,(7,\,3),\,(8,\,3)$
• Update Active-Edge List

  y=4

  4, 5/7, 20/7

  2, 1/4, 8.75

• Plot $(3,\,4),\,(4,\,4),\,(5,\,4),\,(6,\,4),\,(7,\,4),\,(8,\,4),\,(9,\,4)$
• Update Active-Edge List

  y=5

  3, 5/7, 25/7

  1, 1/4, 9

• Plot $(4,\,5),\,(5,\,5),\,(6,\,5),\,(7,\,5),\,(8,\,5),\,(9,\,5)$
• Update Active-Edge List

  y=6

  2, 5/7, 30/7

  2, -2, 7

  (Note one record dropped out and another what merged from the scan line bucket list)
• Plot $(4,\,6),\,(5,\,6),\,(6,\,6),\,(7,\,6)$
• Update Active-Edge List

  y=7

  1, 5/7, 35/7

  1, -2, 5

• Plot $(5,\,7)$

One thing to note about this implementation is its dependence on floating point arithmetic and rounding. It is possible to separate the denominator and numerator information in $\delta x$ and implement an integer only algorithm that is similar to Bresenham's line algorithm.

A Scan line fill program

A Java applet that executes a version of scan line fill is available for you to test. http://www.cs.fit.edu/wds/java/html/RasterDriver.html

Including Shading/Rendering Information

We can extend the data in the record store for each vertex to implement Gouraud (or Phong) shading as the polygon is filled. For Gouraud shading, this would be done by keeping the red, green, blue (RGB) intensity at each vertex and the change in these values as the edge is traced out. For simplicity, we'll illustrate this with gray scale using only an intensity I at each vertex.

Pretend we are given polygon vertices, as before, with intensity data:

P_0=(0,0), I_0 = 2, P_1=(8,1), I_1 = 10, P_2=(9,5), I_2 = 5, P_3=(5,7), I_3 = 8

Consider edge 1 from P₀ to P₁. We need to know that the intensity changes by

$$\delta I = \frac{I_1-I_0}{y_2-y_1} = \frac{8}{1}=8$$

as we step from one scan line to the next.

• Edge 1: $P_0=(0,0),\, I_0=2,\,P_1=(8,1),\,I_1=10$
  
  $$\delta y = 1-0 + 1 = 2$$
  
  
  
  
  $$\delta x = 1/m = 8$$
  
  
  
  
  x = 0
  
  
  
  
  $$\delta I = 8$$
  
  
  
  
  I = 2
  
  
  
  
  $$\mbox{store $\delta y = 2,,\,\delta x = 8,\, x=0,\,\delta I=8,\,I=2$ in bucket $0$}$$
  
  

• Edge 2: $P_1=(8,\,1),\,I_1=10,\, P_2=(9,\,5),\,I_2=5$
  
  $$\delta y = 5-1+1 = 5$$
  
  
  
  
  $$\delta x = 1/m = 1/4$$
  
  
  
  
  $$\delta I = (I_1-I_2)/(y_1-y_2) = -5/4$$
  
  
  
  
  I = 10
  
  
  
  
  $$\mbox{store $\delta y-1 = 4,\,\delta x = 1/4,\,x+\delta x = 8.25,\,\delta I=-5/4,\, I+\delta I = 8.75$ in bucket $y=2$}$$
  
  

• Edge 3: $P_2=(9,\,5),\,I_2=5 P_3=(5,\,7),\,I_3=8$
  
  $$\delta y = 7-5+1 = 3$$
  
  
  
  
  $$\delta x = 1/m = -2$$
  
  
  
  
  $$\delta I = (I_3-I_2)/(y_3-y_2) = 3/2$$
  
  
  
  
  I = 5
  
  
  
  
  $$\mbox{store $\delta y-1 = 2,\,\delta x = -2,\,x+\delta x =7,\,\delta I=3/2,\, I+\delta I = 6.5$ in bucket $y=6$}$$
  
  

• Edge 4: $P_3=(5,\,7),\,I_3=8 P_0=(0,\,0),\,I_0=2$
  
  $$\delta y = 7-0 +1 = 8$$
  
  
  
  
  $$\delta x = 1/m = 5/7$$
  
  
  
  
  $$\delta I = (I_0-I_3)/(y_0-y_3) = 6/7$$
  
  
  
  
  I = 2
  
  
  
  
  $$\mbox{store $\delta y =8,\,\delta x = 5/7,\,x= 0,\,\delta I = 6/7,\,I=2$ in bucket $0$}$$
  
  

The scan line bucket-list then looks like:

bucket	$\delta y,\,\delta x,\, x,\,\delta I,\, I$	$\delta y,\,\delta x,\, x,\,\delta I,\, I$
0	8, 5/7, 0, 6/7, 2	2, 8, 0, 8, 2
1
2	4, 1/4, 8.25,-5/4,8.75
3
4
5
6	2, -2, 7,3/2,6.5
7
8
9

Now we pull off from the top the first non empty list from the scan line buckets.

Active-Edge List:

y=0

8, 5/7, 0 , 6/7, 2

2, 8, 0,8,2

From this active edge list we plot: $(0,\,0)$ with intensity 2.

Update Active-Edge List:

y=1

7, 5/7, 5/7,6/7,20/7

1, 8, 8,8,10

and plot the pixels $(1,\,1)$ to (8,1), but with what intensities?

You must have observed that we now want to interpolate (via constant increments) from intensity I=20/7 to intensity I=10 as we step across the scan line. So let's define a double difference (that corresponds to what's called bilinear interpolation)

$$\delta \delta I = \frac{\delta I_1 - \delta I_0}{x_1-x_0} = \frac{10 -20/7}{8-1} = 50/49$$

Plot the 8 pixels $(1,\,1)$ to $(8,\,1)$ with intensities:

20/7, 190/49, 240/49, 290/49, 340/49, 390/49, 440/49, 490/49=10

When the active edge list is updated, one record (for edge 1) drops out and an new record (for edge 2) is merged in:

y=2

6, 5/7, 10/7,6/7,26/7

4, 1/4, 8.25,-5/4,8.75

Now the ``double difference''

$$\delta \delta I = \frac{35/4 - 26/7}{8-1}$$

And this value is added to the intensity starting at 26/7 until the right edge of the polygon is met at pixel (8,2).

Note in practice the intensity values would be truncated or rounded to integers.

A Boundary Fill Algorithm

Now to change directions, we present fill algorithms that you might find in a ``paint'' program.

• Given a seed point $(x_s,\,y_s)$ known to be in the region we want to fill
• Push the seed onto a stack
• While the stack is not empty
  • Pop a point from the stack
  • Color the point
  • For each neighbor of the point, not already colored and not on the region boundary, push the neighbor on the stack
• We need to be able to read the frame buffer to see if the pixel is colored
• We need to be able to test whether a point is inside/outside or on the boundary

• Two common topologies for neighbors
  • 4-neighbor topology (North, South, East, West)
  • 8-neighbor topology (N, NE, E, SE, S, SW, W, NW)
• Advantages
  • Easy to code (could put it in hardware)
  • Works for any shape we can test for ``being inside''
• Disadvantages
  • Stack overflow

Assume a seed point inside the region to be filled and empty stack

Pseudo-code for Flood Fill Algorithm

Assume a seed point inside the region to be filled and an algorithm that uses a 4-point topology

Pseudo-code for Flood Fill Algorithm

Filling Using Coherence

• Need to avoid stack overflow
• Need to improve performance
• A span or run of pixels is a horizontally adjacent group of pixels on a scan line
• Given a seed, fill the span it is on
• Fill any span above current span that is reachable
• Fill any span below current span that is reachable

No References!