CG Lab File

School of Computer Science
UNIVERSITY OF PETROLEUM AND ENERGY

STUDIES
DEHRADUN, UTTARAKHAND
Computer Graphics Lab

B.Tech CSE AIML B2 (Non
Honours)
Lab File
Submitted to: Submitted by:

Dr. Tarandeep Kaur Bhatia Divyansh
Singh
500091538
CG LAB EXP-1
Introduction to OpenGL
OpenGL:
OpenGL (Open Graphics Library) is an open-source, cross-platform API (application

programming interface) used for rendering 2D and 3D graphics. It has been widely used as a
standard for graphics programming since it was first introduced by Silicon Graphics Inc. in
1992.
OpenGL provides many functions for creating and manipulating graphics. For drawing
primitive shapes (points, lines, triangles), textures, and lighting. It's used in a variety of
applications, including video games, scientific simulations, virtual and augmented reality,
and computer-aided design. One of OpenGL's strengths is its portability. It is available for
various platforms such as Windows, macOS, Linux, Android and iOS. It is also compatible
with various programming languages such as C, C++, Java and Python.
OpenGL has been updated several times over the years, with the latest version being OpenGL
4.6 released in 2017.
GLU & GLUT:

GLU (OpenGL Utility Library) is a set of utility functions built on top of OpenGL, providing
additional functionality to simplify common tasks associated with graphics rendering. GLU
was originally developed by Silicon Graphics Inc., the same company that developed
OpenGL, but is now part of the OpenGL standard.
GLU provides functions for performing common operations such as transforming

coordinates, generating 2D and 3D primitives, tessellating curves and surfaces, and handling
texture mapping. Some of the more commonly used GLU functions include gluPerspective()
for setting a perspective projection, gluLookAt() for positioning the camera, and
gluQuadric() for generating geometric primitives such as spheres and cylinders. And so on.
Although GLU has been largely superseded by other libraries and APIs in modern graphics
programming, it is still sometimes used in applications that require compatibility with legacy
code and older systems.
GLUT (OpenGL Utility Toolkit) is an open source, cross-platform library that provides a set
of tools and functions for creating and managing windows and user interfaces in OpenGL
applications. It was originally developed by Mark Kilgard in 1993 to make writing OpenGL
programs easier.
GLUT simplifies the task of creating graphical user interfaces in OpenGL applications by
providing numerous functions for managing windows, keyboard and mouse input, and
timing. It also provides a simple API for drawing geometric primitives, text, and images on
the screen.
Commonly used to create simple graphic demos, educational software, and small games,
GLUT remains popular for quick prototyping and experimenting with new ideas. However, it
has limited functionality, and developers of more complex applications often use other
libraries and frameworks such as GLFW, SDL, and Qt.
OpenGL Architecture:
OpenGL is designed as a layered architecture that provides a modular structure for

implementing graphics rendering pipelines. The architecture consists of several layers, each
with its own functions and responsibilities.
Application layer:
At this level, graphics application code is written. Connect to the OpenGL API to specify
the desired rendering operations, such as: For example, camera settings, object creation,
lighting and shading definitions, etc.
OpenGL API layer:

This layer provides an interface between the application layer and the OpenGL
implementation. Defines a set of functions that an application can call to specify rendering
operations such as: These include drawing primitives, specifying texture mappings, and
controlling the graphics pipeline. OpenGL library layer:
This layer is the core of the OpenGL implementation. Provides the software and hardware
interfaces required to perform application-specified playback operations. Library layers are
responsible for managing the graphics pipeline, including vertex and fragment processing,
rasterization, and blending.
Device driver layer:

This layer provides the interface between the OpenGL library layer and the graphics
hardware. It translates OpenGL commands into hardware-specific instructions that can be
executed on a graphics processing unit (GPU). Graphics hardware layer:
This layer is the physical hardware that performs rendering operations. It contains the GPU,
memory, and other hardware components required for graphics processing.
OpenGL's layered architecture provides a clean separation of concerns between the various
components of the graphics rendering pipeline. This makes it easier for developers to
understand and optimise their code, and easier for hardware vendors to implement OpenGL
on devices.
Setting up the Environment:
1. Install Codeblock.
2. Go to https://www.transmissionzero.co.uk/software/freeglut-devel/
3. Click on Download freeglut 3.0.0 for MinGW (with PGP signature and PGP key)
4. Extract the contents of the extracted file (freeglut-MinGW-3.0.0-1.mp).
5. Go to Downloadfreeglut-MinGW-3.0.0-1.mp folder freeglut folder bin

