VISVESVARAYA TECHNOLOGICAL UNIVERSITY

BELAGAVI - 590 018, KARNATAKA.

MINI PROJECT REPORT

ON

“DEMONSTRATION OF
DOUBLY LINKEDLIST”
Submitted in the partial fulfillment of requirements
FOR
Computer Graphics and Visualization Lab (18CSL67)
Submitted by

ABHISHEK V 4BD20CS004
SAGAR K R 4BD20CS082

PROJECT GUIDES:

Prof. Madhuri Deekshith S B.E, M. Tech., Prof.Gangamma H B.E, M. Tech.,

Asst. Professor Asst. Professor

2022-2023
Department of Computer Science and Engineering.
Bapuji Institute of Engineering & Technology
Davangere- 577004
 Bapuji Institute of Engineering and Technology
Davangere -577004

Department of Computer Science and Engineering

CERTIFICATE
This is to certify that ABHISHEK V and SAGAR K R bearing USN 4BD20CS004
and USN 4BD20CS082 respectively of Computer Science and Engineering department have
satisfactorily submitted the mini project report entitled “DEMONSTRATION DOUBLY
LINKED LIST”. The report of the project has been approved as it satisfies the academic
requirements in respect of project work prescribed for the academic year 2023.

Project Guide1 Project Guide 2

Prof. Madhuri Deekshith S B.E., M. Tech., Prof. Gangamma H B.E., M. Tech.,

Asst. Professor Asst. Professor

Department of CS&E Department of CS&E
B.I.E.T., Davangere. B.I.E.T., Davangere.

Head of Department

Dr. Nirmala C.R M. Tech., Ph.D.,

Prof & Head, Department of CS&E
B.I.E.T., Davangere

Date: Signature of Examiners:

Place: (1)

(2)
 ACKNOWLEDGEMENT

Salutations to our beloved and highly esteemed institute, “BAPUJI INSTITUTE OF

ENGINEERING AND TECHNOLOGY” for having well qualified staff and labs furnished with
necessary equipments.

We express our sincere thanks to our guide Prof. Madhuri Deekshith S & Prof.
Gangamma H for giving us constant encouragement, support and valuable guidance throughout
the course of the project without whose stable guidance this project would not have been
achieved.

We express whole hearted gratitude to Dr. Nirmala C R who is our respectable HOD of
Computer Science & Engineering Department. We wish to acknowledge her help who made our
task easy by providing with his valuable help and encouragement.

We also express our whole hearted gratitude to our principal, Dr. Aravind H B, for his
moral support and encouragement.

We would like to extend my gratitude to all staff of Department of Computer Science

and Engineering for the help and support rendered to me. I have benefited a lot from the
feedback, suggestions given by them.

We would like to extend my gratitude to all my family members and friends especially
for their advice and moral support.

ABHISHEK V (4BD20CS004)
SAGAR K R (4BD20CS062)
 Vision and Mission of the Institute

Vision
“To be a centre of excellence recognized nationally internationally, in distinctive areas of engineering
education and research, based on a culture of innovation and invention.”

Mission
“BIET contributes to the growth and development of its students by imparting a broad based
engineering education and empowering them to be successful in their chosen field by inculcating in
them positive approach, leadership qualities and ethical values.”

Vision and Mission of the Computer Science and Engineering

Department

Vision
“To be a centre-of-excellence by imbibing state-of-the-art technology in the field of Computer
Science and Engineering, thereby enabling students to excel professionally and be ethical.”

Mission

1. Adapting best teaching and learning techniques that cultivates Questioning and
Reasoning culture among the students.
2. Creating collaborative learning environment that ignites the critical thinking in
students
and leading to the innovation.
3. Establishing Industry Institute relationship to bridge skill gap and make them
industryready and relevant.
4. Mentoring students to be socially responsible by inculcating ethical and moral
values.
Program Educational Objectives (PEOs):

