Report Finalex

Graphics Editor
1.Introduction
1.1 General Introduction
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 pictorial data rapidly and efficiently. Interactive computer graphics is the most
important means of producing pictures since the invention of photography and television. It
has the added advantage that, with the computer, we can make pictures not only of concrete
real world objects but also of abstract, synthetic objects, such as mathematical surfaces and
of data that have no inherent geometry, such as survey results.
Using this editor you can draw and paint using the mouse. It can also perform a host
of other functions like drawing lines, circles, polygons and so on. Interactive picture
construction techniques such as basic positioning methods, rubber-band methods are used.
Block operations like cut, copy and paste are supported to edit large areas of the workspace
simultaneously. It is user friendly and intuitive to use.
Graphics Editors can normally be classified as:
 2D Graphics Editors.
 3D Graphics Editors.
A 2D Graphics Editor is used to draw 2D primitives (Line, Rectangle, Circle,

Ellipse, etc. and alter those with operations like cut, copy and paste. These may also support
features like layers and object precision etc. A simple 2D Graphics Editor should include the
following features:
 Facilities: Cursor Movement, Editing picture objects
 Good User Interface: GUI / Toolbars / Icon based User Interface.
Dept of CSE,REC,hulkoti 1
Graphics Editor
A 3D Graphics Editor refers to program used to create 3D computer-generated

imagery. There are typically many stages in the "pipeline" that studios use to create 3D
objects for film and games. Many 3D modelers are general-purpose and can be used to
produce models of various real-world entities, from plants to automobiles to people. Some
are specially designed to model certain objects, such as chemical compounds or internal
organs.
3D modelers are used in a wide variety of industries. The movie industry uses them to create
and manipulate characters and objects for animated and real-life motion pictures. The video
game industry uses them to create assets for video games. The science sector uses them to
create highly detailed models of chemical compounds. The architecture industry uses them to
create models of proposed buildings and landscapes. The engineering community uses them
to design new devices, vehicles and structures as well as a host of other uses.
1.2 What Is OpenGL?
OpenGL is strictly defined as “a software interface to graphics hardware.” In essence, it is a

3D graphics and modeling library that is highly portable and very fast. Using OpenGL,
you can create elegant and beautiful 3D graphics with exceptional visual quality. The greatest
advantage to using OpenGL is that it is orders of magnitude faster than a raytracer or
software rendering engine. Initially, it used algorithms carefully developed and optimized by
Silicon Graphics, Inc. (SGI), an acknowledged world leader in computer graphics and
animation. Over time, OpenGL has evolved as other vendors have contributed their expertise
and intellectual property to develop high-performance implementations of their own.
OpenGL is not a programming language like C or C++. It is more like the C runtime
library, which provides some prepackaged functionality.
OpenGL is intended for use with computer hardware that is designed and optimized for the
display and manipulation of 3D graphics. Software-only implementations of OpenGL are
also possible. However, using a software implementation means that your program can
potentially run on a wider variety of computer
systems that may not have a 3D accelerated graphics card installed.
Dept of CSE,REC,hulkoti 2 2
Graphics Editor
OpenGL is used for various purposes, from CAD engineering and architectural
applications to modeling programs used to create computer-generated monsters in
blockbuster movies. The introduction of an industry-standard 3D API to mass-market
operating systems such as Microsoft Windows and the Macintosh OS X has some exciting
repercussions. With hardware acceleration and fast PC microprocessors becoming
commonplace, 3D graphics are now typical components of consumer and business
applications, not only of games and scientific applications.
1.3 Problem Statement

The objective is to build a graphics editor having all required operations that a normal
graphics editor should offer. The coding is implemented for a single canvas graphics editor.
In this editor importance is given to a simple user interface and implementation of all basic
graphic routines and basic graphic editing options.
The basic requirements of the graphics editor were analysed to be:
1. User Interface- The presentation of the graphics editor is crucial to its acceptance by
its users. The package should provide easy selection and implementation of the
features through iconic interfaces.
2. Color Selection - To select a suitable color for drawing the primitives. The editor
implements support for drawing various shapes mentioned above.
3. Graphics Drawing – To draw basic primitives like line, circle, rectangle on the
canvas and to use tools like pencil, colour filling, eraser, etc. to manipulate the image.
 Line: line is drawn by selecting two points start point and the end point. The
start point begins with mouse click and end point is the point where mouse
button is released.
 Circle: Circle is drawn by selecting a point and dragging thereafter till the
desired radius.
 Text: selecting the text icon and thereafter entering the text from keyboard
 Rectangle: rectangle is drawn by selecting a start point and dragging to end
point of required size.
Graphics Editor
 Freehand Drawing: a freehand drawing is the one in which wherever mouse

is dragged pixels are plotted
Other features:
 Fill Shapes: this is done by selecting a co-ordinate by click of mouse and the
enclosed area of the point is filled with the selected color.
 Eraser: this feature allows deleting particular portions of figure as selected by
click of the user.
 Dialog boxes: Dialog boxes and menus add user friendliness to the package.
1.4 Project Goal
The aim of this project is to develop a 2-D graphics package which supports basic
operations which include creating objects like lines, circles, polygons, etc. The package must
also have a user-friendly interface that may be menu-oriented, iconic or a combination of
both.
1.5 Scope
It provides most the features that a 2D graphic editor should have. It is developed in
VC++. it has been implemented by using openGL APIs. The 2-D graphics package designed
here provides an interface for the users for handling the display and manipulation of basic
picture objects like point, line, rectangle, polygon, etc. It also provides various features like
colour filling, erasing, etc. The interface is user -friendly with icons for all the functions. The
mouse is the main input device used.
Graphics Editor
Graphics Editor
2.Literature Survey
Computer graphics is the creation and manipulation of pictures with the aid of computers. It
is divided into two broad classes:
 Non-Interactive Graphics.
 Interactive Graphics.
Non-Interactive graphics
This is a type of graphics where observer has no control over the pictures produced
on the screen. It is also called as Passive graphics.
Interactive Graphics
This is the type of computer graphics in which the user can control the pictures
produced. It involves two-way communication between user and computer. The computer
upon receiving signal from the input device can modify the displayed picture appropriately.
To the user it appears that the picture changes instantaneously in response to his commands.
2.1 Icon Interface
An icon is a pictorial representation of an object, an action or a property. The user-
interface designer often has the choice of using icons to represent such concepts. Here icons
have been used for feature selection.
Dept of CSE,REC,hulkoti 6
Graphics Editor
3.Software Requirement Specifications
3.1 Introduction
3.1.1 Product Perspective:

This is a graphics editor that enables the user to input graphical data. Using the editor,
the user can also save the information input by him/her into files or open existing files for
editing. This editor provides a graphical user-friendly interface to create and edit the files. In
keeping with the low-end users, help files have been provided for each of the actions.
3.1.2 Product Functions:

As mentioned previously, the main objective of the editor is to help the user to input
graphical data and edit it conveniently. For ease in input and to help the user to traverse
through the text easily, the editor provides functionality through the mouse.
3.1.3 User Characteristics:

The editor provides a very easy-to-use interface and does not expect any extra
technical knowledge from the user. A basic understanding of all the options provided in the
editor would facilitate him in using the editor to the best possible extent. Since it is a mouse-
driven interface if is sufficiently easy for any kind of end user to run it.
3.2 General Description
3.2.1 General Constraints:

 The software is being built on the concept of interaction with windows, efficient use
of the memory is very important.
 As the software needs to be run even on low-end machines the code should he
efficient and optimal with the minimal redundancies.
 Needless to say, the editor should also be robust and fast.
 It is assumed that the standard output device, namely the monitor, supports colors.
Graphics Editor
3.2.2 Assumptions and Dependencies:

 The user's system is required to have the VC++ compiler of the appropriate version.
 The system is also expected to have a mouse connected since most of the drawing and
other graphical operations implemented assume the presence of a mouse.
3.3 Software Requirements

The editor has been implemented by using the glut library for interfacing with
window system and mainly requires an appropriate version of the compiler to be installed
and functional. Though it has been implemented by using VC++, it is pretty much platform
independent with the restriction that there is support for the execution of CPP files.
Operating System : Windows 2000 | XP|Vista
Complier : Microsoft® Visual Studios Visual C++ compiler
3.4 Hardware Requirements

The standard output device is assumed to be a color monitor. It is quite essential for
any graphics package to have this, as provision of color options to the user is a must. The
mouse, the main input device, has to be functional. A keyboard is also required.
Apart from these hardware requirements, there should be sufficient hard disk space and
primary memory available for proper working of the package.
Processor : Pentium III or higher
RAM : 128MB or more.
Graphics Editor
System Design
4.1 System Architecture

Design process involves design of algorithms, modules, components and subsystems.
The implementation can be divided into 3 parts.
1. Mouse interface implementation
2. Primitive algorithms implementation
3. Integration and other features
4.1.1. Mouse interface:
OpenGL provides APIs for mouse interface, where we can accept commands or
instructions by selecting appropriate mouse buttons. It also provides necessary features which
would give us the x and y coordinates of mouse pointer position on the canvas.
4.2 Primitive algorithms:

There are many primitive algorithms that are available for drawing various primitives. The
list of primitives implemented is:
 Rectangle
 Line
 Freehand
 Polygon and closed figure
 Eraser
 Text insertion
 Circle draw
Various algorithms have been used in this editor to provide the functionalities it boasts of.
Few of them have been explained here.
4.2.1Bresenham's Line and circle :
Graphics Editor
This is the most important algorithm used here in this editor. This is an accurate and efficient
raster line-generating algorithm that scans converts line using only incremental integer
calculations that is adapted here to display lines. The algorithm can be suitably adapted for
drawing circles and other curves.
4.2.2Free- hand Drawing:
Free- hand drawing is a special case of polyline drawing where we have a large number of
points obtained by continuously poling the mouse position during the time the mouse' left
button is clicked.
4.3Design Techniques
The various techniques that are implemented in this projects are as given below.
4.3.1Rubber-Banding Technique
One way to construct a line is to have the user indicate one endpoint and then the
other, once the second endpoint is specified, a line is drawn between the two points. With
this technique however the user has no easy way to try out different line positions before
settling on a final one, because the line is not actually drawn until the second endpoint is
given. A far superior approach is Rubber-Banding. When the user clicks the mouse button,
the starting position of the line is established by the cursor. As the cursor moves, so does the
endpoint of the line. When the button is released, the endpoint is frozen. The rubber-band is
active only when the mouse button is held down. It is in this state that cursor movements
cause the current line to change. An entire genre of interaction techniques is derived from
rubber-banding line drawing. The same concept can be extended to rectangle, circle, ellipse
or polygon drawing.
Graphics Editor
4.1: Rubber Banding Technique
4.3.2 Mid-Point Circle Algorithm For Circle Drawing

Given the integer center point and radius, it generates the optimal set of pixels for the
circles. We consider only 45 degrees of a circle, the second octant from x=0 to
x=y=R/root(2) and use CirclePoints to display points on the entire circle. The strategy is to
select which of the 2 pixels is closer to the circle by evaluating a function at the midpoint
between the 2 pixels.
Void MidpointCircle( int radius, int value )
{
int x = 0 ,y= radius, d = 1 – radius ;
int deltaE = 3 , deltaSE = -2 * radius + 5;
Circlepoints( x, y, value );
While( y > x ) {
If( d < 0 ) { /* Select E */
d + = deltaE ;
deltaE + = 2 ;
deltaSE + = 2 ;
}
else { /* Select SE */
d + = deltaSE ;
deltaE + = 2 ;
deltaSE + = 4 ;
y--;
}
x++;
Graphics Editor
CirclePoints( x, y, value );
}
}
4.1.3. Integration:
All the fore-mentioned units are integrated to completely give us the graphics
editor.
5.Detailed Design
5.1: Working Of The Graphics Package
This design stage involves the actual building of the core components of the different
functions, which are involved in the graphics editor. The design can be sub-divided as
follows
 Design of User Interface

 Design of Graphic primitive functions
Graphics Editor
The design is done mainly using glut library functions or APIs. The design of the
User Interface is done in such a way that it is based on simple iconic interfaces with
toolboxes for various operations, drawing primitive selection, color selection and fill pattern
selection.
5.1 Main Algorithm:
The main algorithm for the graphics editor is the one shown below.
1. Initiate the graphics mode and the graphics driver.
2. Initiate the mouse drivers and keyboard drivers.
3. Draw the toolbar icons, menus, and the main window.
4. Repeat the following steps until the user wants to exit
4.1 Check if left button of the mouse is clicked.
4.2 If so then
4.2.1 Check to see if mouse is on one of the buttons on
Tool bar. If so execute the function associated with
that button.
4.2.2 Else check to see if the mouse is on the color palette.
If so then change the present color to the selected
color.
4.2.3 Else check to see if mouse is on the drawing area. If
so carry on with the operation previously being
executed.
5. Close the graphics mode and restore back the CRT mode.
Graphics Editor
As we see above, the main algorithm is an infinite loop continuously polling for
mouse movements. Whenever the mouse is clicked, the position of the mouse is checked and
depending on the position of the mouse the appropriate operation is executed. The loop is
exited when the user wants to quit the editor.
6.Implementation
6.1 Working With The Window System
6.1.1 glutInit
glutInit is used to initialize the GLUT library.
Usage
void glutInit(int *argcp, char **argv);
argcp A pointer to the program’s unmodified argc variable from main. Upon return, the value
pointed to by argcp will be updated, because glutInit extracts any command line options
intended for the GLUT library. argv The program’s unmodified argv variable from main.
Like argcp, the data for argv will be updated because glutInit extracts any command line
options understood by the GLUT library.
Description
glutInit will initialize the GLUT library and negotiate a session with the window
system. During this process, glutInit may cause the termination of the GLUT program with
an error message to the user if GLUT cannot be properly initialized. Examples of this
situation include the failure to connect to the window system, the lack of window system
support for OpenGL, and invalid command line options. glutInit also processes command
line options, but the specific options parse are window system dependent.
6.1.2 glutInitWindowPosition, glutInitWindowSize
Graphics Editor
glutInitWindowPositionand glutInitWindowSizeset the initialwindow position and

size respectively.
Usage
void glutInitWindowSize(int width, int height);
void glutInitWindowPosition(int x, int y);
width Width in pixels.
height Height in pixels.
x Window X location in pixels.
y Window Y location in pixels.
Description
Windows created by glutCreateWindow will be requested to be created with the
current initial windowposition and size. The initial value of the initial window position
GLUT state is -1 and -1. If either the X or Y component tothe initial window position is
negative, the actual window position is left to the window system to determine.
6.1.3 glutInitDisplayMode
glutInitDisplayMode sets the initial display mode.
Usage
void glutInitDisplayMode(unsigned int mode);
mode Display mode, normally the bitwise OR-ing of GLUT display mode bit masks. See
values below:
GLUT RGBA Bit mask to select an RGBA mode window. This is the default if neither
GLUT RGBA nor
GLUT INDEX are specified.
GLUT RGB An alias for GLUT RGBA.
GLUT SINGLE Bit mask to select a single buffered window. This is the default if neither
GLUT DOUBLE or
GLUT SINGLE are specified.
Graphics Editor
GLUT DOUBLE Bit mask to select a double buffered window. This overrides GLUT
SINGLE if it is also specified.
GLUT DEPTH Bit mask to select a window with a depth buffer
6.1.4 void glFlush()

Forces any buffered OpenGL command to execute.
6.1.5 void glViewport(int x,int y,GLsizei width,GLsizei height)

Specifiesa width*height viewport in pixels whose lower-left corner is at(x,y)
measured from the origin of the window.
6.1.6 void glutMainLoop()

Cause the program to enter an event-processing loop. It should be the last statement
in main.
6.1.7 void glutDisplayFunc(void (*func)(void))

Registersthe display function func that is executed when the window needs to be
redrawn.
6.1.8 void glutPostRedisplay()

Requests that the display callback be executed after the current callback returns.
6.2 Specifying Simple Geometry
6.2.1 void glVertex[234][sifd](TYPE xcoordinate,TYPE ycoordinate,…)

void glVertex[234][sifd](TYPE *coordinate)
Graphics Editor
Specifies the position of a vertex in 2,3or 4 dimensions. The coordinates can be

specified as shorts s, ints i, floats f, or doubles d. If the v is present , the argument is a pointer
to an array containing the coordinates.
6.2.2 void glBegin(glEnum mode)
Initiates a new primitive of type mode and starts the collection of vertices. Values of
mode include GL_POINTS, GL_LINES, GL_POLYGON, GL_LINE_LOOP,
GL_TRIANGLES.
6.2.3 void glEnd()

Terminates the list of vertices.
6.3 Input Device and Interaction
6.3.1 Menu
GLUT supports simple cascading pop-up menus. They are designed to let a user
select various modes within a program. The functionality is simple and minimalistic and is
meant to be that way. Do not mistake GLUT's pop-up menu facility with an attempt to create
a full-featured user interface. It is illegal to create or destroy menus, or change, add, or
remove menu items while a menu (and any cascaded sub-menus) are in use (that is, popped
up).
The popup menus can be arranged in a hierachy of menus, sub-menus, sub-sub-menus, and
so on. Since a sub-menu identifier must be passed as an argument to the GLUT functions that
create the parent menu, the menu must be created from the bottom up. For example, assume
we want to create a main menu with entries Option A or Submenu1, where the sub-menu has
entries of Options B, C, or Submenu2, where the sub-sub-menu has Options D and E.
Graphics Editor
Submenu identifiers must be declared for each of our menu entries. This is a unique
integer value will be assigned as the menus are called by glutCreateMenu(). Start with the
lowest level menu and pass as an argument the callback function, menuCB, which defines
menu selection options. To create the lowest level menu and its entries:
int sub2 = glutCreateMenu(menuCB);

glutAddMenuEntry("Option D", 4);
glutAddMenuEntry("Option E", 5);
Then go up one more level and do the same thing for Submenu1:
sub1 = glutCreateMenu(menuCB);
glutAddMenuEntry("Option B", 2);
glutAddMenuEntry("Option C", 3);
glutAddSubMenu("SubMenu2", sub2);
Finally, we need to go the same thing for the highest level menu:
glutCreateMenu(menuCB);
glutAddMenuEntry("Option A", 1);
glutAddSubMenu("SubMenu1", sub1);
glutAddMenuEntry("Quit", 6)
These menu options can now be used in the callback function menuCB to process the users
menu choice.
void menuCB(int item)
{
switch (item) {
case 1:
/ do whatever option A does
break;
case 2:
/ do whatever option B does
Graphics Editor
6.3.2Mouse
glutMouseFunc
glutMouseFunc sets the mouse callback for the current window.
Usage
void glutMouseFunc(void (*func)(int button, int state,
int x, int y));
func The new mouse callback function.
Description
glutMouseFunc sets the mouse callback for the current window. When a user presses
and releases mouse buttons in the window, each press and each release generates a mouse
callback.
The button parameter is one of GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON,
or GLUT_RIGHT_BUTTON. For systems with only two mouse buttons, it may not be
possible to generate GLUT_MIDDLE_BUTTON callback. For systems with a single
mouse button, it may be possible to generate only a GLUT LEFT BUTTON callback. The
state parameter is either GLUT UP or GLUT DOWN indicating whether the callback was
due to a release or press respectively. Thex and y callback parameters indicate the window
relative coordinates when the mouse button state changed.
If a GLUT DOWN callback for a specific button is triggered, the program can assume
a GLUT UP callback for the same buttonwill be generated (assuming the window still has a
mouse callback registered) when the mouse button is released even if the mouse has moved
outside the window.
If a menu is attached to a button for a window, mouse callbacks will not be generated
for that button. when the mouse event generating the callback occurred.
Passing NULL to glutMouseFunc disables the generation of mouse callbacks.
Graphics Editor
6.3.3glutMotionFunc
glutMotionFunc set the motion callbacks respectively
for the current window.
Usage
void glutMotionFunc(void (*func)(int x, int y));
Description
glutMotionFunc set the motion callback for the current window. The motion callback
for a window is called when the mouse moves within the window while one or more mouse
buttons are pressed. The x and y callback parameters indicate the mouse location in window
relative coordinates.
Passing NULL to glutMotionFunc or glutPassiveMotionFunc disables the generation of the
mouse motion callback.

6.3.4Keyboard
glutKeyboardFunc
glutKeyboardFunc sets the keyboard callback for the current window.
Usage
void glutKeyboardFunc(void (*func)(unsigned char key,
int x, int y));
22 7. CALLBACK REGISTRATION
func The new keyboard callback function.
Description
glutKeyboardFunc sets the keyboard callback for the current window. When a user
types into the window, each key press generating an ASCII character will generate a
keyboard callback. The key callback parameter is the generated ASCII character. The state of
modifier keys such as Shift cannot be determined directly; their only effect will be on the
returned ASCII data.
The x and y callback parameters indicate the mouse location in
Graphics Editor
window relative coordinateswhen the key was pressed. When a new window is created, no
keyboard callback is initially registered, and ASCII key strokes in thewindow are ignored.
Passing NULL to glutKeyboardFunc disables the generation of keyboard callbacks.
6.3.5 glutReshapeFunc
glutReshapeFunc sets the reshape callback for the current window.

Usage
void glutReshapeFunc(void (*func)(int width, int height));
func The new reshape callback function.
Description
glutReshapeFunc sets the reshape callback for the current window. The reshape
callback is triggered when a window is reshaped. A reshape callback is also triggered
immediately before a window’s first display callback after a window is created or whenever
an overlay for the window is established. The width and heightparameters of the callback
specify the new window size in pixels. Before the callback, the current window is
set to the window that has been reshaped.
If a reshape callback is not registered for awindow or NULL is passed toglutReshapeFunc(to
deregister a previously registered callback), the default reshape callback is used. This default
callback will simply call glviewport(0,0,width,height) on the normal plane (and on the
overlay if one exists). If an overlay is established for thewindow, a single reshape callback
is generated. It is the callback’s responsibility to update both the normal plane and overlay
for the window (changing the layer in use as necessary).
6.4 Transformations
6.4.1 void glMatrixMode(GLenum mode)
Graphics Editor
Specifies which matrix will be affected by subsequent transformations. Mode can be

GL_MODELVIEW, GL_PROJECTION or GL_TEXTURE.
6.4.2 void glLoadIdentity()
Sets the current transformation matrix to an identity matrix.
6.4.3 void glPushMatrix()

void glPopMatrix()
Pushes to and pops from the matrix stack corresponding to the current matrix mode.
7. SNAPSHOTS
This section gives us an overview of various functions that have been implemented and their
respective representation on the output screen .The various functions are explained along
with the illustration of using it is as shown below.
A basic output of the editor before implementing any of the tools and the function used to
implement it is as shown below.
Graphics Editor
Snapshot of Graphics Editor(Default Output screen).
Graphics Editor
Snapshot of Graphics editor(using various functions).
Graphics Editor
8.Testing and Results
Functionality Completed Comments

Mouse Pointer Yes It shows the position of the Mouse
Pointer in the status bar at the
bottom of the screen
Geometrical Shapes Yes It supports Geometrical Shapes such

as straight Line, Circle, square,
triangle and Rectangle.
Colors & Patterns Yes It supports a range of Colors and

Patterns choose from.
Other Features Yes It supports other features like colour

fill, Eraser, Free Hand Drawing and
Text-Typing.
Table 7.1: Results
Graphics Editor
Conclusion And Future Enhancements
This graphics editor is very user friendly tool. The user can very easily use this tool to draw
or manipulate a drawing. The interface is mouse driven and the user can select a function by
clicking on an icon representing that function.
For the user’s help the function performed by each icon is displayed in the status bar
as soon as the mouse pointer moves over the icon. We have tried our best to make this editor
very realistic, so that the user does not face any trouble when switching over from any real
life graphics editor to this highly useful one.
The following are some of the features that are planned to be supported in the future versions
of the graphics editor.
 Features like "Undo" and "Redo " could be provided.
 The editor can be made to save images in standard image file formats such as bmp,
jpeg, gif. Therefore Support for different file formats like bmp, jpeg, gif etc. could be
provided.
 Support for advanced 3d drawings and transformations.
 Only Single Document Interface (SDI) has been provided, multiple document
interface can be provided.
Graphics Editor
Bibliography
[1].Edward Angel: ”Interactive Computer Graphics A Top-Down Approach with OpenGL”,

5th Edition, Pearson Education ,Addison-Wesley,2008.
[2].F.S. Hill, Jr.: “Computer Graphics Using OpenGL”, 2nd Edition, Pearson Education,2001.
[3]. James D Foley, Andries Van Dam, Steven K Feiner, John F Huges,
”Computer Graphics”, Addison-Wesley 1997.
[4]. Donald hearn and Pauline Baker: Computer Graphics-OpenGL Version ,2nd Edition
[5]. Yashavant Kanetkar, “Let us C++”, BPB Publications (1991)

[6]. www.wikipedia.org.

Report Finalex

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

Report Finalex

Uploaded by

Copyright:

Available Formats

Graphics Editor

1.1 General Introduction

A 2D Graphics Editor is used to draw 2D primitives (Line, Rectangle, Circle,

A 3D Graphics Editor refers to program used to create 3D computer-generated

1.2 What Is OpenGL?

OpenGL is strictly defined as “a software interface to graphics hardware.” In essence, it is a

1.3 Problem Statement

 Freehand Drawing: a freehand drawing is the one in which wherever mouse

1.4 Project Goal

3.Software Requirement Specifications

3.1.1 Product Perspective:

3.1.2 Product Functions:

3.1.3 User Characteristics:

3.2 General Description

3.2.1 General Constraints:

3.2.2 Assumptions and Dependencies:

3.3 Software Requirements

3.4 Hardware Requirements

4.1 System Architecture

4.2 Primitive algorithms:

4.2.1Bresenham's Line and circle :

4.2.2Free- hand Drawing:

4.1: Rubber Banding Technique

4.3.2 Mid-Point Circle Algorithm For Circle Drawing

5.1: Working Of The Graphics Package

 Design of User Interface

5.1 Main Algorithm:

1. Initiate the graphics mode and the graphics driver.

2. Initiate the mouse drivers and keyboard drivers.

3. Draw the toolbar icons, menus, and the main window.

4. Repeat the following steps until the user wants to exit

4.1 Check if left button of the mouse is clicked.

4.2.1 Check to see if mouse is on one of the buttons on

Tool bar. If so execute the function associated with

4.2.2 Else check to see if the mouse is on the color palette.

If so then change the present color to the selected

4.2.3 Else check to see if mouse is on the drawing area. If

so carry on with the operation previously being

6.1.2 glutInitWindowPosition, glutInitWindowSize

glutInitWindowPositionand glutInitWindowSizeset the initialwindow position and

6.1.4 void glFlush()

6.1.5 void glViewport(int x,int y,GLsizei width,GLsizei height)

6.1.6 void glutMainLoop()

6.1.7 void glutDisplayFunc(void (*func)(void))

6.1.8 void glutPostRedisplay()

6.2 Specifying Simple Geometry

6.2.1 void glVertex[234][sifd](TYPE xcoordinate,TYPE ycoordinate,…)

Specifies the position of a vertex in 2,3or 4 dimensions. The coordinates can be

6.2.2 void glBegin(glEnum mode)

6.2.3 void glEnd()

6.3 Input Device and Interaction

int sub2 = glutCreateMenu(menuCB);

glutMouseFunc sets the mouse callback for the current window.

glutReshapeFunc sets the reshape callback for the current window.

6.4.1 void glMatrixMode(GLenum mode)

Specifies which matrix will be affected by subsequent transformations. Mode can be

6.4.2 void glLoadIdentity()

Sets the current transformation matrix to an identity matrix.

6.4.3 void glPushMatrix()

Snapshot of Graphics Editor(Default Output screen).

Snapshot of Graphics editor(using various functions).

8.Testing and Results

Functionality Completed Comments