Folder
a. Copy the freeglut.dll file, if your PC is of 32 bit.
b. If your PC is of 64 bit, go to folder and copy the freeglut.dll file.
6. Navigate to “C:\Windows” directory and paste your copied freeglut.dll file. You
have to provide administrator permission.
7. Now we have to set up the compiler. Go to Downloadfreeglut-MinGW-3.0.0-

1.mp folder freeglut folder include GL folder. Copy all the four files (having .h
extension)
8. Navigate to the directory where codeblock compiler is installed, i.e., C:\Program
Files\CodeBlocks\MinGW
a. Open the include folder and check whether the “GL” folder exists or not. If
yes, then paste the files copied from Downloadfreeglut-MinGW-3.0.0-1.mp
folder freeglut include GL to the path C:\ProgramFiles\CodeBlocks\MinGW.
b. If no, then check for the GL folder in x86_64-w64-mingw32\include folder.
Paste the copied files from Downloadfreeglut-MinGW-3.0.0-1.mp folder
freeglut include GL to the path C:\ProgramFiles\CodeBlocks\MinGW\x86_64-
w64-mingw32\include\GL.
9. Allow the contents to be merged with the folder for all the items.
10. Now we have to set up the compiler. Go to Downloadfreeglut-MinGW-3.0.0-

1.mp folder freeglut lib ×64 folder. Copy all the two files (having .a extension)
11. Navigate to the directory where codeblock compiler is installed, i.e., C:\Program
Files\CodeBlocks\MinGW
a. Open the lib folder and paste the copied files from Downloadfreeglut-
MinGW-3.0.0-1.mp folder freeglut lib ×64 to the path C:\Program Files\
CodeBlocks\MinGW\lib. (If you have followed the step 9(b), avoid
doing this step, rather do step 11(b))
b. If not, then check for the lib folder in x86_64-w64-mingw32 folder. Paste
the copied files from Downloadfreeglut-MinGW-3.0.0-1.mp folder freeglut
lib to the path C:\Program Files\CodeBlocks\MinGW\x86_64-w64-
mingw32\lib.
12. Allow the contents to be merged with the folder for all the items.
13. Go to C:\Program Files\CodeBlocks\share\CodeBlocks\templates\wizard\
glut directory and open wizard.script file in notepad.
14. Search for the term “glut32” in the wizard.script file and replace all the occurrence in
with “freeglut”. Save the file.
15. Go to C:\Program Files\CodeBlocks\share\CodeBlocks\templates directory and

open glut.cbp file in notepad for editing.
16. Search for the term “glut32” in the glut.cbp file and replace all the occurrence in
it with “freeglut”. Save the file.
17. Now create a new GLUT project in codeblocks. Type a title of the project and
enter the GLUT’s location as installation directory of the GLUT compiler (the
directory used in step 8, i.e., C:\Program Files\CodeBlocks\MinGW\x86_64-w64-
mingw32). Click Next and then Finish.
First OpenGL Program:

Code:
#include<GL/freeglut.h>
void init(){
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); //Line C
glutInitWindowSize(640,480);
glutInitWindowPosition(1000,200);
glutCreateWindow("Simple Window");
}
void display()
{
glClearColor(0,0,1.0,1.0);
glClear(GL_COLOR_BUFFER_BIT);
glFlush();
}
int main(int argc,char **argv)

{
glutInit(&argc,argv); //Line A
init(); //Line B
glutDisplayFunc(display);
glutMainLoop();
return 0;
}
Output:
Difference between C & OpenGL
Differences between C and OpenGL:
Purpose:
C is a general-purpose programming language used for developing a wide range of software
applications, while OpenGL is a graphics rendering API used for creating 2D and 3D
graphics.
Syntax:
C has its own syntax, control structures, and libraries that enable developers to create
software applications, while OpenGL provides a set of functions and interfaces for graphics
rendering.
Abstraction level:
C is a low-level programming language that provides direct access to hardware and memory,
while OpenGL provides a higher level of abstraction by hiding the details of the graphics
hardware and providing a set of functions and interfaces that can be used to create graphics.
Implementation:
C can be implemented on a variety of platforms and hardware architectures, while
OpenGL requires an implementation that supports the specific hardware and operating
system being used.
Scope:
C can be used to develop a wide range of software applications, including systems
programming, operating systems, compilers, and more, while OpenGL is specifically
designed for graphics rendering.
Data type:
C provides a variety of data types for representing variables and values, while
OpenGL provides data types specific to graphics rendering, such as vertex buffers,
textures, and shaders.
Library:
C provides a wide range of libraries for performing various tasks, while OpenGL itself is a
library that provides a set of functions and interfaces for rendering graphics.
Compatibility:
C code can be compiled to run on a wide variety of platforms and hardware architectures,
while OpenGL code depends on the hardware and operating system used and will need to
be modified to be compatible with a variety of platforms. There are cases.
CG LAB EXP-2
DDA Line DrawingAlgorithm