PEO1 To apply skills acquired in the discipline of computer science and engineering
for solving Societal and industrial problems with apt technology intervention.
PEO2 To continue their carrier ion industry /academia or pursue higher studies and
research.
PEO3 To become successful entrepreneurs, innovators to design and develop software
products and services that meets societal, technical and business challenges.
PEO4 To work in the diversified environment by acquiring leadership qualities with
effective communication skills accompanied by professional and ethical values.

Program Specific Outcomes (PSOs):

PSO1 Analyse and develop solutions for problems that are complex in nature but
applying the knowledge acquired from the core subjects of this program.
PSO2 To develop secure, scalable, resilient and distributed applications for industry
and
societal Requirements.
PSO3 To learn and apply the concepts and contract of emerging technologies like artificial
intelligence, machine learning, deep learning, big-data analytics, IOT, cloud
computing etc for any real time problems.

Course Outcomes :

CO1 Apply the concepts of computer graphics

CO2 Implement computer graphics applications using OpenGL
CO3 Animate real world problems using OpenGL
CO4 CO4 Implementation of line drawing and clipping algorithms using OpenGL
functions
CO5 Design and implementation of algorithms Geometric transformations on both 2D
and 3D objects.
 ABSTRACT

A doubly linked list consists of nodes, where each node contains data and two pointers: one
pointing to the previous node and another pointing to the next node. The visualization begins by
depicting an empty doubly linked list, represented by a blank canvas. The process of inserting
elements into the list is demonstrated by adding nodes one by one, with the appropriate pointers
updated to maintain the linkage between nodes. The removal of nodes from the doubly linked list is
another operation which includes updating the pointers of the adjacent nodes to bypass the
removed node, effectively maintaining the integrity of the list. It also showcases traversal
operations, such as iterating through the list from the beginning or end, and accessing individual
nodes. These operations help in understanding how the pointers enable efficient navigation within
the doubly linked list. It also demonstrates the operation of searching for a specific element within
the doubly linked list. It illustrates the process of comparing the data in each node with the target
element and moving through the list using the pointers until the desired node is found.
 CONTENTS
TOPIC PAGE NO.
Chapter 1: INTRODUCTION 1-9
1.1 OpenGL
1.2 History
1.3 Features of OpenGL
1.4 Basic OpenGL Operations
1.5 OpenGL Interface
1.6 Graphics Functions
1.7 Data Types

Chapter 2: SYSTEM REQUIREMENT 10

2.1 Software Requirements
2.2 Hardware Requirements
Chapter 3: DESIGN 11-12
3.1 Implementation
3.2 Display
3.3 Flowchart
Chapter 4: IMPLEMENTATION 13-22
4.1 Overview
4.2 User Interface
4.3 Structure
4.4 Analysis
Chapter 5: SNAPSHOTS 23-26
CONCLUSION
REFERENCES
 LIST OF FIGURES

Sl. No. Fig. No. NAME Page No.

1. 1.4 OpenGL Block Diagram 4

2. 1.5 Library Organization 7
3. 1.1 Data Types List 9
4. 3.3 Flow Chart 12
5. 5.1 Home page 23
6. 5.2 Insertion at front 24
7. 5.3 Insertion at Rear 24
8. 5.4 Insertion at the left of a node 24
9. 5.5 Insertion at the right of a node 25
10. 5.6 Deleting Front 25
11. 5.7 Deleting Rear 26
12. 5.8 Deleting specified element 26
 Demonstration of doubly linked list

CHAPTER 1
INTRODUCTION
1.1 OPENGL
OpenGL is the abbreviation for Open Graphics Library. It is a software interface for
graphics hardware. This interface consists of several hundred functions that allow you, a
graphics programmer, to specify the objects and operations needed to produce high-quality color
images of two-dimensional and three-dimensional objects. Many of these functions are actually
simple variations of each other, so in reality there are about 120 substantially different
functions.The main purpose of OpenGL is to render two-dimensional and three-dimensional
objects into the frame buffer. These objects are defined as sequences of vertices (that define
geometric objects) or pixels (that define images).OpenGL performs several processes on this
data to convert it to pixels to form the final desired image in the frame buffer.

