Scribd
Upload
39 views

Fill Algorithms: Soon Tee Teoh CS 116B

The document describes three algorithms for filling polygons: scan-line fill, boundary fill, and flood fill. Scan-line fill colors pixels by scan lines, handling edge intersections. Boundary fill colors the interior starting from a seed pixel by recursively filling surrounding uncolored pixels. Flood fill replaces all pixels of a given color connected to a seed pixel.

Uploaded by

surbhisharma2210
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
39 views

Fill Algorithms: Soon Tee Teoh CS 116B

The document describes three algorithms for filling polygons: scan-line fill, boundary fill, and flood fill. Scan-line fill colors pixels by scan lines, handling edge intersections. Boundary fill colors the interior starting from a seed pixel by recursively filling surrounding uncolored pixels. Flood fill replaces all pixels of a given color connected to a seed pixel.

Uploaded by

surbhisharma2210
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 11

Fill Algorithms

Soon Tee Teoh CS 116B

Fill Algorithms
Given the edges defining a polygon, and a color for the polygon, we need to fill all the pixels inside the polygon. Three different algorithms:
1. Scan-line fill 2. Boundary fill 3. Flood fill

Scan Line Fill Algorithm


Basic algorithm:
Assume scan line start from the left and is outside the polygon. When intersect an edge of polygon, start to color each pixel (because now were inside the polygon), when intersect another edge, stop coloring Odd number of edges: inside Even number of edges: outside

Advantage of scan-line fill: It does fill in the same order as rendering, and so can be pipelined.

out in out in

Scan Line Fill: What happens at edge end-point?


Edge endpoint is duplicated. In other words, when a scan line intersects an edge endpoint, it intersects two edges. Two cases:
Case A: edges are monotonically increasing or decreasing Case B: edges reverse direction at endpoint

In Case A, we should consider this as only ONE edge intersection In Case B, we should consider this as TWO edge intersections

Scan-line

Scan-line

Case A

Case B

Speeding up Scan-Line Algorithm


1. Parallel algorithm: process each scan line in one processor. Each scan line is independent 2. From edge intersection with one scan line, derive edge intersection with next scan line (see next slide) 3. Active edge list (see later slides)

Method 2: Derive next intersection


Suppose that slope of the edge is
m = Dy/Dx

Let xk be the x intercept of the current scan line, and xk+1 be the x intercept of the next scan line, then
xk+1 = xk + Dx/Dy

Algorithm:
Suppose m = 7/3 Initially, set counter to 0, and increment to 3 (which is Dx). When move to next scan line, increment counter by increment When counter is equal or greater than 7 (which is Dy), increment the x-intercept (in other words, the x-intercept for this scan line is one more than the previous scan line), and decrement counter by 7.

Line with slope 7/3

yk xk

decrement

decrement

0 4 1 5 2 6 3 0 y0 x0

decrement

Active Edge List


Start with the sorted edge table.
In this table, there is an entry for each scan-line. Add only the non-horizontal edges into the table.
For each edge, we add it to the scan-line that it begins with (that is, the scan-line equal to its lowest y-value). For each edge entry, store (1) the x-intercept with the scan-line, (2) the largest y-value of the edge, and (3) the inverse of the slope.

Each scan-line entry thus contains a sorted list of edges. The edges are sorted left to right. (To maintain sorted order, just use insertion based on their x value.)

Next, we process the scan lines from bottom to top.


We maintain an active edge list for the current scan-line. The active edge list contains all the edges crossed by that scan line. As we move up, update the active edge list by the sorted edge table if necessary. Use iterative coherence calculations to obtain edge intersections quickly.

Boundary Fill
Suppose that the edges of the polygon has already been colored. Suppose that the interior of the polygon is to be colored a different color from the edge. Suppose we start with a pixel inside the polygon, then we color that pixel and all surrounding pixels until we meet a pixel that is already colored.
void boundaryFill(int x, int y, int fillColor, int borderColor) { int interiorColor; getPixel(x,y,interiorColor); if ((interiorColor!=borderColor)&&(interiorColor!=fillColor)) { setPixel(x,y,fillColor); boundaryFill(x+1,y,fillColor,borderColor); boundaryFill(x-1,y,fillColor,borderColor); boundaryFill(x,y+1,fillColor,borderColor); boundaryFill(x,y-1,fillColor,borderColor); } }

Flood Fill
Suppose we want to color the entire area whose original color is interiorColor, and replace it with fillColor. Then, we start with a point in this area, and then color all surrounding points until we see a pixel that is not interiorColor.
void floodFill(int x, int y, int fillColor, int interiorColor) { int color; getPixel(x,y,color) if (color==interiorColor) { setPixel(x,y,fillColor); floodFill(x+1,y,fillColor,interiorColor); floodFill(x-1,y,fillColor,interiorColor); floodFill(x,y+1,fillColor,interiorColor); floodFill(x,y-1,fillColor,interiorColor); } }

You might also like