1. Calculate the slope of the line using the
formula: slope = (y2 - y1) / (x2 - x1)
2. Determine the number of steps required to draw the line. This can be done by
taking the maximum difference between the x-coordinates and the y-coordinates,
and then rounding up to the nearest integer:
steps = max(abs(x2 - x1), abs(y2 - y1))
3. Calculate the increment in x and y coordinates for each step using the
formula: dx = (x2 - x1) / steps
dy = (y2 - y1) / steps
4. Initialise the starting point of the line to (x1, y1) and increment the x and
y coordinates by dx and dy respectively for each step.
5. Round off the x and y coordinates to the nearest integer to get the pixel
coordinates for each step.
6. Plot the pixels along the line using the calculated pixel coordinates.
DDA Code
#include <stdio.h>
#include <GL/glut.h>
#include <math.h>
void display() {
float x1 = -0.7f, y1 = -0.7f;
float x2 = 0.7f, y2 = 0.7f;
float dx = x2 - x1;
float dy = y2 - y1;
float steps = abs(dx) > abs(dy) ? abs(dx) :
abs(dy); float x_inc = dx / steps;
float y_inc = dy /
steps; float x = x1, y =
y1;
glBegin(GL_LINES);
for (int i = 0; i <= steps; i++)

{ glVertex2f(x, y);
x +=
x_inc; y
+= y_inc;
}
glEnd();
glFlush();
}
int main(int argc, char** argv) {

glutInit(&argc, argv);
glutCreateWindow("DDA Line Drawing
Algorithm"); glutDisplayFunc(display);
glutMainLoop();
return 0;
}
Output:
Bresenham Line Drawing Algorithm
1. Determine the endpoints of the line segment to be drawn: (x1, y1) and (x2, y2).
2. Calculate the differences between the endpoints in the x and y directions: dx = abs(x2
- x1) and dy = abs(y2 - y1).
3. Determine the sign of the differences: sx = sign(x2 - x1) and sy = sign(y2 - y1). The
sign function returns -1 if the value is negative, 0 if the value is zero, and 1 if the
value is positive.
4. Initialise the error term to zero: error = 0.
5. Loop from x1 to x2, and for each x value, calculate the corresponding y value
using the error term:
Calculate the pixel coordinates: plot(x, y).
If the error term is greater than or equal to dx, increment y by sy and subtract dx
from the error term. Otherwise, leave y unchanged and
add dy to the error term.
Increment x by sx.
6. Repeat step 5 for each value of x until x equals x2.
Bresenham Code
#include <gl/glut.h>
#include <stdio.h>
int x1, y1, x2, y2;
void myInit() {
glClearColor(0.0, 0.0, 0.0, 1.0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(0, 500, 0, 500);
}
void draw_pixel(int x, int y) {
glBegin(GL_POINTS);
glVertex2i(x, y);
glEnd();
}
void draw_line(int x1, int x2, int y1, int y2)

{ int dx, dy, i, e;
int incx, incy, inc1,
inc2; int x,y;
dx = x2-x1;
dy = y2-y1;
if (dx < 0) dx = -dx;

if (dy < 0) dy = -dy;
incx = 1;
if (x2 < x1) incx = -1;
incy = 1;
if (y2 < y1) incy = -1;
x = x1; y = y1;
if (dx > dy) {
draw_pixel(x, y);
e = 2 * dy-dx;
inc1 = 2*(dy-dx);
inc2 = 2*dy;
for (i=0; i<dx; i++) {
if (e >= 0) {
y +=
incy; e +=
inc1;
}
else
e += inc2;
x += incx;
draw_pixel(x, y);
}
} else
{
draw_pixel(x, y);
e = 2*dx-dy;
inc1 = 2*(dx-dy);
inc2 = 2*dx;
for (i=0; i<dy; i++) {
if (e >= 0) {
x += incx;
e += inc1;
}
else
e += inc2;
y += incy;
draw_pixel(x, y);
}
}
}
void myDisplay() {
draw_line(x1, x2, y1,
y2); glFlush();
}
void main(int argc, char **argv) {
printf( "Enter (x1, y1, x2, y2)\n");

scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE|

GLUT_RGB); glutInitWindowSize(500, 500);
glutInitWindowPosition(0, 0);
glutCreateWindow("Bresenham's Line
Drawing"); myInit();
glutDisplayFunc(myDisplay);
glutMainLoop();
}
Output
CG LAB EXP-3
a) W.A.P to draw a simple circle.
Code:
#include <cmath>
using namespace std;
const int WINDOW_WIDTH = 640;

const int WINDOW_HEIGHT = 480;
float PI=3.14159;
void init() {
glClearColor(0.0, 0.0, 0.0, 0.0);
gluOrtho2D(0.0, WINDOW_WIDTH, 0.0, WINDOW_HEIGHT);
}
void Circle(float x, float y, float radius)

{ int i;
int lineAmount = 100; //# of triangles used to draw circle
//GLfloat radius = 0.8f;

//radius GLfloat twicePi = 2.0f
* PI;
glBegin(GL_LINE_LOOP);
for(i = 0; i <= lineAmount;i++)
{ glVertex2f(
x + (radius * cos(i * twicePi /
lineAmount)), y + (radius* sin(i * twicePi /
lineAmount))
);
}
glEnd();
}
void display() {
glColor3f(1.0, 1.0, 1.0); // set color to white

Circle(WINDOW_WIDTH/2.0, WINDOW_HEIGHT/2.0, 100.0); // draw circle at
center of window
glFlush();
}
int main(int argc, char **argv) {

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT);
glutCreateWindow("Simple Circle");
init();
glutMainLoop();
return 0;
}
Output:
b)W.A.P to draw a circle using Bresenham circle
drawing algorithm.
Algorithm:
1. Start
2. Declare x, y, r, x c, y c and d as variables, where (x c, y c) are coordinates of