1.2 HISTORY
As a result, SGI released the OpenGL standard In the 1980s, developing software that
could function with a wide range of graphics hardware was a real challenge. Software developers
wrote custom interfaces and drivers for each piece of hardware. This was expensive and resulted
in much duplication of effort.

By the early 1990s, Silicon Graphics (SGI) was a leader in 3D graphics for workstations.
Their IRIS GL API was considered the state of the art and became the de facto industry standard,
overshadowing the open standards-based PHIGS. This was because IRIS GL was considered
easier to use, and because it supported immediate mode rendering. By contrast, PHIGS was
considered difficult to use and outdated in terms of functionality.

SGI's competitors (including Sun Microsystems, Hewlett-Packard and IBM) were also
able to bring to market 3D hardware, supported by extensions made to the PHIGS standard. This
in turn caused SGI market share to weaken as more 3D graphics hardware suppliers entered the
market. In an effort to influence the market, SGI decided to turn the Iris GL API into an open
standard.

CS&E Dept, B.I.E.T, Davangere 1

 Demonstration of doubly linked list

SGI considered that the Iris GL API itself wasn't suitable for opening due to licensing and
patent issues. Also, the Iris GL had API functions that were not relevant to 3D graphics. For
example, it included a windowing, keyboard and mouse API, in part because it was developed
before the X Window System and Sun's NEWSsystems were developed.

In addition, SGI had a large number of software customers; by changing to the OpenGL
API they planned to keep their customers locked onto SGI (and IBM) hardware for a few years
while market support for OpenGL matured. Meanwhile, SGI would continue to try to maintain
their customers tied to SGI hardware by developing the advanced and proprietary Iris Inventor
and Iris Performer programming APIs.

1.3 FEATURES OF OPENGL

 Industry standard
An independent consortium, the OpenGL Architecture Review Board, guides the
OpenGL specification. With broad industry support, OpenGL is the only truly open,
vendor-neutral, multiplatform graphics standard.

 Stable
OpenGL implementations have been available for more than seven years on a wide
variety of platforms. Additions to the specification are well controlled, and proposed
updates are announced in time for developers to adopt changes. Backward compatibility
requirements ensure that existing applications do not become obsolete.

 Reliable and portable

All OpenGL applications produce consistent visual display results on any OpenGL API-
compliant hardware, regardless of operating system or windowing system.

 Evolving
Because of its thorough and forward-looking design, OpenGL allows new hardware
innovations to be accessible through the API via the OpenGL extension mechanism. In
this way, innovations appear in the API in a timely fashion, letting application developers
and hardware vendors incorporate new features into their normal product release cycles.

CS&E Dept, B.I.E.T, Davangere 2

 Demonstration of doubly linked list

 Scalable
OpenGL API-based applications can run on systems ranging from consumer electronics
to PCs, workstations, and supercomputers. As a result, applications can scale to any class
of machine that the developer chooses to target.

 Easy to use
OpenGL is well structured with an intuitive design and logical commands. Efficient
OpenGL routines typically result in applications with fewer lines of code than those that
make up programs generated using other graphics libraries or packages. In addition,
OpenGL drivers encapsulate information about the underlying hardware, freeing the
application developer from having to design for specific hardware features.

 Well-documented
Numerous books have been published about OpenGL, and a great deal of sample code is
readily available, making information about OpenGL inexpensive and easy to obtain.

CS&E Dept, B.I.E.T, Davangere 3

 Demonstration of doubly linked list

1.4 BASIC OPENGL OPERATION

The following diagram illustrates how OpenGL processes data. As shown, commands
enter from the left and proceed through a processing pipeline. Some commands specify
geometric objects to be drawn, and others control how the objects are handled during various
processing stages.

Fig 1.4.1: OpenGL Block Diagram

The processing stages in basic OpenGL operation are as follows:

 Display list

Rather than having all commands proceed immediately through the pipeline, you can
choose to accumulate some of them in a display list for processing later.

 Evaluator

The evaluator stage of processing provides an efficient way to approximate curve and
surface geometry by evaluating polynomial commands of input values.

