Flood Fill
The Flood Fill algorithm is used primarily in computer graphics to determine and change the colour
of an area bounded by a particular colour. It is used in tools like the paint bucket in digital drawing
programs, but it can also be applied in game development or graph traversal.
There are several ways to implement the flood fill algorithm, but the most common ones are:
Depth-First Search (DFS)
Breadth-First Search (BFS)
Flood fill is very similar to these graph traversal methods because it essentially "explores" a grid of
pixels (or cells in a matrix).
Key Concepts
1. Grid/Matrix Representation: A 2D array (matrix) is used to represent the pixels or regions.
2. Base Condition: The algorithm stops when it encounters a boundary or a pixel that does not
match the original target colour.
3. Recursive or Iterative: Can be implemented either recursively (DFS) or iteratively (BFS).
Steps for Flood Fill:
1. Start at a pixel (node) and check if it has the target colour.
2. If yes, change it to the new colour.
3. Move to the neighbouring pixels (up, down, left, right) and repeat the process.
4. Continue until all the connected pixels with the target colour are changed.
Disadvantage:
Very slow algorithm
May be fail for large polygons
Initial pixel required more knowledge about surrounding pixels.
Example:
#include <graphics.h>
#include <conio.h>
#include <dos.h>
// Flood Fill function using recursion
void floodFill(int x, int y, int fill_color, int boundary_color) {
// Get the color of the current pixel
int current_color = getpixel(x, y);
// Check if the current pixel is not the boundary and not already filled
if (current_color != boundary_color && current_color != fill_color) {
// Set the pixel to the fill color
putpixel(x, y, fill_color);
// Recursively call floodFill for neighboring pixels (up, down, left, right)
floodFill(x + 1, y, fill_color, boundary_color); // Right
floodFill(x - 1, y, fill_color, boundary_color); // Left
floodFill(x, y + 1, fill_color, boundary_color); // Down
floodFill(x, y - 1, fill_color, boundary_color); // Up
int main() {
// Initialize graphics mode
int gd = DETECT, gm;
initgraph(&gd, &gm, "C:\\Turboc3\\BGI");
// Set the boundary color and fill color
int boundary_color = WHITE;
int fill_color = YELLOW;
// Draw a rectangle to fill (boundary of rectangle is WHITE)
rectangle(100, 100, 200, 200);
// Fill the inside of the rectangle using flood fill
floodFill(150, 150, fill_color, boundary_color);
// Hold the screen to see the output
getch();
// Close the graphics mode
closegraph();
return 0;
}
Boundary Filling
Boundary Fill Algorithm starts at a pixel inside the polygon to be filled and paints the interior
proceeding outwards towards the boundary. This algorithm works only if the colour with which the
region has to be filled and the colour of the boundary of the region are different. If the boundary is
of one single colour, this approach proceeds outwards pixel by pixel until it hits the boundary of the
region.
Boundary Fill Algorithm is recursive in nature. It takes an interior point (x, y), a fill colour, and a
boundary colour as the input. The algorithm starts by checking the colour of (x, y). If it’s colour is not
equal to the fill colour and the boundary colour, then it is painted with the fill colour and the
function is called for all the neighbours of (x, y). If a point is found to be of fill colour or of boundary
colour, the function does not call its neighbours and returns. This process continues until all points
up to the boundary colour for the region have been tested.
The boundary fill algorithm can be implemented by 4-connected pixels or 8-connected pixels.
4-connected pixels: After painting a pixel, the function is called for four neighbouring points. These
are the pixel positions that are right, left, above, and below the current pixel. Areas filled by this
method are called 4-connected.
Four connected approaches is more suitable than the eight connected approaches.
1. Four connected approaches: In this approach, left, right, above, below pixels are tested.
2. Eight connected approaches: In this approach, left, right, above, below and four diagonals are
selected.
Boundary can be checked by seeing pixels from left and right first. Then pixels are checked by seeing
pixels from top to bottom. The algorithm takes time and memory because some recursive calls are
needed.
Algorithm Steps:
1. Start from a given point (usually inside the boundary).
2. If the current pixel is neither the boundary color nor the fill color, change it
to the fill color.
3. Recursively apply the fill to the neighboring pixels (up, down, left, right,
and optionally diagonals).
4. The algorithm continues until all reachable pixels inside the boundary are
filled.
Example Program:
#include <graphics.h>
#include <conio.h>
// Boundary Fill Algorithm using recursion
void boundaryFill(int x, int y, int fill_color, int boundary_color) {
// Get the current color of the pixel
int current_color = getpixel(x, y);
// If the pixel is not the boundary color and not already filled
if (current_color != boundary_color && current_color != fill_color) {
// Set the pixel to the fill color
putpixel(x, y, fill_color);
// Recursively fill the neighboring pixels (up, down, left, right)
boundaryFill(x + 1, y, fill_color, boundary_color); // Right
boundaryFill(x - 1, y, fill_color, boundary_color); // Left
boundaryFill(x, y + 1, fill_color, boundary_color); // Down
boundaryFill(x, y - 1, fill_color, boundary_color); // Up
int main() {
// Initialize the graphics mode
int gd = DETECT, gm;
initgraph(&gd, &gm, "C:\\Turboc3\\BGI");
// Set the boundary color and fill color
int boundary_color = WHITE;
int fill_color = RED;
// Draw a closed boundary shape (e.g., a rectangle)
rectangle(100, 100, 300, 300); // Rectangle with top-left (100, 100) and bottom-right (300, 300)
// Set the boundary color for the rectangle
setcolor(WHITE);
// Call the boundary fill function, starting from a point inside the rectangle
boundaryFill(150, 150, fill_color, boundary_color);
// Hold the screen to display the output
getch();
// Close the graphics mode
closegraph();
return 0;