the center.
3. Set x = 0, y = r and d = 3 - 2r
4. Plot point (x + x c, y + y c)
5. If x < y then set d = d + 4x + 6 and x = x + 1
6. Else set d = d + 4(y - x) + 10, x = x + 1 and y = y - 1
7. Go to step 4 until x > y
Code:
#include <cmath>

void init() {
glClearColor(0.0, 0.0, 0.0, 0.0);
}
void plotCirclePoints(int centerX, int centerY, int x, int y) {

glBegin(GL_POINTS);
glVertex2i(centerX + x, centerY +
y); glVertex2i(centerX + x, centerY -
y);
glVertex2i(centerX - x, centerY + y);
glVertex2i(centerX - x, centerY - y);
glVertex2i(centerX + y, centerY +
x); glVertex2i(centerX + y, centerY -
x); glVertex2i(centerX - y, centerY +
x); glVertex2i(centerX - y, centerY -
x); glEnd();
}
void drawCircle(int centerX, int centerY, int radius)

{ int x = 0, y = radius;
int d = 3 - 2 * radius;
while (x <= y) {
plotCirclePoints(centerX, centerY, x,
y); if (d < 0) {
d += 4 * x + 6;
}
else {
d += 4 * (x - y) +
10; y--;
} x+
+;
}
}
void display() {

drawCircle(WINDOW_WIDTH/2, WINDOW_HEIGHT/2, 100); // draw circle at
center of window
glFlush();
}

glutCreateWindow("Bresenham Circle");
init();
glutMainLoop();
return 0;
}
Output:
c) W.A.P to draw a circle using the Midpoint circle
drawing algorithm.
Algorithm:
1. Start
2. Declare x, y, r as variables, where (x, y) are coordinates of the center and r is

the radius of the circle.
3. Set x = 0, y = r and p = 1 - r
4. Plot point (x + x c, y + y c)
5. If p < 0 then set p = p + 2x + 3 and x = x + 1
6. Else set p = p + 2(x - y) + 5, x = x + 1 and y = y - 1
7. Go to step 4 until x > y
Code:
#include <cmath>

void init() {
glClearColor(0.0, 0.0, 0.0, 0.0);
}
void plotCirclePoints(int centerX, int centerY, int x, int y) {

glBegin(GL_POINTS);
y); glVertex2i(centerX - x, centerY +
y);
glVertex2i(centerX - x, centerY - y);
glVertex2i(centerX + y, centerY +
x); glVertex2i(centerX + y, centerY -
x); glVertex2i(centerX - y, centerY +
x); glVertex2i(centerX - y, centerY -
x); glEnd();
}
void drawCircle(int centerX, int centerY, int radius)