CS&E Dept, B.I.E.T, Davangere 4

 Demonstration of doubly linked list

 Per-vertex operations and primitive assembly

OpenGL processes geometric primitives - points, line segments, and polygons all of
which are described by vertices. Vertices are transformed, and primitives are clipped to
the viewport in preparation for rasterization.

 Rasterization

The rasterization stage produces a series of frame-buffer addresses and associated

values using a two-dimensional description of a point, line segment, or polygon. Each so
produced is fed into the last stage, per-fragment operations.

 Per-fragment operations

These are the final operations performed on the data before it is stored as pixels in the
frame buffer Per-fragment operations include conditional updates to the frame buffer
based on incoming and previously stored z values (for z buffering) and blending of
incoming pixel colors with stored colors, as well as masking and other logical operations
on pixel values.

 Pixel operation

Input data can be in the form of pixels rather than vertices. Such data which might
describe an image for texture mapping skips the first stage of processing and instead
processed as pixels in the pixel operation stage.

 Texture memory

The result of pixel operation stage is either stored as texture memory for use in
rasterization stage or rasterised and resulting fragment merged into the frame buffer just
as they were generated from the geometric data.

CS&E Dept, B.I.E.T, Davangere 5

 Demonstration of doubly linked list

1.5 THE OPENGL INTERFACE

Most of our applications will be designed to access OpenGL directly through functions in
three libraries. They are

 GL – Graphics Library

Functions in the main GL (or OpenGL in Windows) library have names that begin with
the letters gl and are stored in a library usually referred to as GL (or OpenGL in
Windows).

 GLU – Graphics Utility Library

This library uses only GL functions but contain code for creating common objects and
simplifying viewing. All functions in GLU can be created from the core GL library but
application programmers prefer not to write the code repeatedly. The GLU library is
available in all OpenGL implementations; functions in the GLU library begins with the
letters glu.

 GLUT – OpenGL Utility Toolkit

To interface with the window system and to get input from external devices into our
programs we need at least one more library. For the X window System, this library is
called GLX, for Windows, it is wgl, and for the Macintosh, it is agl. Rather than using a
different library for each system, we use a readily available library called the OpenGL
Utility Toolkit (GLUT) , which provides minimum functionality that should be expected
in any modern windowing system.

CS&E Dept, B.I.E.T, Davangere 6

 Demonstration of doubly linked list

Fig 1.5.1: Library Organization

The above figure shows the organization of the libraries for an X Window System
environment.

In most implementations, one of the include lines

#include<GL/glut.h>

or

#include<GLUT/glut.h>

is sufficient to read in glut.h, gl.h and glu.h.

CS&E Dept, B.I.E.T, Davangere 7

 Demonstration of doubly linked list

1.6 GRAPHICS FUNCTIONS

Our basic model of a graphics package is a black box, a term that engineers use to denote
a system whose properties are described only by its inputs and outputs; we may know nothing
about its internal workings.

OpenGL functions can be classified into seven major groups:

 Primitive function: The primitive functions define the low-level objects or atomic
entities that our system can display. Depending on the API, the primitives can include
points, lines, polygons , pixels, text, and various types of curves and surfaces.

 Attribute functions
If primitives are the what of an API – the primitive objects that can be displayed- then
attributes are the how. That is, the attributes govern the way the primitive appears on the
display. Attribute functions allow us to perform operations ranging from choosing the
color with which we display a line segment, to picking a pattern with which to fill inside
of a polygon.

 Viewing functions
The viewing functions allow us to specify various views, although APIs differ in the
degree of flexibility they provide in choosing a view.

 Transformation functions
One of the characteristics of a good API is that it provides the user with a set of
transformations functions such as rotation, translation and scaling.

 Input functions
For interactive applications, an API must provide a set of input functions, to allow users
to deal with the diverse forms of input that characterize modern graphics systems. We
need functions to deal with devices such as keyboards, mice and data tablets.

CS&E Dept, B.I.E.T, Davangere 8

 Demonstration of doubly linked list

 Control functions
