Professional Documents
Culture Documents
CG Report
CG Report
We sincerely owe our gratitude to all the persons who helped and guided us in
completing this mini project work.
We are thankful to Dr. Archana N V, Principal, NIEIT Mysuru, for having supported
us in our academic endeavors.
Lastly, we thank almighty, our parents and friends for their constant encouragement
without which this mini project would not be possible.
Yours sincerely,
2. Requirement satisfactions 6
3.1 Overview 8
3.2 Objective 10
3.4 Benefits 10
4. System Design 11
4.1 Documentation 11
5. Implementation 13
6. Testing 15
7. Snapshots 17
8. Conclusion 20
9. Bibliography 21
CLIENT SERVER DATA COMMUNICATION 2023-24
CHAPTER 1
INTRODUCTION
First Come First Serve Algorithm is OS based Computer graphics Project. This
Project as name suggest demonstrate 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 Code::Blocks IDE on Windows 10 operating system with OpenGL
package.
Computer graphics started with the display of data on hard copy plotters and
cathode ray tube screens soon after the introduction of computers themselves. It has grown
to include the creation, storage, and manipulation of models and images of objects. These
models come from a diverse and expanding set of fields, and include physical,
mathematical, engineering, architectural, and even conceptual structures, natural
phenomena, and so on. Computer graphics today is largely interactive. The user controls
the contents, structure, and appearance of the objects and of their displayed images by using
input devices, such as keyboard, mouse, or touch-screen. Due to close relationships
between the input devices and the display, the handling of such devices is included in the
study of computer graphics. The advantages of the interactive graphics are many in number.
Graphics provides one of the most natural means of communicating with a computer, since
our highly developed 2D and 3D pattern-recognition abilities allow us to perceive and
process data rapidly and efficiently. In many design, implementation, and construction
page 1
processes today, the information pictures can give is virtually indispensable. Scientific
visualization became an important field in the 1980s when the scientists and engineers
realized that they could not interpret the prodigious quantities of data produced in
supercomputer runs without summarizing the data and highlighting trends and phenomena
in various kinds of graphical representations.
The following diagram details the OpenGL processing pipeline. For most of the
pipeline, you can see three vertical arrows between the major stages. These arrows represent
vertices and the two primary types of data that can be associated with vertices: color values
page 2
and texture coordinates. Also note that vertices are assembled into primitives, then into
fragments, and finally into pixels in the frame buffer. This progression is discussed in more
detail in Vertices, Primitives, Fragments and Pixels.
page 3
• It is a state machine. At any moment during the execution of a program there is a current
model transformation.
page 4
page 5
CHAPTER 2
SYSTEM REQUIREMENTS SPECIFICATIONS
2.1 Hardware Requirements
• Microprocessor: 1.0 GHz and above CPU based on either AMD or INTEL
Microprocessor Architecture.
GL/glut.h:
page 6
We use a readily available library called the OpenGL Utility Toolkit (GLUT), which
provides the minimum functionality that should be expected in any modern windowing
system. The application program uses only GLUT functions and can be recompiled with
the GLUT library for other window system. OpenGL makes a heavy use of macros to
increase code readability and avoid the use of magic numbers. In most implementation,
one of the include lines.
page 7
CHAPTER 3
ABOUT THE PROJECT
Main aim of this project is to illustrate the concepts of working of a client-server in OpenGL.
The objects are drawn using the GLUT functions. This project has been developed using
Code::Blocks IDE on Windows 11 operating system with OpenGL package.
3.1 Overview
In this project, the focus is on developing a client-server application using the OpenGL
(Open Graphics Library) framework. The goal is to create a system where clients can connect
to a server and interact with a shared graphical environment. This project leverages the
capabilities of OpenGL to provide a rich and immersive visual experience for the clients.
The server application is responsible for managing the overall system and providing the
necessary infrastructure for clients to connect and interact. It handles client connections,
authentication, and session management. Additionally, the server coordinates the distribution of
graphical data to the clients, ensuring that each client receives the necessary updates to render
the shared environment accurately.
The client application focuses on rendering the shared graphical environment using OpenGL. It
communicates with the server to receive updates on the graphical state and handles user input to
interact with the scene. The client application leverages OpenGL's rendering capabilities to
display the graphical elements, including 3D models, textures, lighting effects, and animations.
User actions, such as moving objects, changing viewpoints, or manipulating the scene, are
transmitted to the server for processing and synchronization with other clients.
Client 1 makes use of TCP to transmit data to the server. Similar to HTTP, the client first sends a
client request to the server and the server responds with the server response. The Client, after
receiving the server response can again transmit the data (if any) to the server and similarly, the
server also can transmit the data to the client. Client request and response are demonstrated using
animating lines.
page 8
Client 2 makes use of UDP to transmit data to the server. In this case, there is no need of
handshaking. Instead, the data is directly pushed towards the server and vice versa. In UDP, there
is no method to detect packet loss. In this case datagram packet transmission is shown using
animating lines.
Client 3 and Client 4 demonstrate how data is transmitted among these 2 clients through the central
server. First one client (say client 3) uploads some data to the server (that is not present in the
server). If the same data is required by another client (say client 4), they download it from the
server itself.
page 9
3.3 Objective
Satellites are manmade objects put into orbit. They often affect our lives without our realizing
it: they make us safer, provide modern conveniences, and broadcast entertainment. Wireless
and mobile communication applications can be easily established by satellite communication
independent of location. Security in satellite transmission is usually provided by the coding and
decoding equipment. During critical condition, each Earth station may be removed relatively
quickly from a location and reinstalled somewhere else.
3.4 Benefits
Three main uses of satellites are:
a. Communications
b. Photography, Imaging, and Scientific Surveying
c. Navigation
Communication Satellites are "space mirrors" that can help us bounce radio, TV, Internet data,
and other kinds of information from one side of Earth to the other.
The information also helps public health officials track diseases, it helps farmers know what
crops to plant and it helps emergency workers respond to natural disasters.
page 10
CHAPTER 4
SYSTEM DESIGN
4.1 Documentation
• Purpose and Scope
This section provides a brief description of the Systems Design Document’s purpose
and scope.
• System Overview
This section describes the system in narrative form using non-technical terms. It should
provide a high-level system architecture diagram showing a subsystem breakout of the
system, if applicable. The high-level system architecture or subsystem diagrams should, if
applicable, show interfaces to external systems. Supply a high-level context diagram for the
system and subsystems, if applicable. Refer to the requirements trace ability matrix (RTM)
in the Functional Requirements Document (FRD), to identify the allocation of the functional
requirements into this design document.
• Design Constraints
This section describes any constraints in the system design (reference any trade-off
analyses conducted such, as resource use versus productivity, or conflicts with other
page 11
systems) and includes any assumptions made by the project team in developing the system
design.
• Future Contingencies
This section describes any contingencies that might arise in the design of the
system that may change the development direction. Possibilities include lack of
interface agreements with outside agencies or unstable architectures at the time this
document is produced. Address any possible workarounds or alternative plans.
• Document Organization
This program includes interaction with keyboard.
a) s/S – To Start the project.
b) t/T – To transmit and receive signals.
c) q/Q – Quit
page 12
CHAPTER 5
IMPLEMENTATION
5.1 User defined functions
• download(): This function is used for designing body and the solar panels of a
satellite.
• response(): This function set the constraints for the string to display on the screen
• draw(float radius): To design windows and main structure for this project.
• upload(): To represent a data, which travels from source to destination.
• Handshake1h(): To design Earth on another screen and calling the satellite() function.
CHAPTER 6
TESTING
Introduction to Testing
Verification and validation are a generic name given to checking processes, which ensures that the
software conforms to its specifications and meets the demands of users.
• Validation
Are we building the right product? Validation involves checking that the program has implanted
meets the requirement of the users.
• Verification
Verification involves checking that the program confirms to its specification.
• Module testing
A module is a collection of dependent components such as a function. A module encapsulates
related components so can test without other system modules.
• Sub-system Testing
This phase involves testing collection of modules, which have been integrated into sub- systems.
Sub-systems may be independently designed and implemented.
• System testing
The sub-systems are integrated to make up the entire system. The errors that result from
unanticipated interaction between sub-systems and system components are removed.
• Acceptance testing
This is the final stage in the testing process before the system is tested for operational
use. Any requirement problem or requirement definition problem revealed from
acceptance testing are considered and made error free.
• Test plan
Careful planning is needed to the most of testing and controlled testing cost.
Results
Several errors were detected and rectified and the whole project is working as it should have to
work with proper output and high efficiency.
CHAPTER 7
SNAPSHOTS
Sd
CHAPTER 8
CONCLUSION
In conclusion, this project focuses on developing a client-server application using the OpenGL
framework to create a shared graphical environment. The project leverages the power of OpenGL for
rendering high-quality graphics and provides a platform for real-time collaboration and interaction
among clients. By considering networking, security, and performance aspects, the project aims to deliver
a robust and visually appealing client-server system that can be applied to various domains, such as
multiplayer games, virtual reality environments, or collaborative design platforms.
FUTURE ENHANCEMENT
The future enhancement that can be made include:
▪ Cross-platform compatibility
CHAPTER 9
BIBLOGRAPHY
Books:
Computer Graphics – James D Foley, Andries Van Dam, Steven K Feiner, John F Hughes,
Addison-Wesley 1997.
Computer Graphics - OpenGL Version – Donald Hearn and Pauline Baker, 2nd Edition,
Pearson Education, 2003
https://opengl.org
https://stackoverflow.com
22