Graphics Mini Project Report 1

MINI PROJECT
RAILWAY STATION WITH MOVING TRAIN
ANKIT SOURAV
Registration No: 12010073
Subject: CSE- 304 (Computer Graphics & Visualization)
Submitted to
Dr. Om Prakash Yadav (26121)
Asst. Professor,
School of Computer Science and Engineering
Lovely Professional University

Jalandhar – Delhi, Grand Trunk Rd,
Phagwara, Punjab 144001
March, 2023
ABSTRACT
Computer graphics is a powerful medium for presentation and design. In early days of its usage, it
has been used mainly for presentation.
This Project “Railway Station with Moving Train” is designed to show the 2D view of the objects
and its transformation. The project deals with providing the graphical interface between the user and
the system. Project has been built using computer graphics package i.e. OpenGL.
Main aim of this Mini Project is to illustrate the concepts of color combination and usage of the
OpenGL library. This Project consists of Railway station having three seating benches, sun shining
in the sky, moving clouds, fencing borders behind the railway station, greenery like grass and trees
planted in the railway station campus and a traffic light which gives the green signal to pass the train
over the tacks.
Project consists of a moving train with three connector coaches and wheels. When the code is
executed all the functionalities starts performing simultaneously. The color combination makes it
attractive. The animate option enables the object move from one to place to another. The train is
having the head light emitting yellow color light.
OpenGL provides a set of commands to render a three dimensional scene. OpenGL is a hardware-
and system-independent interface. An OpenGL application will work on every platform, as long as
there is an installed GLUT library.
INTRODUCTION
First Come First Serve Algorithm is OS based Computer graphics Project. This project demonstrates
the working of First Come First Serve Algorithm or FCFS Algorithm. The Objects are drawn using
the GLUT functions. This project has been developed using Dev- C++ on Windows 10 operating
system with OpenGL package.
Computer Graphics
Graphics are defined as any sketch or a drawing or a special network that pictorially
represents some meaningful information. Computer Graphics is used where a set of images
needs to be manipulated or the creation of the image in the form of pixels and is drawn on
the computer. Computer Graphics can be used in digital photography, film, entertainment,
electronic gadgets, and all other core technologies which are required. It is a vast subject
and area in the field of computer science. Computer Graphics can be used in UI design,
rendering, geometric objects, animation, and many more. In most areas, computer graphics
is an abbreviation of CG. There are several tools used for the implementation of Computer
Graphics.
Applications of Computer Graphics
• Computer Graphics are used for an aided design for engineering and architectural
system- These are used in electrical automobiles, electro-mechanical, mechanical, electronic
devices. For example, gears and bolts.
• Computer Art – MS Paint.
• Presentation Graphics – It is used to summarize financial statistical scientific or economic

data. For example- Bar chart, Line chart.
• Entertainment- It is used in motion pictures, music videos, television gaming.
• Education and training- It is used to understand the operations of complex systems. It is

also used for specialized system such for framing for captains, pilots and so on.
• Visualization- To study trends and patterns. For example- Analysing satellite photo of earth.
OpenGL
Open Graphics Library (OpenGL) is a cross-language (language independent), cross-platform

(platform-independent) API for rendering 2D and 3D Vector Graphics (use of polygons to
represent image). OpenGL API is designed mostly in hardware.
• Design: This API is defined as a set of functions which may be called by the client
program. Although functions are like those of C language, but it is language independent.
• Development: It is an evolving API and Khronos Group regularly releases its new version
having some extended features compare to previous one. GPU vendors may also provide some
additional functionality in the form of extension.
• Associated Libraries: The earliest version is released with a companion library called
OpenGL utility library. But since OpenGL is quite a complex process. So in order to make it easier
other library such as OpenGL Utility Toolkit is added which is later superseded by free glut. Later
included library were GLEE, GLEW, and gliding.
• Implementation: Mesa 3D is an open-source implementation of OpenGL. It can do pure

software rendering and it may also use hardware acceleration on BSD, Linux, and other platforms
by taking advantage of Direct Rendering Infrastructure.
Advantages of OpenGL
1. Industry Standard: OpenGL specification is guided by an independent consortium, the OpenGL

