CG Lab Manual

Practical-1
Aim: Study of various C graphics functions

Software Required: Turbo C/C++ Compiler
Vishal
Shah
Digitally signed by
Vishal Shah
DN: cn=Vishal Shah
Date: 2012.07.16
21:48:31 +05'30'
Knowledge Required: Basic C/C++ language programming, Hardware Interrupt, Hex number format.
Theory/logic: initgraph ()
Syntax:- #include <graphics.h>
void initgraph(int *graphdriver, int *graphmode, char *pathtodriver);
Description:-initgraph initializes the graphics system by loading a graphics driver from disk (or
validating a registered driver), and putting the system into graphics mode.
To start the graphics system, first call the initgraph function. initgraph loads the graphics driver and puts
the system into graphics mode. You can tell initgraph to use a particular graphics driver and mode, or to
autodetect the attached video adapter at run time and pick the corresponding driver.
If you tell initgraph to autodetect, it calls detectgraph to select a graphics driver and mode. initgraph also
resets all graphics settings to their defaults (current position, palette, color, viewport, and so on) and resets
graphresult to 0.
Normally, initgraph loads a graphics driver by allocating memory for the driver (through _graphgetmem),
then loading the appropriate .BGI file from disk. As an alternative to this dynamic loading scheme, you
can link a graphics driver file (or several of them) directly into your executable program file.
pathtodriver specifies the directory path where initgraph looks for graphics drivers. initgraph first looks in
the path specified in pathtodriver, then (if they are not there) in the current directory. Accordingly, if
pathtodriver is null, the driver files (*.BGI) must be in the current directory. This is also the path
settextstyle searches for the stroked character font files (*.CHR).
*graphdriver is an integer that specifies the graphics driver to be used. You can give it a value using a
constant of the graphics_drivers enumeration type, which is defined in graphics.h and listed below.
Graphics Drivers Constant Numeric value
DETECT
0 (requests autodetect)
CGA
1
MCGA
2
EGA
3
EGA64
4
EGAMONO
5
IBM8514
6
HERCMONO
7
ATT400
8
VGA
9
PC3270
10
*graphmode is an integer that specifies the initial graphics mode (unless *graphdriver equals DETECT; in
which case, *graphmode is set by initgraph to the highest resolution available for the detected driver). You
can give *graphmode a value using a constant of the graphics_modes enumeration type, which is defined
in graphics.h and listed below.
graphdriver and graphmode must be set to valid values from the following tables, or you will get
unpredictable results. The exception is graphdriver = DETECT.
Palette listings C0, C1, C2, and C3 refer to the four predefined four-color palettes available on CGA (and
compatible) systems. You can select the background color (entry #0) in each of these palettes, but the
other colors are fixed.
Palette Number Three Colors
0
LIGHTGREEN LIGHTRED
YELLOW
1
LIGHTCYAN LIGHTMAGENTA WHITE
2
GREEN
RED
BROWN
3
CYAN
MAGENTA
LIGHTGRAY
After a call to initgraph, *graphdriver is set to the current graphics driver, and *graphmode is set to the
current graphics mode.
Graphics
Driver
CGA
Graphics
Mode
CGAC1
CGAC2
CGAC3
CGAHI
MCGA
EGA
EGA64
EGAMONO
HERC
Value Columns x Rows
Palette
Pages
1
2
3
4
320 x 200
320 x 200
320 x 200
640 x 200
C1
C2
C3
2 color
1
1
1
1
MCGAC0
MCGAC1
MCGAC2
MCGAC3
MCGAMED
MCGAHI
0
1
2
3
4
5
320 x 200
320 x 200
320 x 200
320 x 200
640 x 200
640 x 480
C0
C1
C2
C3
2 color
2 color
1
1
1
1
1
1
EGALO
EGAHI
EGA64LO
EGA64HI
0
1
0
1
640 x 200
640 x 350
640 x 200
640 x 350
16 color
16 color
16 color
4 color
EGAMONOHI 3
640 x 350
2 color
EGAMONOHI 3
640 x 350
2 color
4
2
1
1
1
w/64K
2
w/256K
HERCMONOHI 0
720 x 348
2 color
ATT400
ATT400C0
ATT400C1
ATT400C2
ATT400C3
ATT400MED
ATT400HI
0
1
2
3
4
5
320 x 200
320 x 200
320 x 200
320 x 200
640 x 200
640 x 400
C0
C1
C2
C3
2 color
2 color
1
1
1
1
1
1
VGA
VGALO
VGAMED
VGAHI
0
1
2
640 x 200
640 x 350
640 x 480
16 color
16 color
16 color
2
2
1
PC3270
PC3270HI
720 x 350
2 color
IBM8514HI
0
640 x 480
256 color
IBM8514LO
0
1024 x 768
256 color
Return Value: - initgraph always sets the internal error code; on success, it sets the code to 0. If an error
occurred, *graphdriver is set to -2, -3, -4, or -5, and graphresult returns the same value as listed below:
Constant Name Number Meaning
grNotDetected
-2
Cannot detect a graphics card
grFileNotFound -3
Cannot find driver file
grInvalidDriver
-4
Invalid driver
IBM8514
CIRCLE
Syntax: - Void circle (int x, int y, int radius);
Description: - Circle function takes X and Y values with respect to top left corner of the screen and third
argument is a radius of the circle.
Return Value: -None
Closegraph
Syntax: - void closegragh(void);
Description: - The closegraph() swithces back the screen from grpahics mode to text mode. If you dont
use this function then you may have undesirable effects.Here this function is called afer the getch()
function as screen shouldnt switch to text mode till user hits any key.
closegraph deallocates all memory allocated by the graphics system, then restores the screen to the mode
it was in before you called initgraph. (The graphics system deallocates memory, such as the drivers, fonts,
and an internal buffer, through a call to _graphfreemem.)
Return Value: -None.
Cleardevice
Syntax: - void cleardevice(void);
Description: -cleardevice erases (that is, fills with the current background color) the entire graphics
screen and moves the CP (current position) to home (0,0).
Return Value: -None
Ellipse
Syntax: - void ellipse(int x, int y, int stangle, int endangle, int xradius, int yradius);
Description: - ellipse draws an elliptical arc in the current drawing color with its center at (x,y) and the
horizontal and vertical axes given by xradius and yradius, respectively. The ellipse travels from stangle to
endangle. If stangle equals 0 and endangle equals 360, the call to ellipse draws a complete ellipse.
The angle for ellipse is reckoned counterclockwise, with 0 degrees at 3 o'clock, 90 degrees at 12 o'clock,
and so on. The linestyle parameter does not affect arcs, circles, ellipses, or pie slices. Only the thickness
parameter is used.
Return Value: -None
Fill-Ellipse
Syntax: - void fillellipse(int x, int y, int xradius, int yradius);
Description: -Draws an ellipse using (x,y) as a center point and xradius and yradius as the Horizontal and
vertical axes, and fills it with the current fill color and fill pattern.
Return Value: -None
Fillpoly
Syntax: - void fillpoly(int numpoints, int *polypoints);
Description: -fillpoly draws the outline of a polygon with numpoints points in the current line style and
color (just as drawpoly does), then fills the polygon using the current fill pattern and fill color. polypoints
points to a sequence of (numpoints * 2) integers. Each pair of integers gives the x- and y-coordinates of a
point on the polygon.
Return Value: -None
Getaspectratio
Syntax: - void getaspectratio(int *xasp, int *yasp);
Description: -The y aspect factor, *yasp, is normalized to 10,000. On all graphics adapters except the
VGA, *xasp (the x aspect factor) is less than *yasp because the pixels are taller than they are wide. On the
VGA, which has "square" pixels, *xasp equals *yasp. In general, the relationship between *yasp and
*xasp can be stated as *yasp = 10,000 *xasp <= 10,000 getaspectratio gets the values in *xasp & *yasp.
Return Value: -None
Getbkcolor
Syntax: - int getbkcolor(void);
Description: -getbkcolor returns the current background color. (See the table in setbkcolor for details.)
Return Value: - getbkcolor returns the current background color
Getcolor
Syntax: -int getcolor(void);
Description: - getcolor returns the current drawing color. The drawing color is the value to which pixels
are set when lines and so on are drawn. For example, in CGAC0 mode, the palette contains four colors:
the background color, light green, light red, and yellow. In this mode, if getcolor returns 1, the current
drawing color is light green.
Return Value: - getcolor returns the current drawing color
Getdrivername
Syntax: - char *getdrivername(void);
Description: - After a call to initgraph, getdrivername returns the name of the driver that is currently
loaded.
Return Value: - getdrivername returns a pointer to a string with the name of the currently loaded graphics
driver
Getgraphmode
Syntax: - int getgraphmode(void);
Description: -Your program must make a successful call to initgraph before calling getgraphmode. The
enumeration graphics_mode, defined in graphics.h, gives names for the predefined graphics modes. For a
table listing these enumeration values, refer to the description for initgraph.
Return Value: - getgraphmode returns the graphics mode set by initgraph or setgraphmode.
Getmaxx
Syntax: - int getmaxx(void);
Description: - getmaxx returns the maximum (screen-relative) x value for the current graphics driver and
mode. For example, on a CGA in 320*200 mode, getmaxx returns 319. getmaxx is invaluable for
centering, determining the boundaries of a region onscreen, and so on.
Return Value: - getmaxx returns the maximum x screen coordinate.
Getmaxy
Syntax: - int getmaxy(void);
Description: -getmaxy returns the maximum (screen-relative) y value for the current graphics driver and
mode. For example, on a CGA in 320*200 mode, getmaxy returns 199. getmaxy is invaluable for
centering, determining the boundaries of a region onscreen, and so on.
Return Value: - getmaxy returns the maximum y screen coordinate.
Getpixel
Syntax: -unsigned getpixel(int x, int y);
Description: - getpixel gets the color of the pixel located at (x,y).
Return Value: -getpixel returns the color of the given pixel.
Gety
Syntax: -int gety(void);
Description: -gety returns the current graphics position's y-coordinate. The value is viewport-relative.
Return Value: - gety returns the y-coordinate of the current position.
Line
Syntax: -void line(int x1, int y1, int x2, int y2);
Description: - line draws a line in the current color, using the current line style and thickness between the
two points specified, (x1,y1) and (x2,y2), without updating the current position (CP).
Return Value: -None
Linerel
Syntax: -void linerel(int dx, int dy);
Description: -linerel draws a line from the CP (current position) to a point that is a relative distance
(dx,dy) from the CP. The CP is advanced by (dx,dy).
Return Value: -None
Moverel
Syntax: - void moverel(int dx, int dy);
Description: - moverel moves the current position (CP) dx pixels in the x direction and dy pixels in the y
direction.
Return Value: -None
Moveto
Syntax: - void moveto(int x, int y);
Description: -moveto moves the current position (CP) to viewport position (x,y).
Return Value: -None
Outtext
Syntax: -void outtext(char *textstring);
Description: -outtext displays a text string in the viewport, using the current font, direction, and size.
outtext outputs textstring at the current position (CP). If the horizontal text justification is LEFT_TEXT
and the text direction is HORIZ_DIR, the CP's x-coordinate is advanced by textwidth(textstring).
Otherwise, the CP remains unchanged. To maintain code compatibility when using several fonts, use
textwidth and textheight to determine the dimensions of the string. If a string is printed with the default
font using outtext, any part of the string that extends outside the current viewport is truncated. outtext is
for use in graphics mode; it will not work in text mode.
Return Value: -None
Outtextxy
Syntax: - void outtextxy(int x, int y, char *textstring);
Description: -outtextxy displays a text string in the viewport at the given position (x, y), using the current
justification settings and the current font, direction, and size. To maintain code compatibility when using
several fonts, use textwidth and textheight to determine the dimensions of the string. If a string is printed
with the default font using outtext or outtextxy, any part of the string that extends outside the current
viewport is truncated. Outtextxy is for use in graphics mode; it will not work in text mode.
Return Value: -None
Putpixel
Syntax: -void putpixel(int x, int y, int color);
Description: -putpixel plots a point in the color defined by color at (x,y).
Return Value: - None
Rectangle
Syntax: -void rectangle(int left, int top, int right, int bottom);
Description: -rectangle draws a rectangle in the current line style, thickness, and drawing color. (left,top)
is the upper left corner of the rectangle, and (right,bottom) is its lower right corner.
Return Value: - None
Source Code:
/* 1. Program to show how to initialize graphics mode*/
#include<graphics.h>
#include<stdio.h>
#include<conio.h>
void main()
{
int gd=DETECT, gm;
initgraph(&gd, &gm, "c:\\turboc3\\tc\\bgi " );
circle(200,100,150);
getch();
closegraph();
}
/* 2. Program to show the use of various Graphics Library function */
#include<stdio.h>
#include<conio.h>
void main()
{
int gd=DETECT, gm;
int poly[12]={350,450, 350,410, 430,400, 350,350, 300,430, 350,450 };
initgraph(&gd, &gm, "c:\\turboc3\\tc\\bgi");
circle(100,100,50);
outtextxy(75,170, "Circle");
rectangle(200,50,350,150);
outtextxy(240, 170, "Rectangle");
ellipse(500, 100,0,360, 100,50);
outtextxy(480, 170, "Ellipse");
line(100,250,540,250);
outtextxy(300,260,"Line");
sector(150, 400, 30, 300, 100,50); outtextxy(120, 460, "Sector");
drawpoly(6, poly);outtextxy(340, 460, "Polygon");
getch();
closegraph();
}
Practical-2
Aim: Implementation and Using mouse in DOS
Knowledge Required: Basic C/C++ language programming, Hardware Interrupt, Hex number format
Theory/logic:
Introduction to Mouse Programming
There are many ways to access the mouse. Either using tool that are already equipped with mouse routine
or communicating with mouse driver or programming directly with the mouse. What this article is about is
using a method, which deals with mouse with the existence of the mouse driver. Mouse driver is a device
driver that assists the OS in determining what type of mouse is available to the OS.
What are Interrupts?
Interrupts are special functions, which is built in the BIOS (basic input output system). There are nearly
hundreds of interrupt in the BIOS and we are dealing with Interrupt 0x33 (mouse functions). Whenever an
interrupt is called, any task, which is in progress, will be interrupted to execute the requested task. This
interrupt is called by setting the appropriate register value, call the interrupt and output value will be set to
the same register. Either the programmer can look at the output value in the specified register to determine
the called interrupt is performed perfectly or error has occurred.
What are REGISTERS?
Register is a special memory placed in the microprocessor chip, i.e. the 8086, 80486 or Pentium Chip
for faster calculation. This memory location is used during calculation and other stuff. There are several
kind of register in the chip and what I am listing here is just the information enough for us to get to mouse
programming. The Intel 80x86 families and Pentium have the following registers in their chips.
General-purpose register: AX, BX, CX, DX which will be used widely in our program
AX (16 bits) is a combination of AH and AL (H-higher 8 bits, L-lower 8 bits). This combination is
also applicable to BX, CX, DX register
8 bits
8 bits
Names
AH
AL
Accumulator
BH
BL
Base
CH
CL
Counter
DH
DL
Data
Segment Register which in our consideration

16 bits
Names
ES
Extra Segment
CS
Code Segment
SS
Stack Segment
DS
Data Segment
Pointer Registers
16 bits
Names
SI
Source Index
DI
Destination Index
Basic Concept of Mouse Handling

First thing you must know how to tell a mouse to do anything. In actual we do not communicate with
mouse directly but through the driver provided. We use "Interrupts" to get access to this driver. Each
device provide by computer has its own port and more or less we access these ports.
Each device has a unique port which is a hexadecimal value and value is designed to be machine
independent enhancing portability of program.
Mouse has port 0X33 attached to it and similarly keyboard has attach port 0X60.
We make use of address registers. These are basically UNION of type REGS defined in "dos.h".
union REGS {
struct WORDREGS x;
struct BYTEREGS h;
};
BYTEREGS and WORDREGS
Structures for storing byte and word registers
struct WORDREGS {
unsigned int ax, bx, cx, dx;
unsigned int si, di, cflag, flags;
};
struct BYTEREGS {
unsigned char al, ah, bl, bh;
unsigned char cl, ch, dl, dh;
};
We use two registers to communicate to a device driver one for input and one for output.
The union REGS is used to pass information to and from these functions:
int86 int86x intdos intdosx
To do mouse programming you must include <dos.h>. We use a function called int86() to access
"interupts".
Declaration:
int int86(int intno, union REGS *inregs, union REGS *outregs);
We send value to device driver through the input register and receive information in it embedded in output
register.
Before the interrupt

Before executing the software interrupt, these functions copy register values from inregs into the registers.
After the interrupt

After the software interrupts returns, these functions copy the following: current register values to outregs
Return Value
Both functions return the value of AX after completion of the software interrupt
AX Register
We can access various mouse functions using different values of AX input Register and passing those
values to mouse port using a interrupt.
The Functions are listed below - Here AX, BX, CX and DX are members of UNION REGS and more or
less integers.
Input
Function Performed
Returns
AX = 0
Get Mouse Status
AX Value = FFFFh support is available.

AX Value = 0 ,support is not available.
AX = 1
Show Mouse Pointer
Nothing
AX = 2
Hide Mouse Pointer
Nothing
AX = 3
Mouse Position
CX = Mouse X Coordinate
DX = Mouse Y Coordinate
AX = 3
Mouse Button Press
BX = 0 No Key Is Pressed
BX = 1 Left Button is Pressed
BX = 2 Right Button is Pressed
BX = 3 Centre Button is Pressed
AX= 7
CX = MaxX1
DX =MaxX2
Set Horizontal Limit
Nothing
AX= 8
CX = MaxX1
DX =MaxX2
Set Vertical Limit
Nothing
Detecting Mouse: Before you start your mouse program you should always check whether the mouse programming is
supported or not.
If somehow mouse fails to initialize you should always make sure that either program terminates or
employ a error handling approach that maybe shift to keyboard interface .
To detect mouse we use a user defined function name detect_mouse() which has following code #include <stdio.h>
#include <conio.h>
#include <dos.h>
union REGS in, out;
void detect_mouse ()
{
in.x.ax = 0;
int86 (0X33,&in,&out);
if (out.x.ax == 0)
printf ("\nMouse Failed To Initialize");
else
printf ("\nMouse was Succesfully Initialized");
}
int main ()
{
detect_mouse ();
getch ();
return 0;
}
Showing and Hiding Mouse: Now first we show mouse on screen.
Mouse works both in text mode and graphic mode.
In text mode it looks like a square while in graphics mode it looks like a pointer.
Mouse Programming in Text Mode: To show mouse in text mode we added a user defined function showmouse_text() to above code so code
becomes #include <stdio.h>
#include <conio.h>
#include <dos.h>
union REGS in, out;
{
in.x.ax = 0;
if (out.x.ax == 0)
else
getch();
}
void showmouse_text ()
{
in.x.ax = 1;
}
int main ()
{
detect_mouse ();
showmouse_text();
getch ();
return 0;
}
Mouse Programming in Graphics Mode: To show mouse in graphics mode we added a user defined function showmouse_graphics() to detect
mouse code above.
#include <stdio.h>
#include <conio.h>
#include <dos.h>
#include <graphics.h>
union REGS in, out;
{
in.x.ax = 0;
if (out.x.ax == 0)
else
getch();
}
void showmouse_graphics ()
{
//int gdriver = DETECT, gmode, errorcode;
//initgraph(&gdriver, &gmode, "c:\\tc\\bgi");
in.x.ax = 1;
getch ();
//closegraph ();
}
int main ()
{
int gdriver = DETECT, gmode, errorcode;
initgraph(&gdriver, &gmode, "c:\\tc\\bgi");
detect_mouse ();
showmouse_graphics();
getch ();
closegraph ();
return 0;
}
Hiding mouse: To hide mouse we added a user defined function hide_mouse() to the above code.
#include <stdio.h>
#include <conio.h>
#include <dos.h>
union REGS in, out;
void detectmouse ()
{
in.x.ax = 0;
if (out.x.ax == 0)
else
printf ("\nMouse was Succesfully Initialize");
getch();
}
{
in.x.ax = 1;
getch ();
}
void hide_mouse ()
{
in.x.ax = 2;
}
int main ()
{
detect_mouse ();
hide_mouse ();
getch ();
closegraph ();
return 0;
}
Detecting Mouse Click: - An important aspect of mouse programming "Detecting Clicks" i.e. Taking
Inputs. We make use of an additional library function known as kbhit ( ).
Kbhit() returns zero till no key is press and when a key is press it returns 1. It is used to run an
infinite while loop.
To detect mouse clicks we add a user defined function detect_mouse_click () to the above code, which
displays on screen the respective button clicked
#include <stdio.h>
#include <conio.h>
#include <dos.h>
union REGS in, out;
{
in.x.ax = 0;
if (out.x.ax == 0)
else
getch();
}
{
in.x.ax = 1;
}
void detect_mouse_click ()
{
while (!kbhit () )
//Press any keyboad key to exit the loop.
{
in.x.ax = 3;
if (out.x.bx == 1) printf ("\nLeft");
if (out.x.bx == 2) printf ("\nRight");
if (out.x.bx == 3) printf ("\nMiddle");
delay (200);
// Otherwise due to quick computer response 100s of words will get print
}
}
int main ()
{
detect_mouse ();
detect_mouse_click ();
getch ();
closegraph ();
return 0;
}
Get Mouse Coordinates

We can obtain the coordinates of the mouse using same service 3 but using different elements of the
union.
This function has a prime use in games programming, application designing and GUI development.
Different decisions are taken on same left button click; its the position of click that matters.
BX element of output registers stores the X Coordinate of the position of mouse at time of calling
function.
CX element of output registers stores the Y Coordinate of the position of mouse at time of calling
function.
To get mouse coordinate we modified user defined function detect_mouse_click() in the above code, to
display x and y coordinates on screen when left click is pressed.
#include <stdio.h>
#include <conio.h>
#include <dos.h>
union REGS in, out;
{
in.x.ax = 0;
if (out.x.ax == 0)
else
getch();
}
{
in.x.ax = 1;
}
void hide_mouse ()
{
in.x.ax = 2;
getch();
}
void detect_mouse_click() {
while (!kbhit () )
{
int x,y;
in.x.ax = 3;
int86 (0X33, &in, &out);
if (out.x.bx == 1)
{
x = out.x.cx;
y = out.x.dx;
printf ("\nLeft || X - %d Y - %d", x, y);
}
if (out.x.bx == 2)
printf ("\nRight");
if (out.x.bx == 3)
printf ("\nMiddle");
delay (200); // Otherwise due to quick computer response 100s of words will get print
}
}
int main ()
{
detect_mouse ();
detect_mouse_click();
hide_mouse ();
getch ();
closegraph ();
return 0;
}
Restricting Mouse in Rectangular Window: To restrict the mouse in one particular size window in GUI or In Games Programming, we added a user
defined function restrict () to the above code.
It takes four parameters, two Cartesian points each containing one x coordinate and one y coordinate.
First point mentions the top of the rectangle while second point mentions the bottom point of rectangle.
This service can be quite handy in special circumstances,
Ex - if you want to restrict your mouse in one particular size window in GUI or In Games Programming.
#include <stdio.h>
#include <conio.h>
#include <dos.h>
union REGS in, out;
void restrict (int x1,int y1,int x2, int y2)
{
in.x.ax = 7;
in.x.cx = x1;
in.x.dx = x2;
in.x.ax = 8;
in.x.cx = y1;
in.x.dx = y2;
}
{
in.x.ax = 0;
if (out.x.ax == 0)
printf ("\nMouse Fail To Initialize");
else
printf ("\nMouse Succesfully Initialize");
getch();
}
{
in.x.ax = 1;
}
void detect_mouse_click()
{
while (!kbhit () )
{
int x,y;
in.x.ax = 3;
if (out.x.bx == 1)
{
x = out.x.cx;
y = out.x.dx;
printf ("\nLeft || X - %d Y - %d", x, y);
}
if (out.x.bx == 2) printf ("\nRight");
if (out.x.bx == 3) printf ("\nMiddle");
delay (200); // Otherwise due to quick computer response 100s of words will get print
}
}
int main ()
{
detect_mouse ();
restrict (100,100,500,500); // Change values here to create different mouse movement space.
detect_mouse_click();
getch ();
closegraph ();
return 0;
}
Practical 3
Aim: Implement DDA line algorithm
Knowledge Required: Basic C/C++ language programming
Theory/Logic:
This algorithms based on calculating either x or y. In this algorithm we have to sample the line at unit
intervals (e.g. x=1 or y=1) in one coordinate (x or y) and determine corresponding integer value nearest
the line path for other coordinate (xk or yk).
In this algorithm we have to consider four cases:
1. Line with a positive slope less than or equal to 1 and starting point is left most end-point.
2. Line with a positive slope greater than 1 and starting point is left most end-point.
3. Line with a positive slope greater than 1 and starting point is right most end-point.
4. Line with a positive slope less than or equal to 1 and starting point is right most end-point.
Case 1: Line with a positive slope less than or equal to 1 and starting point is left most end-point.
Consider a line with slope is less than or equal to 1. At this time we will sample at unit x intervals (x=1)
and compute each successive y value as
yk+1 = yk + m
Here,
m = y / x = y2 - y1 / x
but x = 1
so, m = y2 - y1
let y2 = yk+1 and y1 = yk
Here subscript k takes integer values starting from 1, for the first point and increases by 1 until the final
end-point is reached since m can be any real number between 0 and 1, the calculated y value must be
rounded to the nearest integer.
Case 2: Line with a positive slope greater 1 and starting point is left most end-point.
For line with a positive slope greater than 1, we reverse the roles of x and y. that is we have to sample as
unit y intervals (y = 1) and calculate each succeeding x value as xk+1=xk+1/m.
Case 3: Line with a positive slope greater than 1 and starting point is right most end-point.
For this case we have to y = -1 because we are starting from right most end-point. So our equation will
be yk+1=yk-m
Case 4: Line with a positive slope less than or equal to 1 and starting point is right most end-point.
For this case we have to x = -1 because we are starting from right most end-point. So our equation will
be yk+1=yk-m
Algorithm
Procedure lineDDA (xa, ya, xb, yb : integer);
Var
dx, dy, steps, k : integer
xincrement, yIncrement, x, y : real;
begin
dx := xb-xa;
dy := yb-ya;
if abs (dx) > abs (dy) then steps := abs (dx)

else steps := abs (dy);
xincrement := dx / steps;
yIncrement := dy / steps;
x := xa;
y := ya;
setpixel (round(x), round(y), 1);
for k := 1 to steps do
begin
x := x + xincrement;
y := y + yIncrement;
setpixel (round(x), round(y), 1);
end
end; (lineDDA)
Source Code: /*
------------------------------------------------------------------------DDA line drawing algorithm
------------------------------------------------------------------------*/
# include <graphics.h>
# include <math.h>
# include <conio.h>
# include <iostream.h>
void DDALine(int x1,int y1,int x2,int y2,int iColor);
void main()
{
int gDriver=DETECT,gMode;
int x1,x2,y1,y2,iColor;
initgraph(&gDriver,&gMode,"c:\\tc\\bgi");
cleardevice();
cout<<endl<<"Enter x1 : ";
cin>>x1;
cout<<"Enter y1 : ";
cin>>y1;
cout<<endl<<"Enter x2 : ";
cin>>x2;
cout<<"Enter y2 : ";
cin>>y2;
cout<<endl<<"Enter COLOR : ";
cin>>iColor;
cleardevice();
DDALine(320,1,320,480,12);
DDALine(1,240,640,240,12);
circle(320,240,2);
DDALine(320+x1,240-y1,320+x2,240-y2,iColor%16);
getch();
}
void DDALine(int x1,int y1,int x2,int y2,int iColor)

{
float dX,dY,iSteps;
float xInc,yInc,iCount,x,y;
dX = x1 - x2;
dY = y1 - y2;
if (fabs(dX) > fabs(dY))
{
iSteps = fabs(dX);
}
else
{
iSteps = fabs(dY);
}
xInc = dX/iSteps;
yInc = dY/iSteps;
x = x1;
y = y1;
circle(x,y,1);
for (iCount=1; iCount<=iSteps; iCount++)
{
putpixel(floor(x),floor(y),iColor);
x -= xInc;
y -= yInc;
}
circle(x,y,1);
return;
}
Advantages: 1. Faster method for calculation of pixels position the direct use of equation.
2. It eliminates the multiplication in equation by making use of raster characteristic.
Disadvantages: 1. The accumulation of round errors in successive additions of the floating point increment can cause
the calculated pixel positions to drift away from the true line path for long line segment.
2. Furthermore, the rounding operation and floating point arithmetic operation is procedure are still
time consuming.
Practical 4
Aim: - Implement Bresenham Line algorithm
Software Required: -Turbo C/C++ Compiler,
Knowledge Required: -Basic C/C++ language programming
Theory/Logic: The Bresenham Line Drawing Algorithm
Figure 2
Given two endpoints (Ax, Ay) and (Bx, By), we can chose the start point (xk, yk). The choice is purely
arbitrary, it can be either of (Ax, Ay) and (Bx, By) points. From this start point or pixel, we have eight
possible choices for the next pixel in the line, since each pixel is surrounded by 8 other pixels (except
border pixels). We need to isolate these eight choices into only two choices. If we restrict the slope m for
now to 0 <= m <=1 and assume Ax < Bx, we know that we can simply step in x one pixel at a time to the
right and determine what y value to choose next. Given (xk, yk), the next ideal pixel (the closest to the real
line) will be (xk+1, y) where,
y = m*(xk+1) + b
But we must choose between (xk+1, yk) or (xk+1, yk+1) as shown in figure 2. These pixels represent the
one just to the right and the one to the right and one up pixel, respectively.
To find the best "next pixel", first we must find the distances (d1 and d2) to the two available choices from
the ideal location (of the real line). Distance between pixel-to-right and ideal pixel is:
d1 = y - yk
and the distance between pixel-to-right-and-up and ideal pixel is:
d2 = (yk +1) - y
So we can simply choose subsequent pixels based on the following:
if (d1<=d2) then choose pixel-to-right: ( xk+1, yk )
if (d1>d2) then choose pixel-to-right-and-up: ( xk+1, yk+1 )
In order to develop a fast way of doing this, we will not be comparing these values in such a manner;
instead we will create a decision variable that can be used to quickly determine which point to use.
Instead of comparing the two values to each other, we can simply evaluate d1-d2 and test the sign to
determine which to choose. If d1 > d2 then d1-d2 will be strictly positive, and if d1-d2 is strictly positive, we
will choose pixel-to-right-and-up. If d1-d2 is negative or zero, we will choose pixel-to-right. In addition to
this optimization, this Algorithm suggests to optimize more. If we evaluate d1-d2 as follows:
d1-d2 = y - yk - (yk+1 - y) = y - yk - yk+1 + y
and now substitute using

y = m*xk+1 + b,
we get ,
d1-d2 = m*xk+1 + b - yk - yk - 1 + m*xk+1 + b = 2*m*xk+1 - 2*yk + 2*b - 1
The last equation can be reduced by the slope m and substituting as follows:
m = y/x
where y = abs(By - Ay) and x = abs(Bx - Ax),
so now we have,
d1-d2 = 2*(y/x)*xk+1 - 2*yk + 2*b - 1
or if we expand the first term (multiply), then:
d1-d2 = 2*(y/x)*(xk +1) - 2*yk + 2*b 1
d1-d2 = 2*(y/x)*xk + 2*(y/x) - 2*yk + 2*b - 1
This last equation can be simplified by creating a new decision variable
Pk = x * (d1-d2).
This x will remove the divisions (all integer operations for faster and efficient computing) and will still
keep the same sign for the decision because x variable is always positive (x = abs (Bx - Ax) -> absolute
value).
If we now evaluate a new decision variable Pk, we get:
Pk = x * (2*(y/x)*xk + 2*(y/x) - 2*yk + 2*b - 1 )
or further:
Pk = 2*y*xk + 2*y - 2*x*yk + 2*x*b - x
If we now rearrange the terms in the last equation, we get:
Pk = 2*y*xk - 2*x*yk + 2*y + 2*x*b - x
or
Pk = 2*y*xk - 2*x*yk + c
Where c is always constant value (it depends only on the input endpoints) and is equal to 2*y + x*(2*b
- 1)
Using described approach, decision variable can be computed very efficiently, but it still requires
evaluation of Pk for each point (pixel) along a line. Since line entity is linear in its nature, Pk change will
be linear as well; therefore we can evaluate subsequent Pk values incrementally by finding a constant
change in Pk for each subsequent pixel. By evaluating an incremental change of the decision function
P = P = Pk+1 - Pk
we can evaluate by substitution P as follows:
Pk+1 - Pk
= 2*y*xk+1 - 2*x*yk+1 + c - 2*y*xk + 2*x*yk - c
= 2*y*xk+1 - 2*y*xk - 2*x*yk+1 + 2*x*yk
= 2*y*(xk+1 - xk) - 2*x*(yk+1 - yk)
Since we are processing pixel one by one in the x direction, the change in the x direction is (xk+1 - xk) = 1,
so if we substitute this into our P derivation, we get:
Pk+1 - Pk = 2*y - 2*x*(yk+1 - yk)
For the y direction, there are two possibilities; the term (yk+1 - yk) can be only 0 or 1, depending on Pk. If
we choose pixel-to-right or pixel-to-right-and-up, so now our P derivation looks like:
Pk+1 - Pk = 2*y - 2*x*(0) = 2*y
Pk+1= Pk +2*y
if pixel-to-right is chosen.
Pk+1 - Pk= 2*y - 2*x*(1) = 2*y - 2*x
if pixel-to-right-and-up is chosen.The only remaining thing is to decide what the initial value of P0 is. This
can be decided by evaluating equation
Pk = 2*y*xk - 2*x*yk + 2*y + x*(2*b - 1),
so for zero (k = 0, xk = 0 and yk = 0), we get:

P0 = 2*y*x0 - 2*x*y0 + 2*y + x*(2*b - 1)
From line equation at the starting pixel y0 = m*x0 + b we get term for b intercept b = y0 - m*x0.
Substituting b and slope m = y/x into equation P0 we get:
P0
= 2*y*x0 - 2*x*y0 + 2*y + x*(2*(y0 - (y/x)*x0) - 1)
= 2*y*x0 - 2*x*y0 + 2*y + 2*x*(y0 - (y/x)*x0) - x
= 2*y*x0 - 2*x*y0 + 2*y + 2*x*y0 - 2*y*x0 - x
P0
= 2*y - x
Bresenhams Line Algorithm
Begin {Bresenham for lines with slope between 0 and 1}
a := ABS(xend - xstart);
b := ABS(yend - ystart);
d := 2*b - a;
Incr1 := 2*(b-a);
Incr2 := 2*b;
If xstart > xend Then Begin
x := xend;
y := yend
End
Else Begin
x := xstart;
y := ystart
End;
For I: = 0 to a Do Begin
Plot(x,y);
x := x + 1;
If d 0 Then Begin
y := y + 1;
d := d + incr1
End
Else
d := d + incr2
End {For Loop}
End; {Bresenham}
Source Code: /*
------------------------------------------------------------------------Bresenham line drawing algorithm
------------------------------------------------------------------------*/
# include <conio.h>
# include <math.h>
char IncFlag;
void Bresenham(int x1,int x2,int y1,int y2);
void DrawLine(int X,int Y,int End,int PInc,int NInc,int P,int XInc,int YInc);
void main()
{
int gDriver=DETECT, gMode;
int x1,x2,y1,y2;
void Bresenham(int,int,int,int);
cout<<endl<<"x1 : ";
cin>>x1;
cout<<endl<<"y1 : ";
cin>>y1;
cout<<endl<<"x2 : ";
cin>>x2;
cout<<endl<<"y2 : ";
cin>>y2;
line(320,0,320,480);
line(0,240,640,240);
Bresenham(x1,x2,y1,y2);
getch();
}
void Bresenham(int x1,int x2,int y1,int y2)
{
int S,O,End;
int P;
int dx = abs(x1 - x2);
int dy = abs(y1 - y2);
float Slope;
int PInc,NInc,XInc,YInc;
if (dx == 0) //Slope Infinite
{
}
else
{
Slope = (float)(y1 - y2) / (x1 - x2);
if (Slope>-1 && Slope<1)
{
IncFlag = 'X';
PInc = 2 * (dy - dx);
NInc = 2 * dy;
P = 2 * dy - dx;
if (x1>x2)
{
S = x2;
O = y2;
End = x1;
}
else
{
S = x1;
O = y1;
End = x2;
}
DrawLine(x,y,End,PInc,NInc,P,XInc,YInc);
//
}
else
{
IncFlag = 'Y';
PInc = 2 * (dx - dy);
NInc = 2 * dx;
P = 2 * dx - dy;
if (y1 > y2)
{
O = x2;
S = y2;
End = y1;
}
else
{
O = x1;
S = y1;
End = y2;
}
}
if (IncFlag == 'X')
putpixel(320+S,240-O,12);
else
putpixel(320+O,240-S,12);
while (S <= End)
{
S++;
if (P<0)
P = P + NInc;
else
{
P = P + PInc;
if (Slope>0.0)
O++;
else
O--;
}
if (IncFlag == 'X')
putpixel(320+S,240-O,12);
else
putpixel(320+O,240-S,12);
}
}
}
Advantages:
This is faster method then DDA because here we have to do only integer calculation.
Disadvantages:
Accumulation of error every time due to rounding in equation.
Practical 5
Aim: Implement Mid-point Circle algorithm
Software Required: Turbo C/C++ Compiler,
Theory/Logic:
If a circle is to be plotted efficiently, the use of trigonometric and power functions must be avoided. And
as with the generation of a straight line, it is also desirable to perform the calculations necessary to find
the scan-converted points with only integer addition, subtraction, and multiplication by powers of 2.
Midpoint circle algorithm allows these goals to be met.
Scan-converting a circle using midpoint algorithm works are follows. If the eight-way symmetry of a
circle is used to generate a circle, points will only have to be generated through a 45 angle. And, if points
are generated from 90 to 45, moves will be made only in the +x and -y directions (see Figure 1).
-y
45
+x
Figure 1 Circle scan-converted with Midpoint algorithm.

The best approximation of the true circle will be described by those pixels in the raster that fall the least
distance from the true circle. Examine Figures 3(a) and 3(b). Notice that if points are generated from 90
and 45, each new point closest to the true circle can be found by taking either of two actions: (1) move in
the x direction one unit or (2) move in the x direction one unit and move in the negative y direction one
unit. Therefore, a method of selecting between these two choices is all that is necessary to find the points
closest to the true circle.
Due to the 8-way symmetry, we need to concentrate only on the are from (0, r) to (r / 2 , r / 2 ) . Here
we assume r to be an integer.
Suppose that P(xi, yi) has been selected as closest to the circle. The choice of the next pixel is between U
and D (Fig.2).
U(xi + 1, yi )
P(xi, yi)
M
D(xi +1, yi - 1)
(b)
Figure 2
Let F(x, y) =
F(x, y) =
x2 + y2 - r2. We know that

0
then (x, y) lies on the circle
>0
then (x, y) is outside the circle
<0
then (x, y) is inside the circle
Let M be the midpoint of DU. If M is outside then pixel D is closer to the circle, and if M is
inside, pixel U is closer to the circle.
Let dold
= F(xi+1, yi 12 )
= (xi + 1)2 + (yi 1 2 )2 r2
* If dold < 0, then U (xi+1, yi) is chosen and the next midpoint will be one increment over x.
Thus
dnew = F(xi+2, yi 12 )
= dold + 2xi + 3
The increment in d is
dU = dnew dold = 2xi + 3
* If dold 0, M is outside the circle and D is chosen. The new midpoint will be one increment over x and
one increment down in y:
dnew = F (xi + 2, yi 23 )
= dold + 2xi 2yi + 5
The increment in d is therefore
dD = dnew dold = 2(xi yi ) + 5
Since the increments dU and dD are functions of (xi , yi), we call point P(xi, yi) the point of evaluation.
Initial point: (0, r). The next midpoint lies at (1, r- 12 ) and so
F (1, r 12 ) = 1 + (r 12 )2 r2 = 5 4 r
(0, r)
U (xi + 1, yi )
P ( x i, y i)
(r /
2, r /
2)
D (xi +1, yi - 1)
(a)
Figure 3 Midpoint Circle Algorithm

Midpoint Circle Algorithm
h = 1 r ; /*initialization */
x = 0;
y = r;
Plot Point (x, y);
While y > x
if h < 0 then /* Select U */
dU = 2*x + 3;
h = h + dU;
x = x + 1;
(b)
else
/* Select D */
dD = 2*(x y) + 5;
h = h dD;
x = x + 1;
y = y 1;
endif
End While
Source Code: /*
------------------------------------------------------------------------Midpoint Circle Drawing
------------------------------------------------------------------------*/
# include <conio.h>
# include <math.h>
void Circle(int Radius,int xC,int yC);
void main()
{
int gDriver=DETECT, gMode;
int Radius, xC, yC;
cout<< endl << "Enter Center point coordinates...";
cout<<endl<<" Xc : ";
cin>>xC;
cout<<endl<<" Xc : ";
cin>>yC;
cout<<endl<<"Radius : ";
cin>>Radius;
cleardevice();
Circle(Radius,xC,yC);
getch();
return;
}
void Circle(int Radius,int xC,int yC)
{
int P;
int x,y;
void Draw(int x,int y,int xC,int yC);
P = 1 - Radius;
x = 0;
y = Radius;
Draw(x,y,xC,yC);
while (x<=y)
{
x++;
if (P<0)
{
P += 2 * x + 1;
}
else
{
P += 2 * (x - y) + 1;
y--;
}
Draw(x,y,xC,yC);
}
}
void Draw(int x,int y,int xC,int yC)
{
putpixel(xC + x,yC + y,12);
putpixel(xC + x,yC - y,12);
putpixel(xC - x,yC + y,12);
putpixel(xC - x,yC - y,12);
putpixel(xC + y,yC + x,12);
putpixel(xC - y,yC + x,12);
putpixel(xC + y,yC - x,12);
putpixel(xC - y,yC - x,12);
}
Advantage:
This is faster method to draw a circle then that of conventional method.
Disadvantages:
Accumulation of error at every step because of rounding
Practical 6
Aim: Implement Mid-point Ellipse algorithm
Theory/Logic:
Slope
= -1
Region
1Region
2
Ellipse is different from the circle. Ellipse is drawn as using similar algorithm with different direction of
sampling. As shown in figure ellipse is divided in two regions.
In Region 1:
Sampling is done in X-Direction
Choosing of pixel between (xk+1, yk), or (xk+1, yk-1)
Mid point: (xk+1, yk-0.5)
In Region 2:
Sampling is done in Y-Direction
Choosing of pixel between (xk, yk-1), or (xk+1, yk-1)
Mid point: (xk+0.5, yk-1)
Decision Parameters for drawing ellipse:
In Region 1:
p1k f e xk 1, yk
With ve(Negative) P1k

Mid-Point is inside
Choose Pixel(Xk+1,Yk)
With +ve(Positive) P1k
Mid-Point is outside
Choose Pixel(Xk+1,Yk-1)
In Region 2:
p2k f e xk 1 2 , yk 1
With ve(Negative) P2k

Mid-Point is inside
Choose Pixel(Xk+1,Yk-1)
With +ve(Positive) P2k
Mid-Point is outside
Choose Pixel(Xk,Yk-1)
Source Code: /* ------------------------------------------------------------MidEllipse

------------------------------------------------------------- */
#include<stdio.h>
#include<conio.h>
#include<math.h>
void disp();
float x,y;
int xc,yc;
void main()
{
int gd=DETECT,gm;
int a,b;
float p1,p2;
clrscr();
initgraph(&gd,&gm,"c:\\tc\\bgi");
printf("Enter the Values for XC, YC, a, b\n");
scanf("%d%d",&xc,&yc);
scanf("%d%d",&a,&b);
x=0;y=b;
disp();
p1=(b*b)-(a*a*b)+(a*a)/4;
while((2.0*b*b*x)<=(2.0*a*a*y))
{
x++;
if(p1<=0)
p1=p1+(2.0*b*b*x)+(b*b);
else
{
y--;
p1=p1+(2.0*b*b*x)+(b*b)-(2.0*a*a*y);
}
disp();
x=-x;
}
x=a;
y=0;
disp();
p2=(a*a)+2.0*(b*b*a)+(b*b)/4;
while((2.0*b*b*x)>(2.0*a*a*y))
{
y++;
if(p2>0)
p2=p2+(a*a)-(2.0*a*a*y);
else
{
x--;
p2=p2+(2.0*b*b*x)-(2.0*a*a*y)+(a*a);
}
disp();
y=-y;
}
getch();
closegraph();
}
void disp()
{
putpixel(xc+x,yc+y,10);
putpixel(xc-x,yc+y,10);
putpixel(xc+x,yc-y,10);
putpixel(xc+x,yc-y,10);
}
Practical 7
Aim: Implement Polygon Filling using Flood Fill and Boundary Fill algorithm
Software Required: C/C++
Knowledge Required: Basic C language programming.
Theory/logic:1.
Boundary Fill Algorithm: This method of area filling is starts with selecting a pixel which is located inside the region to be
filled. For this selected pixel, pixel is colored then its neighboring pixels are selected as new pixels to
be colored until the boundary pixel arrives, here it is to be assumed that boundary pixel is colored with
different color than color of region.
There are two methods for proceeding of Neighboring Pixels:
1.
4 connected pixels
2.
8 connected pixels
4 Connected
8 Connected
Procedure BoundaryFill(x, y, FillColor, BoundaryColor: integer)
If (getpixel(x,y) not BoundaryColor ) And (getpixel(x, y) not FillColor)
setpixel (x, y, FillColor);
BoundaryFill(x+1, y, FillColor, BoundaryColor);
BoundaryFill(x-1, y, FillColor, BoundaryColor);
BoundaryFill(x, y+1, FillColor, BoundaryColor);
BoundaryFill(x, y-1, FillColor, BoundaryColor);
BoundaryFill(x+1, y+1, FillColor, BoundaryColor);
BoundaryFill(x+1, y-1, FillColor, BoundaryColor);
BoundaryFill(x-1, y+1, FillColor, BoundaryColor);
BoundaryFill(x-1, y-1, FillColor, BoundaryColor);
End if
End Procedure
Source Code: /* ---------------------------------------------------------------Boundary Fill (8 Connected Point)

---------------------------------------------------------------- */
#include<iostream.h>
#include<stdlib.h>
#include<conio.h>
#include<dos.h>
class Circle
{
int XCoord;
int YCoord;
int Radius;
void PlotPoint(int,int,int);
public:
Circle()
{
XCoord=0;
YCoord=0;
Radius=0;
}
Circle(int x, int y, int z)
{
XCoord=x;
YCoord=y;
Radius=z;
}
void CircleMidpoint();
void InitGraphs();
void BoundryFill(int,int,int,int);
void BoundryFillRound();
};
void Circle :: InitGraphs()
{
int gMode, gDriver=DETECT;
int errorcode;
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
cout<<"Graphics error: "<< grapherrormsg(errorcode);
cout<<"Press any key to halt:";
getch();
exit(1);
/* return with error code */
}
setbkcolor(3);
}
void Circle :: PlotPoint(int x,int y,int z)
{
putpixel(XCoord+x,YCoord+y,z);
putpixel(XCoord-x,YCoord+y,z);
putpixel(XCoord+x,YCoord-y,z);
putpixel(XCoord-x,YCoord-y,z);
putpixel(XCoord+y,YCoord+x,z);
putpixel(XCoord-y,YCoord+x,z);
putpixel(XCoord+y,YCoord-x,z);
putpixel(XCoord-y,YCoord-x,z);
}
void Circle :: CircleMidpoint()
{
int x,y;
int p;
x=0;
y=Radius;
PlotPoint(x,y,15);
p=1-Radius;
while(x<y)
{
if(p<0)
x+=1;
else
{
x+=1;
y-=1;
}
if(p<0)
p=p+2*x+1;
else
{
p=p + 2 *(x-y) + 1;
}
PlotPoint(x,y,15);
}
}
void Circle :: BoundryFillRound()
{
int x,y;
int p;
for(int iCntr=1;iCntr<Radius;iCntr++)
{
x=0;
y=iCntr;
PlotPoint(x,y,5);
p=1-iCntr;
while(x<y)
{
if(p<0)
x+=1;
else
{
x+=1;
y-=1;
}
if(p<0)
p=p+2*x+1;
else
{
p=p + 2 *(x-y) + 1;
}
PlotPoint(x,y,5);
}
}
}
void Circle :: BoundryFill(int x, int y,int fill,int bound)
{
int cur;
cur=getpixel(x,y);
if(cur!=bound && cur!= fill)
{
putpixel(x,y,fill);
Circle :: BoundryFill(x+1, y,fill,bound);
Circle :: BoundryFill(x-1, y,fill,bound);
Circle :: BoundryFill(x, y-1,fill,bound);
Circle :: BoundryFill(x, y+1,fill,bound);
Circle :: BoundryFill(x+1, y+1,fill,bound);
Circle :: BoundryFill(x+1, y+1,fill,bound);
Circle :: BoundryFill(x-1, y-1,fill,bound);
Circle :: BoundryFill(x-1, y+1,fill,bound);
}
}
void main()
{
Circle cObj(250,250,42);
cObj.InitGraphs();
cObj.CircleMidpoint();
cObj.BoundryFillRound();
//cObj.BoundryFill(250,250,11,15);
getch();
closegraph();
}
2.
Flood Fill Algorithm: voidfloodFill4 (int x, int y, int fillcolor, int oldcolor)
{
if (getpixel (x. y) == oldcolor)
{
setcolor (fillcolor);
setpixel (x, y):
floodFill4 (x+l, y, fillColor, oldColor):
floodfill4 (x-1, y, fillcolor, oldcolor);
floodPill4 (x, y+l, fillcolor, oldcolor);
floodFill4 (x, y-1, fillColor, oldcolor);
}
}
Source Code: /*
---------------------------------------------------------------Floodfill
---------------------------------------------------------------*/
# include <stdio.h>
# include <dos.h>
# include <conio.h>
# include <stdlib.h>
void FloodFill(int,int,int,int);
void MidPoint(int);
void main()
{
int xCenter=320;
int yCenter=240;
int gDriver = DETECT, gMode, errorcode;
initgraph(&gDriver, &gMode, "c:\\tc\\bgi");
cleardevice();
MidPoint(49);
FloodFill(xCenter+1,yCenter+1,0,8);
getch();
return;
}
void MidPoint(int Radius)
{
int iCntr, x, y,p0;
x=0;
y=Radius;
int xCenter=320;
int yCenter=240;
p0=(5/4)-Radius;
putpixel(xCenter+x,yCenter+y,15);
putpixel(xCenter-x,yCenter+y,15);
putpixel(xCenter+x,yCenter-y,10);
putpixel(xCenter-x,yCenter-y,10);
putpixel(xCenter+y,yCenter+x,12);
putpixel(xCenter-y,yCenter+x,12);
putpixel(xCenter+y,yCenter-x,9);
putpixel(xCenter-y,yCenter-x,9);
while(x<=y)
{
if(p0 < 0)
{
p0=p0 + 2*(x+1) + 1;
x=x+1;
}
else
{
p0=p0 + 2*(x+1) + 1 - 2*(y-1);
x=x+1;
y=y-1;
}
putpixel(xCenter+x,yCenter+y,15);
putpixel(xCenter-x,yCenter+y,15);
putpixel(xCenter+x,yCenter-y,10);
putpixel(xCenter-x,yCenter-y,10);
putpixel(xCenter+y,yCenter+x,12);
putpixel(xCenter-y,yCenter+x,12);
putpixel(xCenter+y,yCenter-x,9);
putpixel(xCenter-y,yCenter-x,9);
}
}
void FloodFill(int pointx,int pointy,int OldColor,int NewColor)
{
int Intensity=getpixel(pointx,pointy);
if(Intensity==OldColor)
{
putpixel(pointx,pointy,NewColor);
FloodFill(pointx+1,pointy,OldColor,NewColor);
FloodFill(pointx-1,pointy,OldColor,NewColor);
FloodFill(pointx,pointy+1,OldColor,NewColor);
FloodFill(pointx,pointy-1,OldColor,NewColor);
}
}
Precaution:
1. Stack Overflow of recursion should be controlled
2. Infinite loop control.
Practical 8
Aim: Implement program to draw various charts
Knowledge Required: Basic C language programming
Theory/logic:Charts are data representation techniques by which any body can visualize the data. It represents the data
in summarized format (the statistical features). Charts have many categories, some them are: PIE chart,
Bar Chart, Line chart, Area Chart, Composition chart .
C programming supports drawing of bar char and 3d bar chart, pie chart with different fill style and
different fill patterns so any body can implements basic chart using c graphics.
35
30
25
1st Qtr
20
2nd Qtr
3rd Qtr
15
4th Qtr
10
0
Jan
Feb
Mar
BAR CHART
Apr
May
Jun
PIE CHART
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<math.h>
void main()
{
int gd,gm,x[20],y[20],n,x1,n1,val[20],i;
detectgraph(&gd,&gm);
initgraph(&gd,&gm,"c:\\tc\\bgi");
cleardevice();
void barc(int [],int,int);
void piec(int *,int);
/* for barchart n - no.of bars, x1-starting value for x axis, y[i] variable y axis values*/
printf("Enter n and x1\n");
scanf("%d %d",&n,&x1);
printf("Enter all y values\n");
for(i=0;i<n;i++)
{
scanf("%d",&y[i]); }
cleardevice();
line(5,0,5,480);
line(5,478,638,478);
barc(y,x1,n);
getch();
cleardevice();
/*for pie chart, n1- no. of sections, val[i] % values for each section, here sum of all val[i] = 100*/
printf("Enter no. of sections\n");
scanf("%d",&n1);
printf("Enter all values\n");
for(i=0;i<n1;i++)
{
scanf("%d",&val[i]); }
piec(val,n1);
getch();
}
void barc(int y[20],int x1,int n)
{
int i,j=0,k=0;
for(i=0;i<n;i++)
{
rectangle(x1+j,y[i],x1+j+20,478);
j=j+50;
}
for(i=0;i<n;i++)
{
while(y[i]!=478)
{
line(x1+k+1,y[i],x1+k+19,y[i]);
y[i]=y[i]+1;
}
k+=50;
}
}
void piec(int val[20],int n)
{
int x1[20],y1[20],i,a,j,v[20];
v[0]=0;
val[0]=0;
cleardevice();
circle(320,240,100);
a=4;
for(i=0;i<n;i++)
{
v[i]=val[i]*3.6;
v[i]=v[i]+v[i-1];
x1[i]=100*cos(v[i]*3.14/180)+320;
y1[i]=100*sin(v[i]*3.14/180)+240;
setcolor(a);
line(320,240,x1[i],y1[i]);
//
outtextxy(x1[i],y1[i],(char *)val[i]);
a=a+1;
}
/*
a=4;
for(i=1;i<n;i++)
{
for(j=0;j<=100;j++)
{
setcolor(a);
arc(320,240,val[i-1],val[i],j);
}
a=a+1;
}*/
}
Practical 9
Aim: Implement algorithm of 2D Transformation of an Object
Software Required: Turbo C/C++ Compiler,
Theory/Logic:
The following describes the 2d transformation of a point on a plane
P = ( x , y ) -> P' = ( x' , y' )
Translation
A translation (shift) by Tx in the x direction and Ty in the y direction is
x' = x + Tx
y' = y + Ty
Source Code: /*
---------------------------------------------------------------Translation
---------------------------------------------------------------*/
# include <conio.h>
# include <math.h>
char IncFlag;
int PolygonPoints[4][2] ={{10,10},{10,100},{100,100},{100,10}};
float Tx=10;
float Ty=10;
void PolyLine()
{
int iCnt;
cleardevice();
line(0,240,640,240);
line(320,0,320,480);
for (iCnt=0; iCnt<4; iCnt++)
{
line(320+PolygonPoints[iCnt][0],
240-PolygonPoints[iCnt][1],
320+PolygonPoints[(iCnt+1)%4][0],
240-PolygonPoints[(iCnt+1)%4][1]);
}
}
void Translate()
{
int iCnt;
cout<<endl;
{
PolygonPoints[iCnt][0] += Tx;
PolygonPoints[iCnt][1] += Ty;
}
}
void main()
{
int gDriver = DETECT, gMode;
int iCnt;
initgraph(&gDriver, &gMode, "C:\\TC\\BGI");
PolyLine();
getch();
Translate();
PolyLine();
getch();
}
Scaling: A scaling by Sx in the x direction and Sy in the y directions about the origin is
x' = Sx x
y' = Sy y
If Sx and Sy are not equal this results in a stretching along the axis of the larger scale factor.
To scale about a particular point, first translate to the origin, scale, and translate back to the original
position. For example, to scale about the point (x0,y0)
x' = x0 + Sx ( x - x0 )
y' = y0 + Sy ( y - y0 )
Source Code: /*
----------------------------------------------------------Scaling about Origin
----------------------------------------------------------*/
# include <conio.h>
# include <math.h>
char IncFlag;
float Sx=0.5;
float Sy=2.0;
void PolyLine()
{
int iCnt;
cleardevice();
line(0,240,640,240);
line(320,0,320,480);
{
line(320+PolygonPoints[iCnt][0],240-PolygonPoints[iCnt][1],
320+PolygonPoints[(iCnt+1)%4][0],240-PolygonPoints[(iCnt+1)%4][1]);
}
}
void Scale()
{
int iCnt;
int Tx,Ty;
cout<<endl;
{
PolygonPoints[iCnt][0] *= Sx;
PolygonPoints[iCnt][1] *= Sy;
}
}
void main()
{
int iCnt;
PolyLine();
getch();
Scale();
PolyLine();
getch();
}
Source Code: /*
---------------------------------------------------------------Scaling about Reference Point
---------------------------------------------------------------*/
# include <conio.h>
# include <math.h>
char IncFlag;
float Sx=0.5;
float Sy=2.0;
int RefX=55;
int RefY=55;
void PolyLine()
{
int iCnt;
cleardevice();
line(0,240,640,240);
line(320,0,320,480);
{
line(320+PolygonPoints[iCnt][0],240-PolygonPoints[iCnt][1],
320+PolygonPoints[(iCnt+1)%4][0],240-PolygonPoints[(iCnt+1)%4][1]);
}
}
void Scale()
{
int iCnt;
int Tx,Ty;
cout<<endl;
{
PolygonPoints[iCnt][0] *= Sx;
PolygonPoints[iCnt][0] += (1-Sx)*RefX;
PolygonPoints[iCnt][1] *= Sy;
PolygonPoints[iCnt][1] += (1-Sy)*RefY;
}
}
void main()
{
int iCnt;
PolyLine();
getch();
Scale();
PolyLine();
getch();
}
Rotation
Rotation about the origin by an angle A in a clockwise direction is
x' = x cos(A) + y sin(A)
y' = y cos(A) - x sin(A)
To rotate about a particular point apply the same technique as described for scaling, translate the
coordinate system to the origin, rotate, and the translate back.
Source Code: /*
------------------------------------------------------------Rotate About Origin
------------------------------------------------------------*/
# include <conio.h>
# include <math.h>
char IncFlag;
void PolyLine()
{
int iCnt;
cleardevice();
line(0,240,640,240);
line(320,0,320,480);
{
line(PolygonPoints[iCnt][0],PolygonPoints[iCnt][1],
PolygonPoints[(iCnt+1)%4][0],PolygonPoints[(iCnt+1)%4][1]);
}
}
void Rotate()
{
float Angle;
int iCnt;
int Tx,Ty;
cout<<endl;
Angle = 30.0*(22.0/7.0)/180.0;
{
Tx = PolygonPoints[iCnt][0];
Ty = PolygonPoints[iCnt][1];
PolygonPoints[iCnt][0] = (Tx - 320)*cos(Angle) (Ty - 240)*sin(Angle) + 320;
PolygonPoints[iCnt][1] = (Tx - 320)*sin(Angle) +
(Ty - 240)*cos(Angle) + 240;
}
}
void main()
{
int iCnt;
{
PolygonPoints[iCnt][0] += 320;
PolygonPoints[iCnt][1] = 240 - PolygonPoints[iCnt][1];
}
PolyLine();
getch();
Rotate();
PolyLine();
getch();
}
Source Code: /*
------------------------------------------------------------Rotate about Reference Point
------------------------------------------------------------*/
# include <conio.h>
# include <math.h>
char IncFlag;
int RefX = 10;
int RefY = 100;
void PolyLine()
{
int iCnt;
cleardevice();
line(0,240,640,240);
line(320,0,320,480);
{
}
}
void Translate(int Direction)
{
int iCnt;
{
PolygonPoints[iCnt][0] += Direction*RefX;
PolygonPoints[iCnt][1] -= Direction*RefY;
}
}
void Rotate()
{
float Angle;
int iCnt;
int Tx,Ty;
Translate(-1);
cout<<endl;
Angle = 30.0*(22.0/7.0)/180.0;
{
PolygonPoints[iCnt][0] = (Tx - 320)*cos(Angle) (Ty - 240)*sin(Angle) + 320;
PolygonPoints[iCnt][1] = (Tx - 320)*sin(Angle) +
(Ty - 240)*cos(Angle) + 240;
}
Translate(1);
}
void main()
{
int iCnt;
{
}
PolyLine();
getch();
Rotate();
PolyLine();
getch();
}
Reflection
Case : 1 Reflection about the x axis
x' = x
y' = - y
Source Code: /*
------------------------------------------------------------Reflection in x Axis
------------------------------------------------------------*/
# include <conio.h>
# include <math.h>
char IncFlag;
int PolygonPoints[3][2] ={{10,100},{110,100},{110,200}};
void PolyLine()
{
int iCnt;
cleardevice();
line(0,240,640,240);
line(320,0,320,480);
{
}
}
void Reflect()
{
float Angle;
int iCnt;
int Tx,Ty;
cout<<endl;
PolygonPoints[iCnt][1] = (480 - PolygonPoints[iCnt][1]);

}
void main()
{
int iCnt;
{
}
PolyLine();
getch();
Reflect();
PolyLine();
getch();
}
Case : 2 Reflection about the y axis

