Scan-line Polygon Filling in C

In this article, you will learn about the Scan-line polygon filling in C with its implementation.

Introduction of the Scan-Line polygon filling:

Scan-line polygon filling is a fundamental algorithm in computer graphics for rendering solid shapes on a screen. It works by systematically scanning the image line by line, identifying the intersections of the scan line with the polygon's edges, and then filling the pixels between these intersections with the desired colour.

Importance of the Scan-Line polygon filling:

The filling of polygons is a fundamental operation in computer graphics because it is crucial for rendering realistic images and providing visual representation of shapes. The Scan-Line Polygon Filling Algorithm plays a significant role in this process, enabling the rendering of solid-coloured or textured polygons with precision and efficiency.

Working of the Scan-Line Polygon Filling Algorithm in C

Determine Edges: Identify the edges of the polygon, represented as line segments. Each edge is defined by its endpoints.

Sort Edges: Sort the edges based on their y-coordinates to determine the order in which they intersect the scan lines.

Initialize Edge Table: Create an Edge Table to store information about each edge, including the slope, x-coordinate of the intersection with the current scan line, and other relevant attributes.

Initialize Active Edge Table (AET): Start with an empty Active Edge Table. As the algorithm progresses through scan lines, edges enter and exit the AET based on their intersections.

Scan Lines: Iterate through each scan line from the bottom to the top of the polygon. For each scan line, update the AET by adding new edges from the Edge Table and removing edges that have reached the end of their span.

Fill Pixels: For each pair of adjacent edges in the AET, fill the pixels between their x-coordinates on the current scan line with the specified color.

Update Edge Coordinates: It increments the x-coordinates of the edges in the AET based on their slopes.

Repeat: Continue this process until all scan lines have been processed and the entire interior of the polygon has been filled.

Advantages of the Scan-line Filling Algorithm:

There are several advantages of the Scan-Line Filling Algorithm. Some main advantages of the Scan-Line Filling Algorithm are as follows:

• Efficiency:

Processes only pixels along intersecting scan lines, reducing computational load. It is particularly efficient for large polygons with minimal redundant calculations.

• Versatility:

It is adaptable to complex polygons, concave shapes, and those with holes. It is a versatile application in a variety of computer graphics scenarios.

• Ease of Implementation:

It is a straightforward concept, making it accessible for programmers and designers. It does not require complex data structures, easing the implementation process.

• Accommodates Various Edge Cases:

It handles both horizontal and non-horizontal edges seamlessly. It is suitable for polygons with overlapping or coinciding edges.

• Supports Interior Attributes:

It facilitates filling interiors with solid colors or textures. It enables realistic representation in computer graphics.

Steps for implementation of Scan-Line Filling Algorithm using ubuntu operating system.

Step 1:

• Open the terminal, and then install the freeglut3 You can use the below command to install the freeglut3 library.

• Create a folder with some folder name. Here, we used javaTpoint as the folder name. You can use the below command to make a directory.

Step 2:

• Create a text file and name some file names to store the coordinates. After that, open the text file with the text editor, and then write the coordinates. You can use the below commands:

Step 3:

• Create a C file and name it to write the actual code to implement the scan-line filling algorithm. After that, open the c file with the editor and write the code. You can use the below commands. Here, we named the c file as c.

Example:

Let us take a C program to be written in the main.c file.

Commands for executing the above code:

Output:

Output:

Explanation:

This C++ program demonstrates the Scanline Polygon Fill Algorithm using OpenGL and GLUT. Let's break down the key components of the program:

Imports:

stdio.h, math.h, GL/glut.h: These are standard C and OpenGL libraries. The stdio.h is used for file operations, math.h for mathematical functions, and GL/glut.h for OpenGL Utility Toolkit functions.

Global Variables:

maxHt, maxWd, maxVer: These constants define the maximum height, width, and number of vertices in the program. They are used for setting up the OpenGL window and managing edge tables.

*FILE fp: This file pointer is used to read the coordinates of a polygon from a file named "sample.txt".

Structs (EdgeBucket, EdgeTableTuple): These define structures for an edge bucket and an edge table tuple. The edge bucket contains information about a polygon edge, and the edge table tuple manages a collection of edge buckets.

Functions:

initEdgeTable(): It initializes the global array EdgeTable by setting the count of edge buckets to 0.

printTuple(EdgeTableTuple tup): It prints the contents of an edge table tuple, including the maximum y-coordinate, x-coordinate of the lowest edge point, and slope inverse for each edge.

printTable(): It prints the entire edge table by iterating through all scanlines.

insertionSort(EdgeTableTuple): It sorts an array of edge buckets in increasing order of x-coordinates.

storeEdgeInTuple(...): It stores an edge in a given edge table tuple, sorting the buckets based on ymax and xofymin.

storeEdgeInTable(...): It computes the slope inverse and stores edges in the edge table.

removeEdgeByYmax(...): It removes edges from the active edge table for which y=ymax.

updatexbyslopeinv(...): It updates x-coordinates for each edge in the active edge table based on the slope inverse.

ScanlineFill(): It implements the scanline fill algorithm by filling lines on each scanline using pairs of x-coordinates from the active edge table.

myInit(): It initializes the OpenGL window with a white background and sets up the orthographic projection.

drawPolyDino(): It reads coordinates from the file "PolyDino.txt", draws lines, and stores edges in the edge table.

drawDino(): It initializes the edge table, calls drawPolyDino(), prints the edge table, and performs scanline filling.

main(...): The main function initializes the file pointer, OpenGL window, and display function. After that, it enters the GLUT main loop.

Control Flow:

• The program starts by opening the file "PolyDino.txt" to read polygon coordinates.
• The drawDino() function is the main driver of the program, initializing the edge table, drawing the polygon, printing the edge table, and performing scanline filling.
• The drawPolyDino() function reads coordinates, draws lines, and stores edges in the edge table.
• Scanline filling is achieved by processing each scanline, moving edges from the edge table to the active edge table, and filling lines on the current scanline.

Conclusion:

In conclusion, the C program implements the Scanline Polygon Fill Algorithm using OpenGL and GLUT. The algorithm efficiently fills the interior of a polygon by scanning lines and determining intersections with edges. This fundamental computer graphics algorithm demonstrates versatility, ease of implementation, and support for various edge cases. The program employs standard C libraries, OpenGL for graphics rendering, and GLUT for window management. The control flow follows a logical sequence of initializing, drawing, and performing scanline filling, showcasing the algorithm's effectiveness in rendering solid shapes on a screen.