These functions enable us to communicate with the window system, to initialize our
programs, and to deal with any errors that take place during the execution of our
programs.

 Query functions
If we are to write device independent programs, we should expect the implementation of
the API to take care of the differences between devices, such as how many colors are
supported or the size of the display. Such information of the particular implementation
should be provides through a set of query functions.

CS&E Dept, B.I.E.T, Davangere 9

 Demonstration of doubly linked list

CHAPTER 2

SYSTEM REQUIREMENTS

2.1 SOFTWARE REQUIREMENTS

1. Operating System : Microsoft Windows XP,Microsoft Windows 7

2. Compiler used: VC++ 6.0 compiler

3. Language used: C/ C++

2.2 HARDWARE REQUIREMENTS

1. Main Processor: PENTIUM III or above.

2. Processor Speed: 800 MHz

3. RAM Size: 128MB DDR

4. Monitor resolution - A color monitor with a minimum resolution of 1000*700

CS&E Dept, B.I.E.T, Davangere 10

 Demonstration of doubly linked list

CHAPTER 3

DESIGN

3.1 INITIALIZATION

1. Define the Atom Structure: Decide on the type of atom structure you want to simulate,
such as a solid or a molecular system. Determine the number of atoms, their positions,
and the bonds between them if applicable.

2. Create a 3D Environment: Set up a 3D environment or space where the atoms will exist
and interact. This could be a virtual 3D scene or a simulation box with specific
dimensions.

3. Visualization: Implement a visualization module to display the atom positions and their
movements. This can involve rendering the atoms as spheres or other appropriate
representations and updating their positions in real-time as the simulation progresses.

4. Run the Simulation: Execute the simulation code, which iteratively updates the atom
positions based on the integration method and interatomic forces. Monitor the
simulation's progress, record data if needed, and observe the behavior of the atoms in the
virtual environment.

CS&E Dept, B.I.E.T, Davangere 11

 Demonstration of doubly linked list

3.2 DISPLAY

Atom simulation uses only one window. That is

 Atom simulation (Main window): This window contains all the contents that is menu bar
and simulation display. This is window used for all the events and functions in this
project. In this window we display simulation of first 10 atoms in the periodic table. And
all mouse and keyboard events triggered in this window. All the labels and Information
about the model will be displayed on this window.

Fig 3.2.1: Display of Atom Simulation

CS&E Dept, B.I.E.T, Davangere 12

 Demonstration of doubly linked list

3.3 FLOWCHART

Fig 3.3.1: Flowchart of Atom Simulation

CS&E Dept, B.I.E.T, Davangere 13

 Demonstration of doubly linked list

CHAPTER 4
IMPLEMENTATION
4.1 OVERVIEW

In this Atom Simulation Project shows the movement of electron around the nucleus on
the orbit. We have taken the help of built-in functions present in the header file. To provide
functionality to our project we have written sub functions. These functions provide us the
efficient way to design the project. In this chapter we are describing the functionality of our
project using these functions.

4.2 USER INTERFACE

Mouse interface

 Select element: When the user clicks the right click button on the mouse, the screen will
be prompted with the list of options. First option is to select the user desired element
from the list. The list contains elements from Hydrogen to Neon for the simulation, that is
from atomic number 1 to atomic number 10.

 Simulate: After user selecting an element, when he/she clicks on the simulate option, the
electrons around the nucleus starts revolving around the nucleus within their orbit.

 Stop simulation: If a user selects this option, the simulation will be paused.

 Exit: The program execution will be terminated and the window will be destroyed after
selecting this option.

Keyboard Interface

 After selecting an element, if a user presses spacebar the simulation will be started.

 After starting the simulation if the user clicks on ‘S’ key, simulation will be paused.

 If the user clicks on the ‘Q’ key, program execution will be terminated and the window
will be destroyed.

CS&E Dept, B.I.E.T, Davangere 14

 Demonstration of doubly linked list