Architecture Review Board, due to which it has broad industry support.
2. Stability: All the features provided by OpenGL are well controlled. Backward compatibility also
ensures that the existing applications and features don't become obsolete at any point.
3. Reliability and Portability: All OpenGL applications produce consistent visual display results on
any OpenGL API-compliant hardware, regardless of the operating system or windowing system.
4. Huge Community: OpenGL also has a huge community behind it and that also has its own
benefits.
5. Documentation: OpenGL is very properly documented and all of its features, from individual
functions to shaders, are readily available and can be easily obtained.
Disadvantages of OpenGL
1. You can print an OpenGL image directly to a printer using metafiles only. For more
information, see Printing an OpenGL Image.
2. An application can directly draw both OpenGL graphics and GDI graphics into a single-
buffered window, but not into a double-buffered window.
3. Windows has a single system hardware color palette, which applies to the whole screen. An
OpenGL window cannot have its own hardware palette but can have its own logical palette.
4. There is no direct support for the Clipboard, dynamic data exchange (DDE), or OLE.
5. There is no support for the following pixel format features: stereoscopic images, alpha bit
planes, and auxiliary buffers.
System Requirements
Hardware: PC, Keyboard, 4 GB RAM, 500 GB HDD, Mouse, 2 + GB Compatible Graphics cards,
minimum CPU should have intel i3 processor or above, Monitor Resolution- minimum of 640*480.
Software: Dev C++, OpenGL Library Functions, Windows 7 or 8 Operating system.

CODE
#include<stdio.h>
#include<GL/glut.h>
#include <GL/gl.h>
#include <stdlib.h>
#define SPEED 30.0
float i=0.0,m=0.0,n=0.0,o=0.0,c=0.0;
int light=1,day=1,plane=0,comet=0,xm=900,train=0;
char ch;
void declare(char *string)

{
while(*string)
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, *string++);
}
void draw_pixel(GLint cx, GLint cy)

{
glBegin(GL_POINTS);
glVertex2i(cx,cy);
glEnd();
}
void plotpixels(GLint h,GLint k, GLint x,GLint y)

{
draw_pixel(x+h,y+k);
draw_pixel(-x+h,y+k);
draw_pixel(x+h,-y+k);
draw_pixel(-x+h,-y+k);
draw_pixel(y+h,x+k);
draw_pixel(-y+h,x+k);
draw_pixel(y+h,-x+k);
draw_pixel(-y+h,-x+k);
}
void draw_circle(GLint h, GLint k, GLint r)