{ int x = 0, y = radius;
int d = 1 - radius;
while (x <= y) {
plotCirclePoints(centerX, centerY, x,
y); if (d < 0) {
d += 2 * x + 3;
}
else {
d += 2 * (x - y) + 5;
y--;
} x+
+;
}
}
void display() {

drawCircle(WINDOW_WIDTH/2, WINDOW_HEIGHT/2, 100); // draw circle at
center of window
glFlush();
}

glutCreateWindow("Midpoint Circle");
init();
glutMainLoop();
return 0;
}
Output:
CG LAB EXP-4
W.A.P to draw a simple ellipse.
Code:
#include <cmath>

void init() {
glClearColor(0.0, 0.0, 0.0, 0.0);
}
void plotEllipsePoints(int centerX, int centerY, int x, int y) {

glBegin(GL_POINTS);
y); glVertex2i(centerX - x, centerY +
y); glVertex2i(centerX - x, centerY -
y); glEnd();
}
void drawEllipse(int centerX, int centerY, int rx, int ry)

{ int x = 0, y = ry;
int rxSquare = rx *
rx; int rySquare = ry
* ry;
int twoRxSquare = 2 *
rxSquare; int twoRySquare = 2
* rySquare; int p;
int px = 0;
int py = twoRxSquare * y;
plotEllipsePoints(centerX, centerY, x,
y);
p = std::round(rySquare - rxSquare * ry + 0.25 *
rxSquare); while (px < py) {
x++;
px +=
twoRySquare; if (p
< 0) {
p += rySquare + px;
}
else {
y--;
py -= twoRxSquare;
p += rySquare + px - py;
}
plotEllipsePoints(centerX, centerY, x, y);
}
p = std::round(rySquare * (x + 0.5) * (x + 0.5) + rxSquare * (y - 1) * (y - 1) - rxSquare *

rySquare);
while (y > 0)
{ y--;
py -=
twoRxSquare; if (p
> 0) {
p += rxSquare - py;
}
else {
x++;
px += twoRySquare;
p += rxSquare - py + px;
}
plotEllipsePoints(centerX, centerY, x, y);
}
}
void display() {

drawEllipse(WINDOW_WIDTH/2, WINDOW_HEIGHT/2, 200, 100); // draw ellipse at
center of window with radii 200 and 100 pixels
glFlush();
}

glutInitDisplayMode(GLUT_SINGLE |
GLUT_RGB);
glutCreateWindow("Ellipse");
init();
glutMainLoop();
return 0;
}
Output:
CG LAB EXP-5
Draw Line, Rectangle, Arc and Circle using

inbuilt functions.
1. Line
Code:
void display() {
glClear(GL_COLOR_BUFFER_BIT); // Clear the screen
glColor3f(1.0, 1.0, 1.0); // Set line color to

white glBegin(GL_LINES); // Begin drawing a
line
glVertex2f(-0.5, -0.5); // Specify the starting point of the line
glVertex2f(0.5, 0.5); // Specify the ending point of the line
glEnd(); // End drawing the line
glFlush(); // Flush the drawing commands

}

glutInit(&argc, argv); // Initialize
GLUT
glutCreateWindow("OpenGL Line"); // Create a window with the specified title
glutDisplayFunc(display); // Set the display callback function
glutMainLoop(); // Start the main
loop return 0;
}
Output:
2. Rectangle
Code:
void rect_display() {
glClear(GL_COLOR_BUFFER_BIT); // clear the screen
glColor3f(0.0, 0.0, 1.0); // set rectangle color to blue
glBegin(GL_QUADS); // begin drawing
rectangle glVertex2f(-0.5, -0.5); // set first point
of rectangle glVertex2f(0.5, -0.5); // set
second point of rectangle glVertex2f(0.5, 0.5); //
set third point of rectangle glVertex2f(-0.5, 0.5); //
set fourth point of rectangle glEnd(); // end drawing
rectangle
glFlush(); // flush the buffer
}