4.3 STRUCTURE
 void circle(float rad)
 void drawString(float x, float y, float z, char *string)
 void drawsubhead(float x, float y, float z, char *string)
 void nuc(float rad)
 void display()
 void rotate()
 void mouseControl(int button, int state, int x, int y)
 void keyboard(unsigned char key, int x, int y)
 void menu(int option)
 void createMenu(void)
 int main(int argc, char **argv) 

4.4 ANALYSIS
Purpose:
• Main function.
• Function to displays instructions and labels on screen.
• Methods defining coordinate values for objects.
• Function for drawing different objects on screen.
• Keyboard and Mouse function for interaction.
• Display function.

4.4.1 MAIN FUNCTION

int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitWindowPosition(300, 100);
glutInitWindowSize(700, 700);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
glutCreateWindow("ATOM SIMULATION");

CS&E Dept, B.I.E.T, Davangere 15

 Demonstration of doubly linked list

init();
glutDisplayFunc(display);
glutMouseFunc(mouseControl);
glutKeyboardFunc(keyboard);
glutSpecialFunc(fkey);
createMenu();
glutMainLoop();
return 0;
}

4.4.2 FUNCTION TO DISPLAYS INSTRUCTIONS

void display()
{
glClearColor(1, 1, 0.9, 1);
glClear(GL_COLOR_BUFFER_BIT);

if (value == -1)
{
char cn[] = "BAPUJI INSTITUTE OF ENGINEERING AND TECHNOLOGY";
drawhead(-650, 900, 0, cn);
char pn[] = "Davanagere -577004";
drawsubhead(-250, 850, 0, pn);

char dn[] = "DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING";

drawhead(-690, 650, 0, dn);

char prn[] = "A Mini Project On";

drawsubhead(-150, 450, 0, prn);
char pro[] = "ATOM SIMULATION";
drawhead(-250, 350, 0, pro);

char pb[] = "PROJECT BY: ";

drawhead(-690, -150, 0, pb);

char p1[] = "SYED FARHAN";

drawhead(-690, -250, 0, p1);
char p1u[] = "4BD20CS104";
drawsubhead(-690, -300, 0, p1u);

char p2[] = "NIKIL B S";

drawhead(-690, -400, 0, p2);

CS&E Dept, B.I.E.T, Davangere 16

 Demonstration of doubly linked list

char p2u[] = "4BD20CS062";

drawsubhead(-690, -450, 0, p2u);

char gb[] = "GUIDED BY: ";

drawhead(290, -150, 0, gb);

char g1[] = "Mrs. Madhuri deekshith S ";

drawhead(290, -250, 0, g1);
char d1[] = "Asst. professor, Department of CSE, BIET";
drawsubhead(290, -300, 0, d1);

char g2[] = "Mr. Naveen H M ";

drawhead(290, -400, 0, g2);
char d2[] = "Asst. professor, Department of CSE, BIET";
drawsubhead(290, -450, 0, d2);

char in[] = "Press enter to Continue";

drawhead(-250, -700, 0, in);

glutDetachMenu(GLUT_RIGHT_BUTTON);
glutSwapBuffers();
}

4.4.3 FUNCTION FOR DRAWING DIFFERENT OBJECTS ON SCREEN

void circle(float rad)

{
glBegin(GL_POINTS);
glColor3f(1, 0, 0);
for (float i = 0; i < (2 * pi); i += 0.001)
{
glVertex2i(rad * cos(i), rad * sin(i));
}
glEnd();
}
void drawString(float x, float y, float z, char *string)
{
glColor3f(0, 0, 0);
glRasterPos3f(x, y, z);

for (char *c = string; *c != '\0'; c++)

{
glutBitmapCharacter(GLUT_BITMAP_HELVETICA_10, *c);
}
}

CS&E Dept, B.I.E.T, Davangere 17

 Demonstration of doubly linked list

void drawhead(float x, float y, float z, char *string)

{
glColor3f(0, 0, 0);
glRasterPos3f(x, y, z);
for (char *c = string; *c != '\0'; c++)
{
glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18, *c);
}
}

void drawsubhead(float x, float y, float z, char *string)