{
GLint d=1-r, x=0, y=r;
while(y>x)
{
plotpixels(h,k,x,y);
if(d<0) d+=2*x+3;
else
{
d+=2*(x-y)+5;
--y;
}
++x;
}
plotpixels(h,k,x,y);
}
void draw_object()
{
int l;
if(day==1)
{
//sky
glColor3f(0.0,0.9,0.9);
glBegin(GL_POLYGON);
glVertex2f(0,380);
glVertex2f(0,700);
glVertex2f(1100,700);
glEnd();
//sun
for(l=0;l<=35;l++)
{
glColor3f(1.0,0.9,0.0);
draw_circle(100,625,l);
}
//cloud1
for(l=0;l<=20;l++)
{
glColor3f(1.0,1.0,1.0);
draw_circle(160+m,625,l);
for(l=0;l<=35;l++)
{
glColor3f(1.0,1.0,1.0);
}
for(l=0;l<=20;l++)
{
glColor3f(1.0,1.0,1.0);
}
//cloud2
for(l=0;l<=20;l++)
{
glColor3f(1.0,1.0,1.0);
}
for(l=0;l<=35;l++)
{
glColor3f(1.0,1.0,1.0);
}
for(l=0;l<=20;l++)
{
glColor3f(1.0,1.0,1.0);
}
//sky
glColor3f(0.0,0.0,0.0);
glVertex2f(0,380);
glVertex2f(0,700);
glEnd();
//grass
glColor3f(0.0,0.3,0.0);
glVertex2f(0,160);
glVertex2f(0,380);
glEnd();
//track boundary
glColor3f(1.0,1.0,1.0);
glVertex2f(0,150);
glVertex2f(0,160);
glEnd();
//Railway track
glColor3f(0.0,0.0,0.0);
glVertex2f(-100,0);
glVertex2f(-100,20);
glVertex2f(1100,0);
glEnd();
glEnd();
glVertex2f(0,0);
glVertex2f(0,80);
glVertex2f(10,80);
glVertex2f(10,0);
glEnd();
glVertex2f(80,0);
glVertex2f(80,80);
glVertex2f(90,80);
glVertex2f(90,0);
glEnd();
glVertex2f(150,0);
glVertex2f(150,80);
glVertex2f(160,80);
glVertex2f(160,0);
glEnd();
glVertex2f(220,0);
glVertex2f(220,80);
glVertex2f(230,80);
glVertex2f(230,0);
glEnd();
glVertex2f(290,0);
glVertex2f(290,80);
glVertex2f(300,80);
glVertex2f(300,0);
glEnd();
glVertex2f(360,0);
glVertex2f(360,80);
glVertex2f(370,80);
glVertex2f(370,0);
glEnd();
glVertex2f(430,0);
glVertex2f(430,80);
glVertex2f(440,80);
glVertex2f(440,0);
glEnd();
glVertex2f(500,0);
glVertex2f(500,80);
glVertex2f(510,80);
glVertex2f(510,0);
glEnd();
glVertex2f(570,0);
glVertex2f(570,80);
glVertex2f(580,80);
glVertex2f(580,0);
glEnd();
glVertex2f(640,0);
glVertex2f(640,80);
glVertex2f(650,80);
glVertex2f(650,0);
glEnd();
glVertex2f(710,0);
glVertex2f(710,80);
glVertex2f(720,80);
glVertex2f(720,0);
glEnd();
glVertex2f(770,0);
glVertex2f(770,80);
glVertex2f(780,80);
glVertex2f(780,0);
glEnd();
glVertex2f(840,0);
glVertex2f(840,80);
glVertex2f(850,80);
glVertex2f(850,0);
glEnd();
glVertex2f(900,0);
glVertex2f(900,80);
glVertex2f(910,80);
glVertex2f(910,0);
glEnd();
glVertex2f(970,0);
glVertex2f(970,80);
glVertex2f(980,80);
glVertex2f(980,0);
glEnd();
glVertex2f(1040,0);
glVertex2f(1050,0);
glEnd();
//railway station
glColor3f(0.647059,0.164706,0.164706);
glEnd();
//roof
glColor3f(0.556863,0.419608,0.137255);
glEnd();
//side window
glColor3f(0.556863,0.419608,0.137255);
glEnd();
//side window
glColor3f(0.556863,0.419608,0.137255);
glEnd();
glColor3f(0.847059,0.847059,0.74902);
glEnd();
glEnd();
glEnd();
//window 1
glColor3f(0.196078,0.6,0.8);
glEnd();
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINES);
glVertex2f(450,337.5);
glEnd();
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINES);
glEnd();
//window 2
glColor3f(0.196078,0.6,0.8);
glEnd();
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINES);
glEnd();
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINES);
glEnd();
//door
glColor3f(0.329412,0.329412,0.329412);
glEnd();
// carrier 1 Wheels
for(l=0;l<50;l++)
{
glColor3f(0.35,0.16,0.14);
draw_circle(-25+i-xm,50,l);
draw_circle(225+i-xm,50,l);
}
//train base
glColor3f(0.196078,0.6,0.8);
glVertex2f(350+i-xm,50);
glEnd();
//train control chamber

glColor3f(1.0,0.25,0.0);
glEnd();
//window
glColor3f(1.0,1.0,1.0);
glEnd();
//train top
glColor3f(0.309804,0.184314,0.184314);
glEnd();
//tain engine
glColor3f(1.0,0.5,0.0);
glEnd();
glColor3f(0.0,0.0,0.0);
glEnd();
glColor3f(0.0,0.0,0.0);
glEnd();
glColor3f(0.0,0.0,0.0);
glEnd();
//tain smoke
glColor3f(0.196078,0.6,0.9);
glEnd();
glColor3f(0.309804,0.184314,0.184314);
glEnd();
//train head-light
glColor3f(1.0,1.0,0.0);
glEnd();
glColor3f(0.0,0.0,0.0);
glEnd();
// train connector
glColor3f(0.309804,0.184314,0.184314);
glEnd();
//train wheels
for(l=0;l<50;l++)
{
glColor3f(0.35,0.16,0.14);
}
}
//Railway Station Board
glColor3f(0.5,0.5,0.5);
glEnd();
glColor3f(0.5,0.5,0.5);
glEnd();
glColor3f(0.435294,0.258824,0.258824);
glEnd();
glColor3f(1.0,1.0,1.0);
glRasterPos2f(570,520);
declare("RAILWAY STATION");
glFlush();
}
void myinit()
{
glClearColor(1.0,1.0,1.0,1.0);
glColor3f(0.0,0.0,1.0);
glPointSize(2.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0,1100.0,0.0,700.0);
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
draw_object();
traffic_light();
glFlush();
}
int main(int argc,char** argv)