glutCreateWindow("Rectangle");
glutDisplayFunc(rect_display);
glutMainLoop();
return 0;
}
Output:
3. Arc
Code:
#include <GL/glut.h> // include the GLUT library
#include <math.h> // include the math library
void display()
{
glClear(GL_COLOR_BUFFER_BIT); // clear the color buffer
glColor3f(1.0, 1.0, 1.0); // set the color to white
glMatrixMode(GL_PROJECTION); // switch to projection

matrix glLoadIdentity(); // reset projection matrix
gluOrtho2D(-1.0, 1.0, -1.0, 1.0); // set up an orthographic view
const float PI = 3.14159265;

float angle1 = 45.0f; // start angle of arc in
degrees float angle2 = 135.0f; // end
angle of arc in degrees float radius = 0.5f; // radius
of arc
glBegin(GL_LINE_STRIP); // start drawing line

strip for (float angle = angle1; angle <= angle2; angle +=
0.1f) {
float x = radius * cos(angle * PI /
180.0f); float y = radius * sin(angle * PI /
180.0f);
glVertex2f(x, y); // add vertex to line strip
}
glEnd(); // end drawing line strip
glFlush(); // flush drawing commands

}
int main(int argc, char **argv)

{
glutInit(&argc, argv); // initialize GLUT
glutCreateWindow("Arc"); // create a window
glutDisplayFunc(display); // register display callback
function glutMainLoop(); // enter main loop
return 0;
}
Output:
4. Circle
Code:
#include <math.h>
void display() {
glClear(GL_COLOR_BUFFER_BIT); // clear the screen
glColor3f(0.0, 1.0, 1.0); // set circle color to green
glBegin(GL_TRIANGLE_FAN); // begin drawing
circle glVertex2f(0.0, 0.0); // set center point of circle
float radius = 0.5; // set radius of circle
int num_segments = 50; // set number of segments for
circle for (int i = 0; i <= num_segments; i++) {
float angle = i * 2.0f * M_PI /
num_segments; float x = radius * cosf(angle);
float y = radius *
sinf(angle); glVertex2f(x, y);
}
glEnd(); // end drawing circle
glFlush(); // flush the buffer
}

glutInit(&argc, argv); // initialize GLUT
glutCreateWindow("Circle Drawing"); // create window
glutDisplayFunc(display); // set display callback
function glutMainLoop(); // enter main event loop
return 0;
}
Output:
CG LAB EXP-6
Boundary Fill
Boundary fill is a computer graphics algorithm used to fill a closed area (a region) with a
specific colour or pattern. The algorithm starts from a given point inside the region and
proceeds to fill the region with the specified colour or pattern until it reaches the boundary of
the region. The boundary is defined by a different colour or pattern, which is typically used
to distinguish the region from its surroundings. The boundary fill algorithm can be
implemented in different ways, such as the 4-connected approach, where pixels are
considered neighbours if they share a common edge, or the 8-connected approach, where
pixels are considered neighbours if they share a common edge or corner. The boundary fill
algorithm is commonly used in computer graphics applications such as drawing and painting
programs, where it allows users to quickly fill in areas of colour without having to manually
colour each individual pixel.
Algorithm:
1. Start by selecting a point inside the region to be filled.
2. Set the color of the selected pixel to the fill color.
3. Check the 8-connected neighbours of the selected pixel.
4. If a neighbour is not already filled and its color is not the boundary color, set its
color to the fill color and recursively repeat step 3 for this neighbour.
5. Repeat steps 3-4 for all 4/8-connected neighbours of the selected pixel.
6. Continue this process until all pixels within the region are filled.
Boundary Fill 4-connected
Code:
void boundaryFill4(int x, int y, float* fillColor, float* borderColor) {

float interiorColor[3];
glReadPixels(x, y, 1, 1, GL_RGB, GL_FLOAT, interiorColor);
if ((interiorColor[0] != borderColor[0] || interiorColor[1] != borderColor[1] ||
interiorColor[2] != borderColor[2]) &&
(interiorColor[0] != fillColor[0] || interiorColor[1] != fillColor[1] || interiorColor[2] !=
fillColor[2])) {
glColor3fv(fillColor);
glBegin(GL_POINTS);
glVertex2i(x, y);
glEnd();
boundaryFill4(x + 1, y, fillColor,
borderColor); boundaryFill4(x - 1, y, fillColor,
borderColor); boundaryFill4(x, y + 1,
fillColor, borderColor); boundaryFill4(x, y - 1,
fillColor, borderColor);
}
}
void display() {
// draw a square
glColor3f(1.0f, 1.0f, 1.0f);
glBegin(GL_LINE_LOOP);
glVertex2i(100, 100);
glEnd();
// perform boundary fill at (150, 150)

float fillColor[] = { 1.0f, 1.0f, 1.0f };
float borderColor[] = { 0.0f, 1.0f, 1.0f
};
boundaryFill4(150, 150, fillColor, borderColor);
glFlush();
}