{
glColor3f(0, 0, 0);
glRasterPos3f(x, y, z);
for (char *c = string; *c != '\0'; c++)
{
glutBitmapCharacter(GLUT_BITMAP_HELVETICA_12, *c);
}
}

void nuc(float rad)

{
glBegin(GL_POLYGON);
glColor3f(0.8, 0.4, 0.5);
for (float i = 0; i < (2 * pi); i = i + 0.1)
{
glVertex2f(rad * cos(i), rad * sin(i));
}
glEnd();
}

4.4.5 KEYBOARD AND MOUSE FUNCTION FOR INTERACTION

void mouseControl(int button, int state, int x, int y)

{
switch (button)
{
case GLUT_LEFT_BUTTON:
if (state == GLUT_DOWN)
glutIdleFunc(rotate);
break;
default:
break;
}
}

CS&E Dept, B.I.E.T, Davangere 18

 Demonstration of doubly linked list

void keyboard(unsigned char key, int x, int y)

{
if (key == 13)
{
value = 0;
glClear(GL_COLOR_BUFFER_BIT);
glutAttachMenu(GLUT_RIGHT_BUTTON);
glutPostRedisplay();
}
else if (key == 's')
{
glutIdleFunc(NULL);
}
else if (key == 32)
{
glutIdleFunc(rotate);
}
else if (key == 'q' || key == 'Q')
{
exit(0);
}
else if (key == 'b' || key == 'B')
{
value=-1;
}
else if (key == 27)
{
glutReshapeWindow(700, 700);
}

4.4.6 DISPLAY FUNCTION

void display()
{
glClearColor(1, 1, 0.9, 1);
glClear(GL_COLOR_BUFFER_BIT);
if (value == 1)
{
char n[] = "HYDROGEN";
drawhead(-100, 900, 0, n);
circle(400);
char o[] = "ORBIT";
drawString(410, 0, 0, o);

CS&E Dept, B.I.E.T, Davangere 19

 Demonstration of doubly linked list

glPushMatrix();
glRotatef(angle, 0, 0, 1);
eleright(400);
char e[] = "ELECTRON";
drawString(420, 0, 0, e);
glPopMatrix();
glutSwapBuffers();
}

…………

if (value == 10)
{
char n[] = "NEON";
drawhead(-100, 900, 0, n);
circle(400);
circle(600);
char o[] = "ORBIT";
drawString(610, 0, 0, o);
glPushMatrix();
glRotatef(angle, 0, 0, 1);
eleright(400);
eleleft(400);
eletop(600);
eledown(600);
eletr(600);
eledl(600);
eletl(600);
eledr(600);
eleleft(600);
eleright(600);
char e[] = "ELECTRON";
drawString(0, 620, 0, e);
glPopMatrix();
glutSwapBuffers();
}

CS&E Dept, B.I.E.T, Davangere 20

 Demonstration of doubly linked list

CHAPTER 5
SNAPSHOTS

Fig 5.1: Initial View

Fig 5.2: Hydrogen Atom

CS&E Dept, B.I.E.T, Davangere 21

 Demonstration of doubly linked list

Fig 5.3: Boron Atom

Fig 5.4: Neon Atom

CS&E Dept, B.I.E.T, Davangere 22

 CONCLUSION

Operations on Doubly Linked List is a designed and implemented using a graphics software
system called OpenGL which has became a widely accepted standard for developing graphic
application. Using OpenGL functions user can create geometrical objects and can use
translation, rotation, scaling with respect to the co-ordinate system. The development of this
project has given us a good exposure to OpenGL by which we have learnt some of the
technique which help in development of animated pictures, gaming.
 REFERENCES

BOOKS:

[1] Edward Angel: Interactive Computer Graphics A Top-Down Approach with OpenGL, 5
edition, Pearson Education, 2008.

[2] Donald Hearn and Pauline Baker: Computer Graphics-OpenGL Version, 3d Edition,
Pearson 2004.

LINKS:

[1] https://www.opengl.org/

[2] https://www.glprogramming.com

[3] https://open.gl/transformations