x' = - x
y' = y
Source Code: /*
------------------------------------------------------------Reflection in y Axis
------------------------------------------------------------*/
# include <conio.h>
# include <math.h>
char IncFlag;
int PolygonPoints[3][2] ={{10,100},{110,100},{110,200}};
void PolyLine()
{
int iCnt;
cleardevice();
line(0,240,640,240);
line(320,0,320,480);
{
}
}
void Reflect()
{
float Angle;
int iCnt;
int Tx,Ty;
cout<<endl;
PolygonPoints[iCnt][0] = (640 - PolygonPoints[iCnt][0]);
}
void main()
{
int iCnt;
{
}
PolyLine();
getch();
Reflect();
PolyLine();
getch();
}
Case 3: - Reflections about an arbitrary line involve possibly a translation so that a point on the line
passes through the origin, a rotation of the line to align it with one of the axis, a reflection, inverse rotation
and inverse translation.
Source Code: /*
---------------------------------------------------------------Reflection on any line.
---------------------------------------------------------------*/
#
#
#
#
include
include
include
include
<iostream.h>
<conio.h>
<graphics.h>
<math.h>
char IncFlag;
int PolygonPoints[3][2] =
{{10,100},{110,100},{110,200}};
int
int
int
int
x1=10;
y1=10;
x2=100;
y2=100;
void PolyLine()
{
int iCnt;
cleardevice();
line(0,240,640,240);
line(320,0,320,480);
{
}
}
void Reflect()
{
float Angle,Slope,Hx,Hy,B;
int iCnt;
int Tx,Ty;
Angle = atan((y2-y1)/(x2-x1));
Angle *= (M_PI)/180.0;
Slope = tan(Angle);
B = y2 - x2*Slope;
Hx = -B*sin(2.0 * Angle);
Hy = B*(cos(2.0 * Angle)+1);
{
PolygonPoints[iCnt][0] = Tx*cos(2.0*Angle);
+ Ty*sin(2.0*Angle) + Hx;
PolygonPoints[iCnt][0] = Tx*sin(2.0*Angle);
- Ty*cos(2.0*Angle) + Hy;
}
}
void main()
{
int iCnt;
{
}
PolyLine();
getch();
Reflect();
PolyLine();
getch();
}
Practical-10
Aim: Implementation of Line Clipping Algorithms
Knowledge Required: Basic C language programming.
Theory/logic:
1. Cohen Sutherland Algorithm for Line clipping: This algorithm is used to clip the line against given rectangle window. As you proceed around the
window, extending each edge and defining an inside half-space and an outside half-space, nine regions
are created - the eight "outside" regions and the one "inside" region. Each of the nine regions
associated with the window is assigned a 4-bit code to identify the region. Each bit in the code is set to
either a 1(true) or a 0(false). If the region is to the left of the window, the first bit of the code is set to
1. If the region is to the top of the window, the second bit of the code is set to 1. If to the right, the
third bit is set, and if to the bottom, the fourth bit is set. The 4 bits in the code then identify each of
the nine regions as shown below.
For any endpoint ( x , y ) of a line, the code can be determined that identifies which region the endpoint
lies. The code's bits are set according to the following conditions:
The sequence for reading the codes' bits is LRBT (Left, Right, Bottom, Top).
Once the codes for each endpoint of a line are determined, the logical AND operation of the codes
determines if the line is completely outside of the window. If the logical AND of the endpoint codes is not
zero, the line can be trivally rejected. For example, if an endpoint had a code of 1001 while the other
endpoint had a code of 1010, the logical AND would be 1000 which indicates the line segment lies
outside of the window. On the other hand, if the endpoints had codes of 1001 and 0110, the logical AND
would be 0000, and the line could not be trivally rejected.
The logical OR of the endpoint codes determines if the line is completely inside the window. If the
logical OR is zero, the line can be trivally accepted. For example, if the endpoint codes are 0000 and
0000, the logical OR is 0000 - the line can be trivally accepted. If the endpoint codes are 0000 and 0110,
the logical OR is 0110 and the line can not be trivally accepted.
Data Structure: none.