glutInitDisplayMode(GLUT_SINGLE);
glutInitWindowSize(400, 400);
glutInitWindowPosition(100, 100);
glutCreateWindow("Boundary Fill 4-
Connected"); glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
gluOrtho2D(0, 400, 0, 400);
glutMainLoop();
return 0;
}
Output:
Boundary Fill 8-connected
Code:
#include <stdlib.h>
#define WINDOW_WIDTH 640

#define WINDOW_HEIGHT 480
// Set the fill color

GLfloat fillColor[3] = {0.0, 0.0, 1.0}; // Blue
// Set the boundary color

GLfloat borderColor[3] = {1.0, 1.0, 1.0}; // Black
// Get the color of a pixel

void getPixelColor(int x, int y, GLfloat color[3]) {
glReadPixels(x, y, 1, 1, GL_RGB, GL_FLOAT,
color);
}
// Set the color of a pixel

void setPixelColor(int x, int y, GLfloat color[3]) {
glColor3fv(color);
glBegin(GL_POINTS);
glVertex2i(x, y);
glEnd();
glFlush();
}
// Recursive function to fill the

region void boundaryFill8(int x, int
y) {
GLfloat interiorColor[3];
getPixelColor(x, y, interiorColor);
if ((interiorColor[0] != borderColor[0])
&& (interiorColor[1] != borderColor[1])
&& (interiorColor[0] != fillColor[0])
&& (interiorColor[2] != fillColor[2])) {
setPixelColor(x, y, fillColor);
boundaryFill8(x+1, y);
boundaryFill8(x-1, y);
boundaryFill8(x, y+1);
boundaryFill8(x, y-1);
boundaryFill8(x+1, y+1);
boundaryFill8(x+1, y-1);
boundaryFill8(x-1, y+1);
boundaryFill8(x-1, y-1);
}
}
// Display the window

void display() {
glClearColor(0.0, 0.0, 0.0, 0.0); // Set the background color to white
// Draw the border of the region

glColor3fv(borderColor);
glRecti(100, 100, 300, 300);
// Call the boundary fill

algorithm boundaryFill8(150,
150);
glFlush();
}
// Initialize the window

void init() {
gluOrtho2D(0, WINDOW_WIDTH, 0, WINDOW_HEIGHT);
}
// Main function
glutCreateWindow("Boundary Fill 8 Connected Algorithm");
init();
glutMainLoop();
return 0;
}
Output:
Flood Fill
Flood fill is a computer graphics algorithm used to fill a closed region with a specific color or
pattern. The algorithm works by selecting a starting point inside the region to be filled and
then colouring all the neighbouring pixels that are not part of the boundary until the entire
region is filled.The algorithm is named after the idea of "flooding" the region with color
starting from the initial point. It is commonly used in painting software, graphic design
applications, and video game development.The flood fill algorithm can be implemented in
either a recursive or iterative manner. Recursive implementation uses function calls to fill
neighbouring pixels while iterative implementation uses a stack or queue to keep track of
pixels to be filled.The flood fill algorithm can be modified to work with patterns, gradients,
or textures. It can also be used in combination with other algorithms such as edge detection
to create more complex effects.
Flood Fill algorithm
1. Choose a starting point inside the region to be filled.
2. Check the color of the starting point.
3. Set the color of the starting point to the fill colour.
4. Check the neighbouring pixels of the starting point.
5. If a neighbouring pixel has the same color as the starting point and is not
already filled, set its color to the fill color and add it to the list of pixels to
check.
6. Repeat step 5 for all neighbouring pixels.
7. Continue this process until there are no more pixels to check.
Flood Fill 4-connected
Code:
#include <stdlib.h>




color);
}

glColor3fv(color);
glBegin(GL_POINTS);
glVertex2i(x, y);
glEnd();
glFlush();
}

region void floodFill4(int x, int y) {
floodFill4(x+1, y);
floodFill4(x-1, y);
floodFill4(x, y+1);
floodFill4(x, y-1);
}
}

void display() {
// Draw the border of the

region
glRecti(100, 100, 300, 300);
// Call the flood fill

algorithm floodFill4(150,
150);
glFlush();
}