{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(1100.0,700.0);
glutInitWindowPosition(0,0);
glutCreateWindow("Traffic Control");
glutDisplayFunc(display);
glutIdleFunc(idle);
glutMouseFunc(mouse);
myinit();
glutAddMenuEntry("Aeroplane",1);
glutAddMenuEntry("Comet",2);
glutAttachMenu(GLUT_RIGHT_BUTTON);
glutMainLoop();
return 0;
}
SNAPSHOTS
CONCLUSION
This project is well suited for designing 2D objects, as well as for carrying basic graphics
functionalities like drawing a simple line, creating polygon, circle, making clouds, trees, railway track,
train coaches along with engine. However, if implemented on large scale with sufficient resources, it
has potential to become stand-alone GUI based application for Windows Operating System.
Out of many features available, the project demonstrates some popular and commonly used features
of OpenGL such as Rendering, Transformation, Rotation, Scaling, etc. These graphic functions will
also work in tandem with various rules involved in the game. Since the project works on dynamic
values, it can be used for future enhancements.
The project enabled to work with mid-level OpenGL complexity and the project demonstrates the
scope of OpenGL platform as a premier game developing launch pad. Hence, it has indeed been useful
in developing many games. OpenGL is good for low cost and simple game development. It serves as
an important stepping stone for venturing into other fields of Computer Graphics design and
applications.
FUTURE ENHANCEMENT
In any system there is always a chance for its enhancement and extensions, in this project many
enhancements could be done, like running train can controlled or signaled using the traffic light, the
railway station, ticket checkers and people could be added to provide a real look, train announcement
could be developed that in real railway station does have. Trees planted can be added because it adds
an attractive look, the glowing sun can add, day and night feature through menu can be developed,
birds can added flying in the sky which would make more realistic and attractive,
The inside view of railway could be created like in real railway station has, the food court, luggage
room, waiting area, Lounges, more tracks and platforms can be added. Display system could be added
to display the trains arrival and departure along with it should display if the train is running late by a
specified time.
REFERENCES
1. Developing Simple Games, Osama Hosam Eldeen, Lab Lambert Publication, 2016.
2. Computer Graphics, Donald Hern and M. Pauline Baker, Prentice-Hall Publishers, 1994.
3. Computer Graphics, Zhigang and Roy plastock, MCGRAW Hill Education, 2015.
4. Computer Graphics, A.P. Godse, Reftix Publishers, 2006.
5. OpenGL Superbible, Richard Wright, Graham Publishers, 2015.

Graphics Mini Project Report 1

Uploaded by

Document Information

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

Graphics Mini Project Report 1

Uploaded by

Copyright:

Available Formats

MINI PROJECT

RAILWAY STATION WITH MOVING TRAIN

Lovely Professional University

Applications of Computer Graphics

• Computer Art – MS Paint.

• Presentation Graphics – It is used to summarize financial statistical scientific or economic

• Entertainment- It is used in motion pictures, music videos, television gaming.

• Education and training- It is used to understand the operations of complex systems. It is

Open Graphics Library (OpenGL) is a cross-language (language independent), cross-platform

• Implementation: Mesa 3D is an open-source implementation of OpenGL. It can do pure

1. Industry Standard: OpenGL specification is guided by an independent consortium, the OpenGL

Software: Dev C++, OpenGL Library Functions, Windows 7 or 8 Operating system.

void declare(char *string)

void draw_pixel(GLint cx, GLint cy)

void plotpixels(GLint h,GLint k, GLint x,GLint y)

void draw_circle(GLint h, GLint k, GLint r)

//train control chamber

int main(int argc,char** argv)

You might also like