Advantage:
Easy to implement.
First check is performed to find whether line is to be accepted or rejected, so no need to do any
calculations if line is to be rejected completely.
Disadvantage:
It is limited to rectangle window only.
Intersection point calculations are required.
Application : In window to viewport transformation, when the region is to be
Clipped, then this algorithm is used to clip the lines.
I/P & O/P: Before Clipping (Input) :
How Algorithm works?

1. Consider the line segment AD. Point A has an outcode of 0000 and point D has an outcode of
1001. The logical AND of these outcodes is zero; therefore, the line cannot be trivally rejected.
Also, the logical OR of the outcodes is not zero; therefore, the line cannot be trivally accepted. The
algorithm then chooses D as the outside point (its outcode contains 1's). By our testing order, we
first use the top edge to clip AD at B. The algorithm then recomputes B's outcode as 0000. With
the next iteration of the algorithm, AB is tested and is trivially accepted and displayed.
2. Consider the line segment EI. Point E has an outcode of 0100, while point I's outcode is 1010. The
results of the trivial tests show that the line can neither be trivally rejected or accepted. Point E is
determined to be an outside point, so the algorithm clips the line against the bottom edge of the
window. Now line EI has been clipped to be line FI. Line FI is tested and cannot be trivially
accepted or rejected. Point F has an outcode of 0000, so the algorithm chooses point I as an
outside point since its outcode is1010. The line FI is clipped against the window's top edge,
yielding a new line FH. Line FH cannot be trivally accepted or rejected. Since H's outcode is
0010, the next iteration of the algorthm clips against the window's right edge, yielding line FG.
The next iteration of the algorithm tests FG, and it is trivially accepted and display.
After Clipping (Output): - After clipping the segments AD and EI, the result is that only the line
segment AB and FG can be seen in the window.
Source Code: /*
---------------------------------------------------------------Cohen Sutherland Algorithm for Line clipping
---------------------------------------------------------------*/
#include <iostream.h>
#include <stdio.h>
#include <conio.h>
FILE *fp;
class clipping
{private:
int x;
int y;
int code[4];
public:
clipping();
void getxy(char p[5]);
void encode(int left,int right,int bottom,int top);
int getcode(int k);
float getx(void);
float gety(void);
friend int accept(clipping p1,clipping p2);
friend int reject(clipping p1,clipping p2);
friend void swap_points(clipping &p1,clipping &p2);
int point_inside(void);
void clipping::operator =(clipping p2);
void changex(int winy,float m);
void changey(int winx,float m);
};
clipping::clipping()
{
int i;
x = 0;
y = 0;
for(i=0;i<4;i++)
code[i] = 0;
}
float clipping::getx(void)
{
return(x);
}
float clipping::gety(void)
{
return(y);
}
void clipping::getxy(char p[5])
{
cout << "\nEnter the coordinates of point " << p;
cout << "\nX :- ";
fscanf(fp,"%d",&x);
cout << "\nY :- ";
fscanf(fp,"%d",&y);
}
void clipping::encode(int left,int right,int bottom,int top)
{
if(x < left)
code[0] = 1;
else
code[0] = 0;
if (x > right)
code[1] = 1;
else
code[1] = 0;
if (y > bottom)
code[2] = 1;
else
code[2] = 0;
if (y < top)
code[3] = 1;
else
code[3] = 0;
}
int clipping::getcode(int k)
{
if (code[k] == 1)
return(1);
return(0);
}
int accept(clipping p1,clipping p2)
{
int k;
for(k=0;k<4;k++)
if (p1.getcode(k) || p2.getcode(k))
return(0);
return(1);
}
int reject(clipping p1,clipping p2)
{
int k;
for(k=0;k<4;k++)
if (p1.getcode(k) && p2.getcode(k))
return(1);
return(0);
}
int clipping::point_inside(void)
{
if (code[0] || code[1] || code[2] || code[3])
return(0);
return(1);
}
void clipping::operator =(clipping p2)
{
int i;
x = p2.x;
y = p2.y;
for (i=0;i<4;i++)
code[i] = p2.code[i];
}
void swap_points(clipping &p1,clipping &p2)
{
clipping tmp;
tmp = p1;
p1 = p2;
p2 = tmp;
}
void clipping::changex(int winy,float m)
{
x = x + (winy - y) / m;
y = winy;
}
void clipping::changey(int winx,float m)
{
y = y + (winx - x) * m;
x = winx;
}
void main()
{
int driver = DETECT,mode;
initgraph(&driver,&mode,"c:\\tc\\bgi");
clipping p1,p2,tmp;
int left,top,right,bottom,done=0,draw=0;
float m;
fp = fopen("cohensut.in","r");
clearviewport();
p1.getxy("p1");
p2.getxy("p2");
left = getmaxx() / 2 - 50;
right = getmaxx() / 2 + 50;
bottom = getmaxy() / 2 + 50;
top = getmaxy() / 2 - 50;
clearviewport();
rectangle(left,top,right,bottom);
line(p1.getx(),p1.gety(),p2.getx(),p2.gety());
while(done == 0)
{
p1.encode(left,right,bottom,top);
p2.encode(left,right,bottom,top);
if (accept(p1,p2))
{
done = 1;
draw = 1;
}
else if (reject(p1,p2))
{
done = 1;
}
else
{
if (p1.point_inside())
swap_points(p1,p2);
m = (p2.gety() - p1.gety()) / (p2.getx() - p1.getx());
if(p1.getcode(0))
p1.changey(left,m);
else if(p1.getcode(1))
p1.changey(right,m);
else if (p1.getcode(2))
p1.changex(bottom,m);
else if (p1.getcode(3))
p1.changex(top,m);
}
cout << "\nPress any key to continue...\n";
getch();
clearviewport();
}
if (draw)
{
}
getch();
}
Conclusion: Cohen Sutherland algorithm is easy to implement algorithm to clip the given line against
rectangle window.
2. Liang Barsky Algorithm for Line Clipping: LBA Algorithm:

1. Read two endpoints of the line say P1(X1, Y1) and p2(X2, Y2).
2. Read two corners of the window,(left-top and right-bottom) say(Xwmin,Ywmax,Xwmax,Ywmin).
3. Calculate the values of parameters Pi and Qi for i=1,2,3,4 such that
P1 = -X
Q1 = X1 - Xwmin
P2 = X
Q2 = Xwmax - X1
P3 = -Y
Q3 = Y1 - Ywmin
P4 = Y
Q4 = Ywmax - Y1
4. If Pi = 0, then
{
The line is parallel to ith boundary.
Now, if Qi<0, then
{
Line is completely outside the boundary; hence discard the line segment and goto
stop.
}
Else
{
Check wether the line is horizonatal or vertical and accordingly check the line
endpoint with corresponding bounadaries. If line endpoint/s lie within the bounaded area then to
draw line otherwise use boundary co-ordinates to draw line. Go to stop.
}
}
5. Initialize value for t1, t2 as t1 = 0, t2 = 1.
6. Calculate values for Qi/Pi for i=1,2,3,4
7. Select value of Qi/Pi where Pi<0 and assign maximum out of them as t1.
8. Select value of Qi/Pi where Pi>0 and assign minimum out of them as t2.
9. If(t1<t2)
{
Calutte the endpoint of the clipped line as follows:
XX1 = X1+t1X
XX2 = X1+t2X
YY1 = Y1+t1Y
YY2 = Y1+t2Y
Draw line (XX1, YY1, XX2, and YY2)
}
10. Stop.
Source Code: /*
---------------------------------------------------------------Liang Barsky Algorithm for Line Clipping
---------------------------------------------------------------*/
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<math.h>
#define false 0
#define true 1
FILE *fin = fopen ("cosuth.in","r");
float u1,u2,dx,dy;
float t1,t2,t3,t4,t5,t6;
class point
{
int x,y;
int code[4];
public:
void getxy()
{
fscanf(fin,"%d %d",&x,&y);
}
void putxy(int x1,int y1)
{
x = x1;
y = y1;
}
void friend clipline(point p1,point p2);
int friend cliptest(float p,float q,float *u1,float *u2);
void friend drawline(point p1,point p2);
}p1,p2,pt[20],winmin,winmax;
void clipline(point p1,point p2)
{
rectangle(80,420,426,160);
u1 = 0.0;
u2 = 1.0;
dx
t1
t2
t3
t4
t5
=
=
=
=
=
=
p2.x - p1.x;
p1.x - winmin.x;
winmax.x - p1.x;
p1.y - winmin.y;
winmax.y - p1.y;
-1 * dx;
if (cliptest(t5,t1,&u1,&u2) == 1)
{
if (cliptest(dx,t2,&u1,&u2) == 1)
{
dy = float(p2.y - p1.y);
t6 = -1 * dy;
if (cliptest(t6,t3,&u1,&u2) == 1)
{
if (cliptest(dy,t4,&u1,&u2) == 1)
{
if (u1 > 0.0)
{
(int)p1.x = p1.x + (u1
(int)p1.y = p1.y + (u1
}
if (u2 < 1.0)
{
(int)p2.x = p1.x + (u2
(int)p2.y = p1.y + (u2
}
}
}
}
}
drawline(p1,p2);
getch();
}
int cliptest(float p,float q,float *u1,float *u2)
{
float r;
int flag;
flag = 1;
* dx);
* dy);
* dx);
* dy);
if (p < 0.0)
{
r = (float) q / p;
if (r > *u2)
{
flag = 0;
}
else
{
if (r > *u1)
{
*u1 = r;
}
}
}
else
{
if (p > 0.0)
{
r = (float) q / p;
if (r < *u1)
{
flag = 0;
}
else
{
if (r < *u2)
{
*u2 = r;
}
}
}
else
{
if (q < 0.0)
{
flag = 0;
}
}
}
return(flag);
}
void drawline(point p1,point p2)
{
line(p1.x,p1.y,p2.x,p2.y);
}
void main()
{
int drv=DETECT,mode,totalpoint,i;
clrscr();
printf("\nHow many line will be on the screen : ");

fscanf(fin,"%d",&totalpoint);
for(i = 0;i < totalpoint ; i++)
{
printf("\nEnter their x and y coordinates of %d point:\n",i+1);
pt[i].getxy();
}
initgraph(&drv,&mode,"c:\\Borlandc\\bgi");
winmin.putxy(80,160);
winmax.putxy(420,426);
rectangle(80,420,426,160);
i = 0;
do
{
drawline(pt[i],pt[i+1]);
i++;
}
while(i < totalpoint-1);
getch();
clearviewport();
i = 0;
do
{
clipline(pt[i],pt[i+1]);
i++;
}
while(i < totalpoint-1);
getch();
}
3. Nicol Lee Nicol Algorithm for Line Clipping: Write NLN algorithm of particular position of P1 we set up the regions for P2 as listed below:
Case1: for P1 in window: Region is L, T, R, and B
Case 2: for P1 iin edge region: Regions are L, LT, LR and LB
Case3: for P1 in corner region: Region is T, L, TB, LR, or LB
L Ray intersections left boundary
T Ray intersections top boundary
B Ray intersections bottom boundary
R Ray intersections right boundary
LT Ray intersections left and top boundary
LR Ray intersections left and right boundary
LB Ray intersections left and bottom boundary
TR Ray intersections top and right boundary
TB Ray intersections top and bottom boundary
Source Code: /*
---------------------------------------------------------------Nicol Lee Nicol Algorithm for Line Clipping
---------------------------------------------------------------*/
#
#
#
#
include
include
include
include
<stdio.h>
<conio.h>
<graphics.h>
<math.h>
int xmin,ymin,xmax,ymax;
void main()
{
int x1,y1,x2,y2;
int findRegionP1(int,int);
void clipline1(int,int,int,int);
int ch;
float m;
clrscr();
printf("\nEnter the xmin:->");
scanf("%d",&xmin);
printf("\nEnter the ymin:->");
scanf("%d",&ymin);
printf("\nEnter the xmax:->");
scanf("%d",&xmax);
printf("\nEnter the ymax:->");
scanf("%d",&ymax);
initgraph(&gdriver, &gmode, "C:\\TC\\BGI");
setcolor(15);
rectangle(xmin,ymin,xmax,ymax);
printf("Enter the x1:->");
scanf("%d",&x1);
printf("Enter the y1:->");
scanf("%d",&y1);
printf("Enter the x2:->");
scanf("%d",&x2);
printf("Enter the y2:->");
scanf("%d",&y2);
setcolor(12);
line(x1,y1,xmin,ymin);
line(x1,y1,xmax,ymin);
line(x1,y1,xmax,ymax);
line(x1,y1,xmin,ymax);
getch();
setcolor(3);
line(x1,y1,x2,y2);
getch();
ch=first_end_point_region(x1,y1);
switch(ch)
{
case 1:
clipline1(x1,y1,x2,y2);
break;
case 2:
break;
case 3:
break;
default:
printf("\nInvalid select of the option: ");
}
getch();
}
int first_end_point_region(int x,int y)
{
/*
u have two equations:xmin <= x <= xmax;
ymin <= y <= ymax; */
if(x>=xmin && x<=xmax && y>=ymin && y<=ymax)
return 1;
else if(x<xmin && y>=ymin && y<=ymax)
return 2;
else if(x<=xmin && y<=ymin)
return 3;
else
return 0;
}
/* point p1 is inside the clip window */
void clipline1(int x1,int y1,int x2,int y2)
{
int draw=1;
float m,m1,m2,m3,m4;
int nx1,ny1,nx2,ny2;
/* calculate slopes for all the lines passing thru vertices
and including the input line :- */
m=((float)(y2-y1))/(x2-x1);
m1=((float)(ymin-y1))/(xmin-x1);
m2=((float)(ymin-y1))/(xmax-x1);
m3=((float)(ymax-y1))/(xmax-x1);
m4=((float)(ymax-y1))/(xmin-x1);
nx1=x1;
ny1=y1;
// point p2 is on top
if(((abs(m)>=m1 && x2<x1) || (abs(m)>abs(m2) && x2>x1)) && y1>y2)
{
// point p2 is also inside clip window
if(y2>ymin)
{
nx2=x2;
ny2=y2;
}
// point p2 is outside clip window
else
{
ny2=ymin;
nx2=x1+(ymin-y1)/m;
}
}
// point p2 is on right side of clip window
else if(m>m2 && m<m3 && x2>=xmax)
{
// point p2 is inside clip window
if(x2<xmax)
{
nx2=x2;
ny2=y2;
}
else
{
nx2=xmax;
ny2=y1+(xmax-x1)*m;
}
}
// point p2 is on bottom side of clip window
else if((abs(m)>=m3 && x2>x1) || (abs(m)>abs(m4) && x2<x1))
{
// point p2 is inside clip window
if(y2<ymax)
{
nx2=x2;
ny2=y2;
}
else
{
ny2=ymax;
nx2=x1+(ymax-y1)/m;
}
}
// point p2 is on left side of clip window
else if(m>m4 && m<m1)
{
// point p2 is inside the clip window
if(x2>xmin)
{
nx2=x2;
ny2=y2;
}
// point p2 is outside the clip window
else
{
nx2=xmin;
ny2=y1+(xmin-x1)*m;
}
}
else
draw=0;
getch();
cleardevice();
setcolor(18);
if(draw)
{
setcolor(12);
setcolor(5);
line(nx1,ny1,nx2,ny2);
}
}
/* Point p1 is in the edge region */
{
int draw=1;
float m,m1,m2,m3,m4;
m=((float)(y2-y1))/(x2-x1);
// Point p2 is in Left-Top region
if(m>m1 && m<m2)
{
// Point p2 is inside the clip window
if(y2>ymin)
{
nx1=xmin;
ny1=y1+m*(xmin-x1);
nx2=x2;
ny2=y2;
}
// Point p2 is outside the clip window
else
{
nx1=xmin;
ny1=y1+m*(xmin-x1);
ny2=ymin;
nx2=x1+(ymin-y1)/m;
}
}
// Point p2 is in Left-Right region
{

if(x2<xmax)
{
nx1=xmin;
ny1=y1+m*(xmin-x1);
nx2=x2;
ny2=y2;
}
else
{
nx1=xmin;
ny1=y1+m*(xmin-x1);
nx2=xmax;
ny2=y1+(xmax-x1)*m;
}
}
// Point p2 is in Left-Bottom region
{
if(y2<ymax)
{
nx1=xmin;
ny1=y1+m*(xmin-x1);
nx2=x2;
ny2=y2;
}
else
{
nx1=xmin;
ny1=y1+m*(xmin-x1);
ny2=ymax;
nx2=x1+(ymax-y1)/m;
}
}
else
draw=0;
getch();
cleardevice();
setcolor(18);
if(draw)
{
setcolor(12);
setcolor(5);
}
}
/* Point p1 is in the Corner Region */

{
int draw=1;
float m,m1,m2,m3,m4,tm1,tm2;
int flag,t;
tm1=((float)(ymin-y1))/(xmin-x1);
tm2=((float)(ymax-ymin))/(xmax-xmin); //diagonal slope
m=((float)(y2-y1))/(x2-x1);
// Point p1 is towards the left side of the clip window (case2)
if(tm1<tm2)
{
flag=2;
t=m2;
m2=m3;
m3=t;
}
// Point p1 is towards the top side of the clip window (case1)
else
flag=1;
// Point p2 is in the Top-Right region
if(m>m1 && m<m2)
{
if(x2>xmax && y2>ymin)
{
ny1=ymin;
nx1=x1+(ymin-y1)/m;
nx2=xmax;
ny2=y1+m*(xmax-x1);
}
else if(y2>ymin && x2<xmax)
{
ny1=ymin;
nx1=x1+(ymin-y1)/m;
ny2=y2;
nx2=x2;
}
}
// Point p2 is Left-Right or Top-Bottom region
{
// Point p2 is in Top-Bottom region (case1)
if(flag==1)
{
if(y2>=ymax)
{
ny1=ymin;
nx1=x1+(ymin-y1)/m;
nx2=x1+(ymax-y1)/m;
ny2=ymax;
}
else if(y2>=ymin)
{
ny1=ymin;
nx1=x1+(ymin-y1)/m;
nx2=x2;
ny2=y2;
}
}
// Point p2 is in Left-Right region (case2)
else
{
if(x2>=xmax)
{
nx1=xmin;
ny1=y1+m*(xmin-x1);
nx2=xmax;
ny2=y1+m*(xmax-x1);
}
else if(x2>=xmin)
{
nx1=xmin;
ny1=y1+m*(xmin-x1);
nx2=x2;
ny2=y2;
}
}
}
// Point p2 is in Left-Bottom region
{
if(y2>=ymax)
{
nx1=xmin;
ny1=y1+m*(xmin-x1);
nx2=x1+(ymax-y1)/m;
ny2=ymax;
}
else if(y2>=ymin)
{
nx1=xmin;
ny1=y1+m*(xmin-x1);
ny2=y2;
nx2=x2;
}
}
else
draw=0;
getch();
cleardevice();
setcolor(18);
if(draw)
{
setcolor(12);
setcolor(5);
}
}
4. Sutherland Hodgemann Algorithm for Polygon clipping: Sutheland Hodgemann Algorithem:

1.
2.
3.
4.
5.
Read co-ordinates of all vetices of the polygon.

Read co-ordinates of the clipping window.
Consider the left edge of the window.
Compare the vetices of each edge of the polygon, individually with the clipping plane.
Save the resulting intersections and vertices in the new list of vertices according to four
possible relationships between the edge and the clipping boundary discussed earlier.
6. Repeat the step 4 and 5 for remaining edge of the clipping window. Each time the resultant list
of vertices is successively passed to process the next edge of the clipping window.
7. Stop.
Source Code: /*
---------------------------------------------------------------Sutherland Hodgemann Algorithm for Polygon clipping
---------------------------------------------------------------*/
#include<stdio.h>
#include<conio.h>
#define ROUND(a) ((int)(a+0.5))
#define n 4
#define
#define
#define
#define
LEFT_EDGE 0x1
RIGHT_EDGE 0x2
BOTTOM_EDGE 0x4
TOP_EDGE 0x8
#define INSIDE(a) (!a)

#define REJECT(a,b) (a&b)
#define ACCEPT(a,b) (!(a|b))
typedef struct wcpt2

{
int x,y;
}wcpt2;
typedef struct dcpt
{
int x,y;
}dcpt;
void main()
{
int gd=DETECT,gm;
int left,top,right,bottom;
int x1,x2,y1,y2;
int maxx, maxy;
/* our polygon array */
int poly[10];
void clipline(dcpt,dcpt,wcpt2,wcpt2);
clrscr();
initgraph(&gd,&gm,"c:\\tc30\\bgi");
maxx = getmaxx()/4;
maxy = getmaxy()/4;
poly[0] = 20;
poly[1] = maxy / 2;
/* 1st vertex */
poly[2] = maxx - 10; /* 2nd */

poly[3] = 10;
poly[4] = maxx - 50; /* 3rd */
poly[5] = maxy - 20;
poly[6] = maxx / 2;
poly[7] = maxy / 2;
/*
/* 4th */
drawpoly doesn't automatically close

the polygon, so we close it.
*/
poly[8] = poly[0];
poly[9] = poly[1];
/* draw the polygon */
drawpoly(5, poly);
rectangle(20,25,80,125);
wcpt2 pt1,pt2;
dcpt winmin,winmax;
winmin.x=20;
winmin.y=25;
winmax.x=80;
winmax.y=125;
pt1.x=20;
pt1.y=maxy/2;
pt2.x=maxx-10;
pt2.y=10;
//
clipline(winmin,winmax,pt1,pt2);
int i=0;
for(int index=0;index<n;index++)
{
if(index==n-1)
{
pt1.x=poly[i];
pt1.y=poly[i+1];
i=0;
pt2.x=poly[i];
pt2.y=poly[i+1];
}
else
{
pt1.x=poly[i];
pt1.y=poly[i+1];
pt2.x=poly[i+2];
pt2.y=poly[i+3];
}
i+=2;
}
pt1.x=poly[i];
pt1.y=poly[i+1];
getch();
}
unsigned char encode(wcpt2 pt,dcpt winmin,dcpt winmax)
{
unsigned char code=0x00;
if(pt.x < winmin.x)
code=code | LEFT_EDGE;
if(pt.x > winmax.x)
code=code | RIGHT_EDGE;
if(pt.y < winmin.y)
code=code | TOP_EDGE;
if(pt.y > winmax.y)
code=code | BOTTOM_EDGE;
return code;
}
void swappts(wcpt2 *p1,wcpt2 *p2)
{
wcpt2 tmp;
tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
void swapcode(unsigned char *c1,unsigned char *c2)
{
unsigned char tmp;
tmp = *c1;
*c1 = *c2;
*c2 = tmp;
}
void clipline(dcpt winmin,dcpt winmax,wcpt2 p1,wcpt2 p2)
{
unsigned char encode(wcpt2,dcpt,dcpt);
unsigned char code1,code2;
int done = 0 , draw = 0;
float m;
void swapcode(unsigned char *c1,unsigned char *c2);
void swappts(wcpt2 *p1,wcpt2 *p2);
while(!done)
{
code1 = encode(p1,winmin,winmax);
code2 = encode(p2,winmin,winmax);
if(ACCEPT(code1,code2))
{
draw = 1;
done = 1;
}
else if(REJECT(code1,code2))
done = 1;
else if(INSIDE(code1))
{
swappts(&p1,&p2);
swapcode(&code1,&code2);
}
if(code1 & LEFT_EDGE)
{
p1.y += (winmin.x - p1.x) *
p1.x);
p1.x = winmin.x;
}
else if(code1 & RIGHT_EDGE)
{
p1.y += (winmax.x - p1.x) *
p1.x);
p1.x = winmax.x;
}
else if(code1 & TOP_EDGE)
{
if(p2.x != p1.x)
p1.x += (winmin.y - p1.y) *
p1.y);
p1.y = winmin.y;
(p2.y - p1.y) / (p2.x -
(p2.y - p1.y) / (p2.x -
(p2.x - p1.x) / (p2.y -
}
else if(code1 & BOTTOM_EDGE)
{
if(p2.x != p1.x)
p1.x += (winmax.y - p1.y) *
p1.y);
p1.y = winmax.y;
}
}
if(draw)
{
setcolor(5);
line(p1.x,p1.y,p2.x,p2.y);
}
}
(p2.x - p1.x) / (p2.y -

CG Lab Manual

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

CG Lab Manual

Uploaded by

Copyright:

Available Formats

Practical-1

Aim: Study of various C graphics functions

Value Columns x Rows

Segment Register which in our consideration

Basic Concept of Mouse Handling

Before the interrupt

After the interrupt

Get Mouse Status

AX Value = FFFFh support is available.

Show Mouse Pointer

Hide Mouse Pointer

Mouse Button Press

Set Horizontal Limit

Set Vertical Limit

Get Mouse Coordinates

if abs (dx) > abs (dy) then steps := abs (dx)

void DDALine(int x1,int y1,int x2,int y2,int iColor)

and now substitute using

so for zero (k = 0, xk = 0 and yk = 0), we get:

Figure 1 Circle scan-converted with Midpoint algorithm.

x2 + y2 - r2. We know that

Figure 3 Midpoint Circle Algorithm

With ve(Negative) P1k

With ve(Negative) P2k

Source Code: /* ------------------------------------------------------------MidEllipse

Source Code: /* ---------------------------------------------------------------Boundary Fill (8 Connected Point)

PolygonPoints[iCnt][1] = (480 - PolygonPoints[iCnt][1]);

Case : 2 Reflection about the y axis

Data Structure: none.

How Algorithm works?

2. Liang Barsky Algorithm for Line Clipping: LBA Algorithm:

printf("\nHow many line will be on the screen : ");

// Point p2 is inside the clip window

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

4. Sutherland Hodgemann Algorithm for Polygon clipping: Sutheland Hodgemann Algorithem:

Read co-ordinates of all vetices of the polygon.

#define INSIDE(a) (!a)

typedef struct wcpt2

poly[2] = maxx - 10; /* 2nd */

drawpoly doesn't automatically close

(p2.y - p1.y) / (p2.x -

(p2.y - p1.y) / (p2.x -

(p2.x - p1.x) / (p2.y -

(p2.x - p1.x) / (p2.y -

You might also like