void init() {
}
// Main function
glutCreateWindow("Flood Fill 4 Connected Algorithm");
init();
glutMainLoop();
return 0;
}
Output:
Flood Fill 8-connected
Code:
#include <stdlib.h>




color);
}

glColor3fv(color);
glBegin(GL_POINTS);
glVertex2i(x, y);
glEnd();
glFlush();
}

region void floodFill8(int x, int y) {
floodFill8(x+1, y);
floodFill8(x-1, y);
floodFill8(x, y+1);
floodFill8(x, y-1);
floodFill8(x+1,
y+1);
floodFill8(x+1, y-1);
floodFill8(x-1, y+1);
floodFill8(x-1, y-1);
}
}

void display() {
// Draw the border of the

region
glRecti(100, 100, 300, 300);
// Call the flood fill

algorithm floodFill8(150,
150);
glFlush();
}

void init() {
}
// Main function
glutCreateWindow("Flood Fill 8 Connected Algorithm");
init();
glutMainLoop();
return 0;
}
Output:

CG Lab File

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

CG Lab File

Uploaded by

Copyright:

Available Formats

School of Computer Science

UNIVERSITY OF PETROLEUM AND ENERGY

Computer Graphics Lab

Submitted to: Submitted by:

OpenGL (Open Graphics Library) is an open-source, cross-platform API (application

GLU & GLUT:

GLU provides functions for performing common operations such as transforming

OpenGL is designed as a layered architecture that provides a modular structure for

OpenGL API layer:

Device driver layer:

Setting up the Environment:

5. Go to Downloadfreeglut-MinGW-3.0.0-1.mp folder freeglut folder bin

7. Now we have to set up the compiler. Go to Downloadfreeglut-MinGW-3.0.0-

10. Now we have to set up the compiler. Go to Downloadfreeglut-MinGW-3.0.0-

15. Go to C:\Program Files\CodeBlocks\share\CodeBlocks\templates directory and

First OpenGL Program:

int main(int argc,char **argv)

DDA Line DrawingAlgorithm

for (int i = 0; i <= steps; i++)

int main(int argc, char** argv) {

4. Initialise the error term to zero: error = 0.

Calculate the pixel coordinates: plot(x, y).

6. Repeat step 5 for each value of x until x equals x2.

int x1, y1, x2, y2;

void draw_line(int x1, int x2, int y1, int y2)

if (dx < 0) dx = -dx;

void main(int argc, char **argv) {

printf( "Enter (x1, y1, x2, y2)\n");

glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE|

a) W.A.P to draw a simple circle.

using namespace std;

const int WINDOW_WIDTH = 640;

void Circle(float x, float y, float radius)

//GLfloat radius = 0.8f;

glColor3f(1.0, 1.0, 1.0); // set color to white

int main(int argc, char **argv) {

2. Declare x, y, r, x c, y c and d as variables, where (x c, y c) are coordinates of

5. If x < y then set d = d + 4x + 6 and x = x + 1

6. Else set d = d + 4(y - x) + 10, x = x + 1 and y = y - 1

7. Go to step 4 until x > y

const int WINDOW_WIDTH = 640;

void plotCirclePoints(int centerX, int centerY, int x, int y) {

void drawCircle(int centerX, int centerY, int radius)

glColor3f(1.0, 1.0, 1.0); // set color to white

int main(int argc, char **argv) {

2. Declare x, y, r as variables, where (x, y) are coordinates of the center and r is

5. If p < 0 then set p = p + 2x + 3 and x = x + 1

6. Else set p = p + 2(x - y) + 5, x = x + 1 and y = y - 1

7. Go to step 4 until x > y

const int WINDOW_WIDTH = 640;

void plotCirclePoints(int centerX, int centerY, int x, int y) {

void drawCircle(int centerX, int centerY, int radius)

glColor3f(1.0, 1.0, 1.0); // set color to white

int main(int argc, char **argv) {

W.A.P to draw a simple ellipse.

const int WINDOW_WIDTH = 640;

void plotEllipsePoints(int centerX, int centerY, int x, int y) {

void drawEllipse(int centerX, int centerY, int rx, int ry)

p = std::round(rySquare * (x + 0.5) * (x + 0.5) + rxSquare * (y - 1) * (y - 1) - rxSquare *

glColor3f(1.0, 1.0, 1.0); // set color to white

int main(int argc, char **argv) {

Draw Line, Rectangle, Arc and Circle using

glColor3f(1.0, 1.0, 1.0); // Set line color to