LAB MANUAL

COMPUTER GRAPHICS
 Table of Contents
S.No Name of Experiment Page No

Digital Differential Analyzer Algorithm

1 1

Bresenham’s Line Drawing Algorithm

2 4

Midpoint Circle Generation Algorithm

3 8

Ellipse Generation Algorithm

4 12

Creating various types of texts and fonts

5 16

Creating two dimensional objects

6 18

Two Dimensional Transformations

7 24

Coloring the Pictures

8 36

Three Dimensional Transformations

9 51

Curve Generation
10 58

11 Simple Animations using transformations 61

12 Key Frame Animation 75

13 VIVA Questions 86

14 Practice Exercises 94

Graphics.h Wikipedia 95
 Hardware and Software Requirements

For implementing graphics concepts in C-Language:

1. Software Requirement:

Turbo C / C++ compiler that supports graphics.h package.

special DOSBOXed installer for Turbo C++ compiler

Download from following links:
http://www.megaleecher.net/Download_Turbo_For_Windows

2. Minimum hardware requirements:

  Intel Pentium III800 MHz Processor or higher version

  Intel chipset 810 mother board or higher version
  14’’ color monitor or greater than that
  Mouse
  Keyboard
  2GB HDD or greater
 256 MB RAM or greater

For doing key frame animation:

Software Requirements: Adobe Flash Professional version 6 .

Download Adobe Flash CS6 which contains Flash Professional Also and install

Hardware Requirements:

 Intel® Pentium® 4, Intel Centrino®, Intel Xeon®, or Intel Core™ Duo (or
 compatible) processor
  Microsoft® Windows® 7 (64 bit) or Windows 8 (64 bit)
  4GB of RAM
 2.5GB of available hard-disk space for installation; additional free space
 required during installation (cannot install on removable flash storage devices)
  1024x768 display (1280x800 recommended)
 QuickTime 10.x software recommended
 Basic Structure of a C-graphics program:

#include<stdio.h>

#include<graphics.h>//must be included for every graphics program

#include<conio.h>

#include<dos.h> //for including delay function.

void main()

int gd=DETECT,gm; //gd=detects best available graphics driver, gm =graphics

mode. initgraph(&gd,&gm,”C:\\TurboC3\\BGI”);// for initializing graph mode

// above 2 steps are must for every graphics program.

//declaration of any variables must be done before calling initgraph() function.

// next write code for producing requiring design or drawing object

line(100,100,200,200);//draws a line segment.

getch();

}
 Experiment – 1
Digital Differential Analyzer Algorithm

1 :Digital differential analyzer (DDA) is used for linear interpolation of variables over an interval between
given start, end points and for rasterization of lines, triangles and polygons. Using DDA Algorithm, Write
a C-Program to draw a line segment between two given points?

Aim: To implement DDA Algorithm for drawing a line segment between two given end points A (x1, y1)
and B(x2, y2).

Description: DDA algorithm is an incremental scan conversion method. Here we perform calculations
at each step using the results from the preceding step. The characteristic of the DDA algorithm is to take
unit steps along one coordinate and compute the corresponding values along the other coordinate. The
unit steps are always along the coordinate of greatest change, e.g. if dx = 10 and dy = 5, then we would
take unit steps along x and compute the steps along y. In DDA we need to consider two cases;

One is slope of the line less than or equal to one (|m| ≤1) and slope of the line greater than one (m|
> 1).
1)When |m| ≤ 1 means y2-y1 = x2-x1 or y2-y1 <x2-x1.In both these cases we assume x to be the
major axis. Therefore we sample x axis at unit intervals and find the y values corresponding to each x
value. We have the slope equation as
∆y=m∆x
y2-y1 = m (x2-x1)
In general terms we can say that y i+1 - yi = m(x i+1 - xi ). But here ∆ x = 1; therefore the equation
reduces to y i+1= yi + m = yi + dy/dx.
2) When | m| > 1 means y2-y1> x2-x1 and therefore we assume y to be the major axis. Here we sample
y axis at unit intervals and find the x values corresponding to each y value. We have the slope equation
as
∆y=m∆x
y2-y1 = m (x2-x1)
Algorithm:
1. Start.
2. Declare variables x,y,x1,y1,x2,y2,k,dx,dy,s,xi,yi and also
declare gdriver=DETECT, mode.
3. Initialize the graphic mode with the path location in TurboC3 folder.
4. Input the two line end-points and store the left end-points in (x1,y1).
5. Load (x1, y1) into the frame buffer; that is, plot the first point. put x=x1,y=y1.
6. Calculate dx=x2-x1 and dy=y2-y1.
7. If abs (dx) > abs (dy), do s=abs(dx).
8. Otherwise s= abs(dy).
9. Then xi=dx/s and yi=dy/s.
10. Start from k=0 and continuing till k<s,the points will be
i. x=x+xi.
ii. Y=y+yi.
11. Plot pixels using putpixel at points (x,y) in specified colour.
12. Close Graph and stop.

1
Program:

#include<stdio.h>
#include<graphics.h>
#include<math.h>
float round(float a);
void main()
{
int gd=DETECT,gm;
// gd=graphics driver (detects best graphics driver and assigns it as default, gm=graphics
mode.
int x1,y1,x2,y2,steps,k;
float xincr,yincr,x,y,dx,dy;
printf("enter x1,y1");
scanf("%d%d",&x1,&y1);
printf("enter x2,y2");
scanf("%d%d",&x2,&y2);
initgraph(&gd,&gm,"c:\\turboc3\\BGI");//initializes the graph
dx=x2-x1;
dy=y2-y1;
if(abs(dx)>abs(dy))
steps=abs(dx);
else
steps=abs(dy);
xincr=dx/steps;
yincr=dy/steps;
x=x1;
y=y1;
for(k=1;k<=steps;k++)
{
delay(100);//for seeing the line drawing process slowly.
x+=xincr;
y+=yincr;
putpixel(round(x),round(y),WHITE);
}
outtextxy(200,20,"DDA"); // for printing text at desired screen location.
outtextxy(x1+5,y1-5,"(x1,y1)");
outtextxy(x2+5,y2+5,"(x2,y2)");
getch();
closegraph(); // closes the graph and comes back to previous graphic mode.
}
float round(float a)
{
int b=a+0.5;
return b;
}

2
Output:

3
 Experiment 2
Bresenham’s Line Drawing Algorithm

2: Bresenham’s line algorithm is an algorithm which determines which order to form a close
approximation to a straight line between two given points. Write a C program for determining pixel
activation list between two given points in order to draw line segment using bresenham’s Line
drawing algorithm?

Aim: To implement Bresenham’s line drawing algorithm for drawing a line segment between
two given endpoints A (x1, y2) and B(x2, y2).

Description:
Basic Concept:

Move across the x axis in unit intervals and at each step choose between two
different y coordinates


For example, from position (2, 3) we have to choose between (3, 3) and (3, 4). We
would like the point that is closer to the original line


So we have to take decision to choose next point. So next pixels are selected based
 on
the value of decision parameter p. The equations are given in below algorithm.

4
Algorithm:

BRESENHAM’S LINE DRAWING ALGORITHM

1. Input the two line end-points, storing the left end-point in (x0, y0)

2. Plot the point (x0, y0)

3. Calculate the constants Δx, Δy, 2Δy, and (2Δy - 2Δx) and get the first value for the
decision parameter as:

p 0  2 y x
4. At each xk along the line, starting at k = 0, perform the following test. If pk < 0, the next
point to plot is (xk+1, yk ) and:

p k 1 p k 2 y

Otherwise, the next point to plot is (xk+1, yk+1) and:

p k 1 p k 2 y 2 x

5. Repeat step 4 (Δx – 1) times

NOTE: The algorithm and derivation above assumes slopes are less than 1. For other
slopes we need to adjust the algorithm slightly

5
Program:

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
void main()
{
int x,y,x1,y1,x2,y2,p,dx,dy;
int gd=DETECT,gm;
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
printf("\nEnter the x-coordinate of the first point ::");
scanf("%d",&x1);
printf("\nEnter the y-coordinate of the first point ::");
scanf("%d",&y1);
printf("\nEnter the x-coordinate of the second point ::");
scanf("%d",&x2);
printf("\nEnter the y-coordinate of the second point ::");
scanf("%d",&y2);
x=x1;
y=y1;
dx=x2-x1;
dy=y2-y1;
putpixel(x,y,2);
p=(2*dy-dx);
while(x<=x2)
{
if(p<0)
{
x=x+1;
p=p+2*dy;
}
else
{
x=x+1;
y=y+1;
p=p+(2*dy)-(2*dx);
}
putpixel(x,y,7);
}
getch();
closegraph();
}

6
Output:

7
 Experiment-3
Midpoint Circle Generation Algorithm

3: Using Midpoint circle generation algorithm which is a variant of Bresenham's line algorithm, write a C-
Program to generate pixel activation list for drawing a circle with a given centre of circle P(x, y) and a
radius r?

Aim: To implement midpoint circle generation algorithm or bresenham’s circle algorithm for drawing a
circle of given center (x, y) and radius r.

Description:

Circles have the property of being highly symmetrical, which is handy when it comes to
drawing them on a display screen.
 We know that there are 360 degrees in a circle. First we see that a circle is symmetrical about the x
 axis, so only the first 180 degrees need to be calculated.
 Next we see that it's also symmetrical about the y axis, so now we only need to calculate the first 90
 degrees.
 Finally we see that the circle is also symmetrical about the 45 degree diagonal axis, so we only need to
 calculate the first 45 degrees.
 We only need to calculate the values on the border of the circle in the first octant. The other values
may be determined by symmetry.

Bresenham's circle algorithm calculates the locations of the pixels in the first 45 degrees. It assumes that
the circle is centered on the origin. So for every pixel (x, y) it calculates, we draw a pixel in each of the eight
octants of the circle. This is done till when the value of the y coordinate equals the x coordinate. The pixel
positions for determining symmetry are given in the below algorithm.


Assume that we have just
plotted point (xk, yk)


The next point is a
choice between (xk +1,
yk) and (xk+1, yk-1)


We would like to choose
the point that is nearest

to the actual circle


So we use decision 
parameter here to decide.
8

VARDHAMAN COLLEGE OF ENGINEERING CSE Department

 Algorithm:

1. Input radius r and circle centre (xc, yc), then set the coordinates for the first point on the
circumference of a circle centred on the origin as:

( x 0 , y 0 ) ( 0 , r )
2. Calculate the initial value of the decision parameter as:

5
p 0 4 r
3. Starting with k = 0 at each position xk, perform the following test. If pk < 0, the next point
along the circle centred on (0, 0) is (xk+1, yk) and:

p k 1 p k 2 x k 1 1

Otherwise the next point along the circle is (xk+1, yk-1) and:

p k 1p k 2 x k 1 1 2 y k 1

4. Determine symmetry points in the other seven octants
5. Move each calculated pixel position (x, y) onto the circular path centred at (xc, yc) to plot the
coordinate values:
6. Repeat steps 3 to 5 until x >= y

x x x c y y y c

Symmetric pixel positions:

  putpixel(xc+x,yc-y,GREEN); //For pixel (x,y)

  putpixel(xc+y,yc-x, GREEN); //For pixel (y,x)
  putpixel(xc+y,yc+x, GREEN); //For pixel (y,-x)
  putpixel(xc+x,yc+y, GREEN); //For pixel (x,-y)
  putpixel(xc-x,yc+y, GREEN); //For pixel (-x,-y)
  putpixel(xc-y,yc+x, GREEN); //For pixel (-y,-x)
  putpixel(xc-y,yc-x, GREEN); //For pixel (-y,x)
 putpixel(xc-x,yc-y, GREEN); //For pixel (-x,y)

VARDHAMAN COLLEGE OF ENGINEERING CSE Department

Program:

#include<dos.h>
#include<stdio.h>
#include<conio.h>
#include<graphics.h>
void draw_circle(int,int,int);
void symmetry(int,int,int,int);
void main()
{
int xc,yc,R;
int gd=DETECT,gm;
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
printf("Enter the center of the circle:\n");
printf("Xc =");
scanf("%d",&xc);
printf("Yc =");
scanf("%d",&yc);
printf("Enter the radius of the circle :");
scanf("%d",&R);
draw_circle(xc,yc,R);
getch();
closegraph();
}

void draw_circle(int xc,int yc,int rad)

{
int x = 0;
int y = rad;
int p = 1-rad;
symmetry(x,y,xc,yc);
for(x=0;y>x;x++)
{
if(p<0)
p += 2*x + 3;
else
{
p += 2*(x-y) + 5;
y--;
}
symmetry(x,y,xc,yc);
delay(50);
}
}

void symmetry(int x,int y,int xc,int yc)

{
putpixel(xc+x,yc-y,GREEN); //For pixel (x,y)
delay(50);
putpixel(xc+y,yc-x, GREEN); //For pixel (y,x)
delay(50);
putpixel(xc+y,yc+x, GREEN); //For pixel (y,-x)

10
 delay(50);
putpixel(xc+x,yc+y, GREEN); //For pixel (x,-y)
delay(50);
putpixel(xc-x,yc+y, GREEN); //For pixel (-x,-y)
delay(50);
putpixel(xc-y,yc+x, GREEN); //For pixel (-y,-x)
delay(50);
putpixel(xc-y,yc-x, GREEN); //For pixel (-y,x)
delay(50);
putpixel(xc-x,yc-y, GREEN); //For pixel (-x,y)
delay(50);
}

Output:

11
 Experiment 4
Ellipse Generation Algorithm

4: Using Midpoint ellipse generation algorithm which is a variant of Bresenham's line algorithm, write a C-
Program to generate pixel activation list for drawing a ellipse?

Aim: To implement the Ellipse Generation Algorithm for drawing an ellipse of given center(x, y) and radius
rx and ry.

Description:

Basic Concept: In Ellipse,

Symmetry between quadrants exists

Not symmetric between the two octants of a quadrant

Thus, we must calculate pixel positions along the elliptical arc through one quadrant and then we
obtain positions in the remaining 3 quadrants by symmetry

The next pixel is chosen based on the decision parameter. The required conditions are given in following
algorithm.

12
 Algorithm:

1. Input rx, ry, and ellipse center (xc, yc), and obtain the first point on an ellipse centered on
the origin as

(x0, y0) = (0, ry)

2. Calculate the initial parameter in region 1 as

p 10 r y2 r x2 r y 14 rx2

3. At each xi position, starting at i = 0, if p1i < 0, the next point along the ellipse centered on (0,
0) is (xi + 1, yi) and
p1 p1 2r2x r 2
i 1 i y i1 y

Otherwise, the next point is (xi + 1, yi – 1) and

p1 p1 2r2x 2r2y r2

i 1 i y i 1 x i1 y

and continue until 2 r 2 x 2 r 2 y

y x

4. (x0, y0) is the last position calculated in region 1. Calculate the initial parameter in region 2 as

p 2 0 r y2 ( x 0 12 ) 2 r x2 ( y 0 1) 2 r x2 ry2

5. At each yi position, starting at i = 0, if p2i > 0, the next point along the ellipse centered on
(0, 0) is (xi, yi – 1) and

p2 p2 2r2y r2

i 1 i x i 1 x

p2
Otherwise, the next point is (xi + 1, yi – 1) and i 1  p 2 i 2 r y2 x i 1 2 r x2 y i1 rx2
Use the same incremental calculations as in region 1. Continue until y = 0.

6. For both regions determine symmetry points in the other three quadrants.

7. Move each calculated pixel position (x, y) onto the elliptical path centered on (xc, yc) and
plot the coordinate values

x = x + xc , y = y + yc

13

VARDHAMAN COLLEGE OF ENGINEERING CSE Department

Program:

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<math.h>
void disp();
float x,y;
int xc,yc;
void main()
{
int gd=DETECT,gm;
int rx,ry;
float p1,p2;
clrscr();
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
printf("Enter the center point :");
scanf("%d%d",&xc,&yc);
printf("Enter the value for Rx and Ry :");
scanf("%d%d",&rx,&ry);
x=0;
y=ry;
disp();
p1=(ry*ry)-(rx*rx*ry)+(rx*rx)/4;
while((2.0*ry*ry*x)<=(2.0*rx*rx*y))
{
x++;
if(p1<=0)
p1=p1+(2.0*ry*ry*x)+(ry*ry);
else
{
y--;
p1=p1+(2.0*ry*ry*x)-(2.0*rx*rx*y)+(ry*ry);
}
disp();
x=-x;
disp();
x=-x;
}
x=rx;
y=0;
disp();
p2=(rx*rx)+2.0*(ry*ry*rx)+(ry*ry)/4;
while((2.0*ry*ry*x)>(2.0*rx*rx*y))
{
y++;
if(p2>0)
p2=p2+(rx*rx)-(2.0*rx*rx*y);
else
{
x--;

14
 p2=p2+(2.0*ry*ry*x)-(2.0*rx*rx*y)+(rx*rx);
}
disp();
y=-y;
disp();
y=-y;
}
getch();
closegraph();
}
void disp()
{
delay(50);
putpixel(xc+x,yc+y,10);
putpixel(xc-x,yc+y,10);
putpixel(xc+x,yc-y,10);
putpixel(xc-x,yc-y,10);
}

Output:

15

VARDHAMAN COLLEGE OF ENGINEERING CSE Department

 Experiment- 5
Creating various types of texts and fonts

5: Using different graphics functions available for text formatting in C-Language, Write a C program for
displaying text in different sizes, different colors, different font styles?

Aim: To write a C-program for displaying text in different sizes, different colors and different font styles by
using graphics functions.

Description:

The following graphics functions are available for text formatting in C.

1. Outtext()---------for displaying text on output screen

2. Outtextxy()------for displaying text on output screen at location (x,y).
3. Settextstyle()---used for specifying font style, font display direction(vertical or horizontal), font size.
4. Setcolor()--------setcolor function is used to change the current drawing color.e.g. setcolor(RED) or
setcolor(4) changes the current drawing color to RED. Remember that default drawing color is WHITE.

Outtext: outtext function displays text at current position.

Eg: outtext("To display text at a particular position on the screen use outtextxy");

Outtextxy(): outtextxy function display text or string at a specified point(x,y) on the screen.
Eg: outtextxy(100, 100, "Outtextxy function");--displays the message "Outtextxy function"
At screen location of (100, 100).

Settextstyle():Settextstyle function is used to change the way in which text appears, using it we can
modify the size of text, change direction of text and change the font of text.
Eg: settextstyle(font,direction,charsize);--settextstyle(TRIPLEX_FONT,HORIZ_DIR,2);
Font –font style- it may be font name or integer value from 0- 9.

Different fonts are: Directions are two. Character

size(0-9)

DEFAULT_FONT,
TRIPLEX_FONT, 1. Horizontal direction(HORIZ_DIR or 0)
SMALL_FONT, 2. Vertical direction(VERT_DIR or 1)
SANS_SERIF_FONT,
GOTHIC_FONT,
SCRIPT_FONT,
SIMPLEX_FONT,
TRIPLEX_SCR_FONT,
COMPLEX_FONT,
EUROPEAN_FONT,
BOLD_FONT

16
Program:

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
void main()
{
int gd=DETECT,gm,x=25,y=25,font=10;
initgraph(&gd,&gm,"C:\\turboC3\\BGI");
for(font=0;font<=4;font++)
{
settextstyle(font,HORIZ_DIR,font+1);// sets font type, font direction, size
setcolor(font+1); // sets color for text.
outtextxy(x,y,"text with different fonts"); // prints message on screen at (x,y)
y=y+25;
}
for(font=0;font<=2;font++)
{
settextstyle(font,VERT_DIR,font+2);
setcolor(font+1);
x=250;
y=100;
outtextxy(x,y,"text in vertical direction");
y=y+25;
}
getch();
closegraph();
}
Output:

17
 Experiment- 6
Creating two dimensional objects

6: Using certain graphic functions available in C-language for drawing lines, rectangles & circles, Write a C-
Program which generates pixel activation list for drawing the following simple two dimensional objects
(Circle, Ellipse…..).

i) House ii) Car iii) Fish iv) man?

Aim: To write a C-program for creating simple two dimensional shape of house, car, fish, man using lines,
circles etc.

Description:

The following graphics functions are available for creating two dimensional shapes in C.

line
circle
ellipse
rectangle
drawpoly

line: line function is used to draw a line from a point(x1,y1) to point(x2,y2) i.e. (x1,y1) and (x2,y2)
are end points of the line.
Declaration: - line(x1, y1, x2, y2); ---line (100,200,300,400);

Circle: Circle function is used to draw a circle with center (x, y) and third parameter specifies
the radius of the circle.
Declaration: circle(x, y, r)—circle (100, 200, 25) ;( 25 is radius of circle, (100,100) is center
of circle).

Ellipse: Ellipse is used to draw an ellipse (x, y) are coordinates of center of the ellipse, startangle
is the starting angle, endangle is the ending angle, and fifth and sixth parameters specifies the X
and Y radius of the ellipse. To draw a complete ellipse strangles and end angle should be 0 and
360 respectively.
Usage: ellipse(x, y, startangle, endangle, xradius, yradius);--ellipse(100,200,0,360,25,45);((100,200) is
center of ellipse, 0 is start angle, 360 is end angle, 25 is x-axis radius, 45 is radius circle).

Rectangle: rectangle function is used to draw a rectangle. Coordinates of left top and right
bottom corner are required to draw the rectangle. left specifies the X-coordinate of top left
corner, top specifies the Y-coordinate of top left corner, right specifies the X-coordinate of right
bottom corner, bottom specifies the Y-coordinate of right bottom corner.

Syntax: rectangle(left,top,right,bottom);--rectangle(100,200,300,400);

18
Drawpoly: Drawpoly function is used to draw polygons i.e. triangle, rectangle, pentagon,
hexagon etc.

Syntax: drawpoly( num,points );--num indicates number of vertices of polygon. Num = num+1.

Example: we will draw a triangle using drawpoly, consider for example the array
:-int points[] = { 320, 150, 420, 300, 250, 300, 320, 150};

points array contains coordinates of triangle which are (320, 150), (420, 300) and (250, 300).
Note that last point(320, 150) in array is same as first.

Number of vertices are denoted by num. for any polygon, number of vertices are (num+1). For
triangle, number of vertices are 4.

i) Program for creating House shape:

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
void main()
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"C:\\TURBOC3\\BGI");
setcolor(5);
rectangle(60,80,150,200);
rectangle(95,140,120,200);
line(60,80,100,15);
line(100,15,150,80);
circle(100,60,10);
getch();
closegraph();
}
Output:

19
ii) Program for creating simple car shape:

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<dos.h>
void main()
{
int gd = DETECT, gm;
initgraph(&gd, &gm, "C:\\TurboC3\\BGI");
cleardevice();
line( 150, 100, 242, 100);
ellipse(242, 105, 0, 90, 10,
5); line(150, 100, 120, 150);
line(252, 105, 280, 150);
line(100, 150, 320, 150);
line(100, 150, 100, 200);
line(320, 150, 320, 200);
line(100, 200, 110, 200); line(
320, 200, 310, 200); arc(130,
200, 0, 180, 20); arc( 290,
200, 0, 180, 20); line( 270,
200, 150, 200); circle(130,
200, 17); circle(290, 200, 17);
getch();

Output:

20
 iii)Program for creating fish:

#include<stdlib.h>
#include<conio.h>
#include<dos.h>
#include<graphics.h>
#include<ctype.h>

void main()
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
cleardevice();
ellipse(520,200,30,330,90,30);
circle(450,193,3);
line(430,200,450,200);
line(597,185,630,170);
line(597,215,630,227);
line(630,170,630,227);
line(597,200,630,200);
line(597,192,630,187);
line(597,207,630,213);
line(500,190,540,150);
line(530,190,540,150);

getch();
}
Output:

21
iv)Program for creating man object:

#include<stdio.h>
#include<graphics.h>
#include<conio.h>
void main()
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
setcolor(9);
circle(150,150,35);
line(150,185,150,300);
line(150,200,120,230);
line(150,200,180,230);
line(150,300,120,330);
line(150,300,180,330);
outtextxy(230,350,"HI, This is Computer Graphics");
getch();
}

Output:

22
 Sample program illustrating the use drawpoly() function:

Aim: To draw a triangle using drawpoly() function.

Description:
Using drawpoly (), we can draw any polygon of any number of vertices.

Syntax: drawpoly (num, points);--num indicates number of vertices of polygon. Num = num+1.
Example: we will draw a triangle using drawpoly, consider for example the array:-
int points[] = { 320, 150, 420, 300, 250, 300, 320, 150};
1) Points array contains coordinates of triangle which are (320, 150), (420, 300) and (250, 300).
Note that last point (320, 150) in array is same as first.
2) Number of vertices is denoted by num. for any polygon, numbers of vertices are (num+1).
For triangle, number of vertices are 4.

Program:
#include <graphics.h>
#include <conio.h>

main()
{
int gd=DETECT,gm,points[]={320,150,420,300,250,300,320,150};
initgraph(&gd, &gm, "C:\\TurboC3\\BGI");
drawpoly(4, points);
getch();
closegraph(); return
0;
}
Output:

23
 Experiment 7
Two Dimensional Transformations

7: Write a C-program for performing the basic 2D transformations such as translation, Scaling, Rotation,
shearing and reflection for a given 2D object?

Aim: To apply the basic 2D transformations such as translation, Scaling, Rotation, shearing and reflection for
a given 2D object.

Description: We have to perform 2D transformations on 2D objects. Here we perform transformations on a

line segment.

The 2D transformations are:

1. Translation
2. Scaling
3. Rotation
4. Reflection
5. Shear

1. Translation: Translation is defined as moving the object from one position to another position
along straight line path.

We can move the objects based on translation distances along x and y axis. tx denotes translation
distance along x-axis and ty denotes translation distance along y axis.

Translation Distance: It is nothing but by how much units we should shift the object from one location
to another along x, y-axis.
Consider (x,y) are old coordinates of a point. Then the new coordinates of that same point (x’,y’) can
be obtained as follows:
X’=x+tx
Y’=y+ty
We denote translation transformation as P. we express above equations in matrix form as:

x,y---old coordinates
x’,y’—new coordinates after
translation
tx,ty—translation distances, T is

24
 2. Scaling: scaling refers to changing the size of the object either by increasing or decreasing. We will
increase or decrease the size of the object based on scaling factors along x and y-axis.

If (x, y) are old coordinates of object, then new coordinates of object after applying scaling
transformation are obtained as:
x’=x*sx
y’=y*sy.
sx and sy are scaling factors along x-axis and y-axis. we express the above equations in matrix form as:
 x  s x 0 x
   
s y
 y  0 y  

Scaling Matrix

3. Rotation: A rotation repositions all points in an object along a circular path in the plane centered at the
pivot point. We rotate an object by an angle theta.

New coordinates after rotation depend on both x and y

• x’ = xcosθ -y sinθ
• y’ = xsinθ+ ycosθ
• or in matrix form:
P'=R•P,  cos  sin
R   

R-rotation matrix.  sin  cos 

25
 4. Reflection: Reflection is nothing but producing mirror image of an object. Reflection can be done just
by rotating the object about given axis of reflection with an angle of 180 degrees.

5. Shear:

1. Shear is the translation along an axis by an amount that increases linearly with another axis (Y). It
produces shape distortions as if objects were composed of layers that are caused to slide over
each other.
2. Shear transformations are very useful in creating italic letters and slanted letters from regular
letters.
3. Shear transformation changes the shape of the object to a slant position.

4. Shear transformation is of 2 types:

a. X-shear: changing x-coordinate value and keeping y constant

x’=x+shx*y
y’=y
b. Y-shear: changing y coordinates value and keeping x
constant x’=x
y’=y+shy*x
shx and shy are shear factors along x and y-axis.

26
 1. Program for translation:

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<math.h>
void main()
{
int gd=DETECT,gm;
int x1,y1,x2,y2,tx,ty,x3,y3,x4,y4;
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
printf("Enter the starting point of line segment:");
scanf("%d %d",&x1,&y1);
printf("Enter the ending point of line segment:");
scanf("%d %d",&x2,&y2);
printf("Enter translation distances tx,ty:\n");
scanf("%d%d",&tx,&ty);
setcolor(5);
line(x1,y1,x2,y2);
outtextxy(x2+2,y2+2,"Original line");
x3=x1+tx;
y3=y1+ty;
x4=x2+tx;
y4=y2+ty;
setcolor(7);
line(x3,y3,x4,y4);
outtextxy(x4+2,y4+2,"Line after translation");
getch();
}

Output:

27
 2. Program for
scaling: #include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<math.h>
void main()
{
int gd=DETECT,gm;
float x1,y1,x2,y2,sx,sy,x3,y3,x4,y4;
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");

printf("Enter the starting point coordinates:");

scanf("%f %f",&x1,&y1);
printf("Enter the ending point coordinates:");
scanf("%f %f",&x2,&y2);
printf("Enter scaling factors sx,sy:\n");
scanf("%f%f",&sx,&sy);
setcolor(5);
line(x1,y1,x2,y2);
outtextxy(x2+2,y2+2,"Original line");
x3=x1*sx;
y3=y1*sy;
x4=x2*sx;
y4=y2*sy;
setcolor(7);

line(x3,y3,x4,y4);
outtextxy(x3+2,y3+2,"Line after scaling");
getch();
}
Output:

28
 3. Program for Rotation:

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<math.h>
void main()
{
int gd=DETECT,gm;
float x1,y1,x2,y2,x3,y3,x4,y4,a,t;
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
printf("Enter coordinates of starting point:\n");
scanf("%f%f",&x1,&y1);
printf("Enter coordinates of ending point\n");
scanf("%f%f",&x2,&y2);
printf("Enter angle for rotation\n");
scanf("%f",&a);
setcolor(5);
line(x1,y1,x2,y2);
outtextxy(x2+2,y2+2,"Original line");
t=a*(3.14/180);
x3=(x1*cos(t))-(y1*sin(t));
y3=(x1*sin(t))+(y1*cos(t));
x4=(x2*cos(t))-(y2*sin(t));
y4=(x2*sin(t))+(y2*cos(t));
setcolor(7);
line(x3,y3,x4,y4);
outtextxy(x3+2,y3+2,"Line after rotation");
getch();
}
Output:

29
 4. Program for reflection along x-axis:

# include <stdio.h>
# include <conio.h>
# include <graphics.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);
for (iCnt=0; iCnt<3; iCnt++)
{
line(PolygonPoints[iCnt][0],PolygonPoints[iCnt][1],
PolygonPoints[(iCnt+1)%3][0],PolygonPoints[(iCnt+1)%3][1]);
}
}
void Reflect()
{
float Angle;
int iCnt;
int Tx,Ty;
printf("endl");;
for (iCnt=0; iCnt<3; iCnt++)
PolygonPoints[iCnt][1] = (480 - PolygonPoints[iCnt][1]);
}
void main()
{
int gDriver = DETECT, gMode;
int iCnt;
initgraph(&gDriver, &gMode, "C:\\TurboC3\\BGI");
for (iCnt=0; iCnt<3; iCnt++)
{
PolygonPoints[iCnt][0] += 320;
PolygonPoints[iCnt][1] = 240 - PolygonPoints[iCnt][1];
}
PolyLine();
getch();
Reflect();
PolyLine();
getch();

30
}

Output:
Object before reflection about x-axis

Object after reflection about x-axis:

31
 5. Program for Reflection about y-axis:

# include <stdio.h>
# include <conio.h>
# include <graphics.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);
for (iCnt=0; iCnt<3; iCnt++)
{
line(PolygonPoints[iCnt][0],PolygonPoints[iCnt][1],
PolygonPoints[(iCnt+1)%3][0],PolygonPoints[(iCnt+1)%3][1]);
}
}
void Reflect()
{
float Angle;
int iCnt;
int Tx,Ty;

for (iCnt=0; iCnt<3; iCnt++)

PolygonPoints[iCnt][0] = (640 - PolygonPoints[iCnt][0]);
}

void main()
{
int gd = DETECT, gm;
int iCnt;
initgraph(&gd, &gm, "C:\\TurboC3\\BGI");
for (iCnt=0; iCnt<3; iCnt++)
{
PolygonPoints[iCnt][0] += 320;
PolygonPoints[iCnt][1] = 240 - PolygonPoints[iCnt][1];
}
PolyLine();
getch();
Reflect();
PolyLine();
getch();
}

32
Output:
Object before reflection:

Object after Reflection about y-axis:

33
 6. Program for X-
shear: #include<stdio.h>
#include<conio.h>
#include<dos.h>
#include<graphics.h>

void main()
{
int gd=DETECT,gm;
float shx,shy;
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
printf("Enter shear factor shx along x-axis :");
scanf("%f",&shx);
line(100,0,200,0);
line(200,0,200,200);
line(200,200,100,200);
line(100,200,100,0);
printf("X-shear");
setcolor(12);
line((100+(0*shx)),0,(200+(0*shx)),0);
line((200+(0*shx)),0,(200+(200*shx)),200);
line((200+(200*shx)),200,(100+(200*shx)),200);
line((100+(200*shx)),200,(100+(0*shx)),0);
getch();
}

Output:

In above output, red lined rectangle denotes object after x-shear transformation.

34
 7. Program for Y-shear:

#include<stdio.h>
#include<conio.h>
#include<dos.h>
#include<graphics.h>
void main()
{
int gd=DETECT,gm;
float shx,shy;
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
printf("Enter shear factor shy along y-axis :");
scanf("%f",&shy);
line(100,10,200,10);
line(200,10,200,200);
line(200,200,100,200);
line(100,200,100,10);
printf("Y-shear");
setcolor(12);
line(100,10+(shy*100),200,10+(shy*200));
line(200,10+(shy*200),200,200+(shy*200));
line(200,200+(shy*200),100,200+(shy*100));
line(100,200+(shy*100),100,10+(shy*100));
getch();
closegraph();
}
Output:

red rectangle denotes object after

y-shear.

35
 Experiment-8
Coloring the Pictures

Note: For filling a given picture or object with color’s, we can do it in two ways in C programming.
The two ways are given below:

i. Using filling algorithms such as Floodfill algorithm, Boundary fill algorithm and scanline polygon
fill algorithm, we can color the objects.
ii. Using inbuilt graphics functions such as floodfill(),setfillstyle() we can fill the object with color’s
directly without using any filling algorithm.

8-i: By using the concept of flood fill algorithm, Write a C- program for filling a given rectangle
object with color?

Aim: To implement flood fill algorithm for filling a rectangle with given color.

Description:

Sometimes we want to fill in (recolor) an area that is not defined within a single color boundary. We
paint such areas by replacing a specified interior color instead of searching for a boundary color value.
This approach is called a flood-fill algorithm.
1. We start from a specified interior pixel (x, y) and reassign all pixel values that are currently set to
a given interior color with the desired fill color.
2. If the area has more than one interior color, we can first reassign pixel values so that all interior
pixels have the same color.
3. Using either 4-connected or 8-connected approach, we then step through pixel positions until
all interior pixels have been repainted.

4-connected approach 8-connected approach

36

VARDHAMAN COLLEGE OF ENGINEERING CSE Department

Algorithm:

4-connected approach:

1. We can implement flood fill algorithm by using recursion.

2. First all the pixels should be reassigned to common color. here common color is black.

3. Start with a point inside given object, check the following

condition: if(getpixel(x,y)==old_col)---old_col is common color

4. If above condition is satisfied, then following 4 steps are followed in filling the

object. //Recursive 4-way floodfill.

putpixel(x,y,fill_col);
flood(x+1,y,fill_col,old_col);
flood(x-1,y,fill_col,old_col);
flood(x,y+1,fill_col,old_col);
flood(x,y-1,fill_col,old_col);

8-connected approach:

1. We can implement flood fill algorithm by using recursion.

2. First all the pixels should be reassigned to common color. here common color is black.

3. Start with a point inside given object, check the following

condition: if(getpixel(x,y)==old_col)---old_col is common color

4. If above condition is satisfied, then following 8 steps are followed in filling the object.

//Recursive 4-way floodfill.

putpixel(x,y,fill_col);
flood(x+1,y,fill_col,old_col);
flood(x-1,y,fill_col,old_col);
flood(x,y+1,fill_col,old_col);
flood(x,y-1,fill_col,old_col); flood(x
+ 1, y - 1, fill_col, old_col); flood(x +
1, y + 1, fill_col, old_col); flood(x -
1, y - 1, fill_col, old_col); flood(x - 1,
y + 1, fill_col, old_col);

37
Program for 4-connected flood fill:

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<dos.h>

void flood(int,int,int,int);

void main()
{
int gd,gm=DETECT;
clrscr();
detectgraph(&gd,&gm);
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
rectangle(50,50,100,100);
flood(55,55,9,0);
getch();
}

void flood(int x,int y, int fill_col, int old_col)

{
if(getpixel(x,y)==old_col)
{
delay(10);
putpixel(x,y,fill_col);
flood(x+1,y,fill_col,old_col);
flood(x-1,y,fill_col,old_col);
flood(x,y+1,fill_col,old_col);
flood(x,y-1,fill_col,old_col);
}
}
Output:

38
 Program for 8-connected flood fill:

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<dos.h>
void flood(int,int,int,int);
void main()
{
int gd,gm=DETECT;
clrscr();
detectgraph(&gd,&gm);
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
rectangle(50,50,100,100);
flood(55,55,12,0);
getch();
}
void flood(int x,int y, int fill_col, int old_col)
{
if(getpixel(x,y)==old_col)
{
delay(10);
putpixel(x,y,fill_col);
flood(x+1,y,fill_col,old_col);
flood(x-1,y,fill_col,old_col);
flood(x,y+1,fill_col,old_col);
flood(x,y-1,fill_col,old_col);
flood(x + 1, y - 1, fill_col, old_col);
flood(x + 1, y + 1, fill_col, old_col);
flood(x - 1, y - 1, fill_col, old_col);
flood(x - 1, y + 1, fill_col, old_col);
}
}
Output:

39
 8-ii: By using the concept of Boundary fill algorithm, Write a C- program for filling a given rectangle
object with color?

Aim: To implement Boundary fill algorithm for filling a rectangle with given color.

Description:

 Start at a point inside a region and paint the interior outward toward the boundary.

 If the boundary is specified in a single color, the fill algorithm processed
outward pixel by pixel until the boundary color is encountered.

 A boundary-fill procedure accepts as input the coordinate of the interior point (x, y),
a fill color, and a boundary color.
Algorithm:
The following steps illustrate the idea of the recursive boundary-fill algorithm:
1. Start from an interior point.
2. If the current pixel is not already filled and if it is not an edge point, then set the pixel with the fill
color, and store its neighboring pixels (4 or 8-connected). Store only neighboring pixel that is not already
filled and is not an edge point.
3. Select the next pixel from the stack, and continue with step 2.

In 4 connected approach, we can fill In 8 connected approach, we can fill

an object in only 4 directions. We an object in 8 directions. We have 8
have 4 possibilities for proceeding possibilities for proceeding to next
to next pixel from current pixel. pixel from current pixel.

40
 Program for 4-connected Boundary fill Algorithm:

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<dos.h>
void boundary_fill(int x, int y, int fcolor, int bcolor)
{
if ((getpixel(x, y) != bcolor) && (getpixel(x, y) != fcolor))
{delay(10); putpixel(x, y, fcolor);
boundary_fill(x + 1, y, fcolor, bcolor);
boundary_fill(x - 1, y, fcolor, bcolor);
boundary_fill(x, y + 1, fcolor, bcolor);
boundary_fill(x, y - 1, fcolor, bcolor);
}
}
void main()
{
int x, y, fcolor, bcolor;
int gd=DETECT,gm;
initgraph(&gd, &gm, "C:\\TurboC3\\BGI");
printf("Enter the seed point (x,y) : ");
scanf("%d%d", &x, &y);
printf("Enter boundary color : ");
scanf("%d", &bcolor);
printf("Enter new color : ");
scanf("%d", &fcolor);
circle(100,200,45);
boundary_fill(x,y,fcolor,bcolor);
getch();
}
Output:

41
Program for 8 connected Boundary fill Algorithm:
#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<dos.h>
void boundary_fill(int x, int y, int fcolor, int bcolor)
{

if ((getpixel(x, y) != bcolor) && (getpixel(x, y) != fcolor))

{ delay(10);
putpixel(x, y, fcolor);
boundary_fill(x + 1, y, fcolor, bcolor);
boundary_fill(x , y+1, fcolor, bcolor);
boundary_fill(x+1, y + 1, fcolor, bcolor);
boundary_fill(x-1, y - 1, fcolor, bcolor);
boundary_fill(x-1, y, fcolor, bcolor);
boundary_fill(x , y-1, fcolor, bcolor);
boundary_fill(x-1, y + 1, fcolor, bcolor);
boundary_fill(x+1, y - 1, fcolor, bcolor);

}
}
void main()
{
int x, y, fcolor, bcolor;
int gd=DETECT,gm;
initgraph(&gd, &gm, "C:\\TurboC3\\BGI");
printf("Enter the seed point (x,y) : ");
scanf("%d%d", &x, &y);
printf("Enter boundary color : ");
scanf("%d", &bcolor);
printf("Enter new color : ");
scanf("%d", &fcolor);
rectangle(50,50,100,100);
boundary_fill(x,y,fcolor,bcolor);
getch();
}
Output:

42
 8-iii: By using the concept of Scan line polygon fill algorithm, write a C- program for filling a given object
with color?

Aim: To implement the Scan line polygon fill algorithm for coloring a given object.

Description:

The basic scan-line algorithm is as follows:

  Find the intersections of the scan line with all edges of the polygon
  Sort the intersections by increasing x coordinate
 Fill in all pixels between pairs of intersections that lie interior to the polygon
Process involved:
The scan-line polygon-filling algorithm involves
• the horizontal scanning of the polygon from its lowermost to its topmost vertex,
• identifying which edges intersect the scan-line,
• and finally drawing the interior horizontal lines with the specified fill color process.

Algorithm Steps:
1. the horizontal scanning of the polygon from its lowermost to its topmost vertex
2. identify the edge intersections of scan line with polygon
3. Build the edge table
a. Each entry in the table for a particular scan line contains the maximum y value for
that edge, the x-intercept value (at the lower vertex) for the edge, and the inverse
slope of the edge.
4. Determine whether any edges need to be splitted or not. If there is need to split, split the
edges.
5. Add new edges and build modified edge table.
6. Build Active edge table for each scan line and fill the polygon based on intersection of
scanline with polygon edges.

43
Program for scan line polygon fill algorithm:

#include <stdio.h>
#include <conio.h>
#include <graphics.h>
void main()
{
int n,i,j,k,gd,gm,dy,dx;
int x,y,temp;
int a[20][2],xi[20];
float slope[20];
clrscr();
printf("\n\n\tEnter the no. of edges of polygon : ");
scanf("%d",&n);
printf("\n\n\tEnter the cordinates of polygon :\n\n\n ");
for(i=0;i<n;i++)
{
printf("\tX%d Y%d : ",i,i);
scanf("%d %d",&a[i][0],&a[i][1]);
}
a[n][0]=a[0][0];
a[n][1]=a[0][1];
detectgraph(&gd,&gm);
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
/*- draw polygon -*/
for(i=0;i<n;i++)
{
line(a[i][0],a[i][1],a[i+1][0],a[i+1][1]);
}
getch();
for(i=0;i<n;i++)
{
dy=a[i+1][1]-a[i][1];
dx=a[i+1][0]-a[i][0];
if(dy==0) slope[i]=1.0;
if(dx==0) slope[i]=0.0;
if((dy!=0)&&(dx!=0)) /*- calculate inverse slope -*/
{
slope[i]=(float) dx/dy;
}
}
for(y=0;y< 480;y++)
{
k=0;
for(i=0;i<n;i++)

44
 {

if( ((a[i][1]<=y)&&(a[i+1][1]>y))||
((a[i][1]>y)&&(a[i+1][1]<=y)))
{
xi[k]=(int)(a[i][0]+slope[i]*(y-a[i][1]));
k++;
}
}
for(j=0;j<k-1;j++) /*- Arrange x-intersections in order -*/
for(i=0;i<k-1;i++)
{
if(xi[i]>xi[i+1])
{
temp=xi[i];
xi[i]=xi[i+1];
xi[i+1]=temp;
}
}
setcolor(3);
for(i=0;i<k;i+=2)
{
line(xi[i],y,xi[i+1]+1,y);
getch();
}
}
}
Output:

Filled
polygon

45
 8-iv: Different graphic Functions are available in C-Language for filling a given object with colors. Using
the graphic functions, Write a C program for
i. Filling a circle with any color?
ii. Filling a polygon with any color?

Aim: To fill a given object with colors by using inbuilt graphics functions.

Description:

For filling a given object with colors, we have the following graphics functions.
1. Fillpoly
2. Floodfill
3. Setfillstyle
4. Setcolor
5. fillellipse

Fillpoly: Fillpoly function is used to draw a polygon of any number of vertices and fills that polygon with
colors. It requires same arguments as drawpoly function. fillpoly fills the polygon by using current fill
pattern and color which can be changed using setfillstyle function.

Program illustrating the use of Fillpoly function:

#include <graphics.h>
#include <conio.h>
main()
{
int gd=DETECT,gm,points[]={100,200,120,230,150,260,120,290,100,330,80,290,50,260,80,230,100,200};
initgraph(&gd, &gm, "C:\\TurboC3\\BGI");
setfillstyle(SOLID_FILL,10); //giving the type of fill
fillpoly(9, points); //drawing a polygon of 9 vertices with coordinates defined in points array and filling
with color defined in setfillstyle function.
getch();
closegraph();
return 0;
}
Output:

46
Floodfill: floodfill function is used to fill an enclosed area of an object. Current fill pattern and fill color
is used to fill the area.(x, y) is any point on the screen if (x,y) lies inside the area then inside will be filled
otherwise outside will be filled,border specifies the color of boundary of area. To change fill pattern and
fill color use setfillstyle.
Syntax: floodfill(x,y,boundarycolor);

Program illustrating the use of Floodfill function:

#include<graphics.h>
#include<conio.h>

main()
{
int gd = DETECT, gm;
initgraph(&gd, &gm, "C:\\TurboC3\\BGI");
setcolor(RED);
circle(100,100,50);
floodfill(100,100,RED);
getch();
closegraph();
return 0;
}
Output:

47
 Setfillstyle: setfillstyle function sets the current fill pattern and fill color.
Syntax: setfillstyle( pattern,color);
1) Here, pattern refers to type of filling. The pattern value may be integer value or its corresponding
pattern name in CAPS. The patterns available are listed below:
EMPTY_FILL----0,
SOLID_FILL----1,
LINE_FILL-----2,
LTSLASH_FILL--3,
SLASH_FILL----4,
BKSLASH_FILL--5,
LTBKSLASH_FILL-6,
HATCH_FILL-----7,
XHATCH_FILL----8,
INTERLEAVE_FILL-9,
WIDE_DOT_FILL--10,
CLOSE_DOT_FILL-11,
USER_FILL------12.[ integer value from 0 to 12 refers to its corresponding pattern name]
2) Color refers to fill color .The below table shows color names and their equivalent integer values.

Program illustrating the use of setfillstyle:

#include<graphics.h>
#include<conio.h>
main()
{
int gd = DETECT, gm;
initgraph(&gd, &gm, "C:\\TurboC3\\BGI"); Output
setfillstyle(XHATCH_FILL, RED);
circle(100, 100, 50);
floodfill(100, 100, WHITE);
getch();
closegraph();
}

48
Setcolor: In Turbo Graphics each color is assigned a number. Total 16 colors are available. Strictly
speaking number of available colors depends on current graphics mode and driver.
For Example :- BLACK is assigned 0, RED is assigned 4 etc. setcolor function is used to change the
current drawing color.e.g. setcolor(RED) or setcolor(4) changes the current drawing color to RED. default
drawing color is WHITE.
Syntax: setcolor(color name or its equivalent integer value) –setcolor(GREEN);

Program illustrating the use of setcolor function:

#include<graphics.h>
#include<conio.h>

main()
{
int gd = DETECT, gm;
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
circle(100,100,50); /* drawn in white color */
setcolor(GREEN);
circle(200,200,50); /* drawn in green color */
getch();
closegraph();
return 0;
}

Output:

49
Fill ellipse: This function draws and fills the ellipse with default color White. If we want to fill another
color means, we have to use setfillstyle function.

Syntax: fillellipse( x, y, xradius, yradius);

Program illustrating the use of fillellipse function:

#include<graphics.h>
#include<conio.h>
main()
{
int gd = DETECT, gm;
initgraph(&gd, &gm, "C:\\TurboC3\\BGI");
fillellipse(100, 100, 50, 25);
getch();
closegraph();
return 0;
}

Output:

50
 Experiment 9
Three Dimensional Transformations

9: Write a C-program for performing the basic transformations such as translation, Scaling, Rotation for a
given 3D object?

Aim: To apply the basic transformations such as translation, Scaling, Rotation for a given 3D object.

Description: We have to perform transformations on 3D objects. Here we perform transformations on a

line segment.

The transformations are:

Translation
Scaling
Rotation
Translation: Translation is defined as moving the object from one position to another position
along straight line path.
We can move the objects based on translation distances along x and y axis. tx denotes translation
distance along x-axis and ty denotes translation distance along y axis.
Translation Distance: It is nothing but by how much units we should shift the object from one location
to another along x, y-axis.
Consider (x,y) are old coordinates of a point. Then the new coordinates of that same point (x’,y’) can
be obtained as follows:
X’=x+tx
Y’=y+ty
Z’=z+tz
We denote translation transformation as P.
2. Scaling: scaling refers to changing the size of the object either by increasing or decreasing. We
will increase or decrease the size of the object based on scaling factors along x and y-axis.
If (x, y) are old coordinates of object, then new coordinates of object after applying scaling
transformation are obtained as:
x’=x*sx
y’=y*sy.
Z’=z*sz.
sx ,sy and sz are scaling factors along x-axis, y-axis and z-axis. we express the above equations in matrix
form as:
3. Rotation: A rotation repositions all points in an object along a circular path in the plane centered at
the pivot point. We rotate an object by an angle theta.
The Transformation matrices for above 3D transformations are given below:

51
Program for translation:

#include<stdio.h>
#include<conio.h>
#include<math.h>
#include<process.h>
#include<graphics.h>
int x1,x2,y1,y2,mx,my,depth;
void draw();
void trans();
void main()

int gd=DETECT,gm,c;
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
printf("\n\t\t3D Translation\n\n");
printf("\nEnter 1st top value(x1,y1):");
scanf("%d%d",&x1,&y1);
printf("Enter right bottom value(x2,y2):");
scanf("%d%d",&x2,&y2);
depth=(x2-x1)/4;
mx=(x1+x2)/2;
my=(y1+y2)/2;
draw();
getch();
cleardevice();
trans();
getch();

}
void draw()
{
bar3d(x1,y1,x2,y2,depth,1);
}
void trans()
{

int a1,a2,b1,b2,dep,x,y;
printf("\n Enter the Translation Distances:");
scanf("%d%d",&x,&y);
a1=x1+x;
a2=x2+x;
b1=y1+y;
b2=y2+y;
dep=(a2-a1)/4;
bar3d(a1,b1,a2,b2,dep,1);
setcolor(5);
draw();
}

52
Output for Translation:

53
Program for scaling:
#include<stdio.h>
#include<conio.h>
#include<math.h>
#include<process.h>
#include<graphics.h>
int x1,x2,y1,y2,mx,my,depth;
void draw();
void scale();
void main()
{

int gd=DETECT,gm,c;
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
printf("\n\t\t3D Scaling\n\n");
printf("\nEnter 1st top value(x1,y1):");
scanf("%d%d",&x1,&y1);
printf("Enter right bottom value(x2,y2):");
scanf("%d%d",&x2,&y2);
depth=(x2-x1)/4;
mx=(x1+x2)/2;
my=(y1+y2)/2;
draw();
getch();
cleardevice();
scale();
getch();
}
void draw()
{
bar3d(x1,y1,x2,y2,depth,1);
}
void scale()
{
int x,y,a1,a2,b1,b2,dep;
printf("\n\n Enter scaling Factors:");
scanf("%d%d",&x,&y);
a1=mx+(x1-mx)*x;
a2=mx+(x2-mx)*x;
b1=my+(y1-my)*y;
b2=my+(y2-my)*y;
dep=(a2-a1)/4;
bar3d(a1,b1,a2,b2,dep,1);
setcolor(5);
draw();
}

54
Output For scaling:

55
Program for Rotation:

#include<stdio.h>
#include<conio.h>
#include<math.h>
#include<graphics.h>
int x1,x2,y1,y2,mx,my,depth;
void draw();
void rotate();
void main()
{
int gd=DETECT,gm,c;
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
printf("\n3D Transformation Rotating\n\n");
printf("\nEnter 1st top value(x1,y1):");
scanf("%d%d",&x1,&y1);
printf("Enter right bottom value(x2,y2):");
scanf("%d%d",&x2,&y2);
depth=(x2-x1)/4;
mx=(x1+x2)/2;
my=(y1+y2)/2;
draw(); getch();
cleardevice();
rotate();
getch();
}
void draw()
{
bar3d(x1,y1,x2,y2,depth,1);
}
void rotate()
{
float t;
int a1,b1,a2,b2,dep;
printf("Enter the angle to rotate=");
scanf("%f",&t);
t=t*(3.14/180);
a1=mx+(x1-mx)*cos(t)-(y1-my)*sin(t);
a2=mx+(x2-mx)*cos(t)-(y2-my)*sin(t);
b1=my+(x1-mx)*sin(t)-(y1-my)*cos(t);
b2=my+(x2-mx)*sin(t)-(y2-my)*cos(t);
if(a2>a1)
dep=(a2-a1)/4;
else
dep=(a1-a2)/4;

56
 bar3d(a1,b1,a2,b2,dep,1); setcolor(5);
}

Output:

57
 Experiment 10
Curve Generation

10: Write a C-program for generating a curve for a given set of control points?

Aim: To generate a smooth curve by using Bezier curve technique for a given set of control points.

Description:

A Bézier curve is a parametric curve frequently used in computer graphics and related fields.

Generalizations of Bézier curves to higher dimensions are called Bézier surfaces, of which the Bézier

triangle is a special case.

In vector graphics, Bézier curves are used to model smooth curves that can be scaled indefinitely. "Paths,"

as they are commonly referred to in image manipulation programs are combinations of linked Bézier

curves. Paths are not bound by the limits of rasterized images and are intuitive to modify. Bézier curves are

also used in animation as a tool to control motion

Four points P0, P1, P2 and P3 in the plane or in higher-dimensional space define a cubic Bézier curve. The

curve starts at P0 going toward P1 and arrives at P3 coming from the direction of P2. Usually, it will not pass

through P1 or P2; these points are only there to provide directional information. The distance between P0

and P1 determines "how long" the curve moves into direction P2 before turning towards P3.

58
Program for Bezier curve:

#include <stdio.h>
#include <stdlib.h>
#include <graphics.h>
#include <math.h>
void bezier (int x[4], int y[4])
{
int gd = DETECT, gm;
int i;
double t;
initgraph (&gd, &gm, "C:\\TurboC3\\BGI");
for (t = 0.0; t < 1.0; t += 0.0005)
{
double xt = pow (1-t, 3) * x[0] + 3 * t * pow (1-t, 2) * x[1] +
3 * pow (t, 2) * (1-t) * x[2] + pow (t, 3) * x[3];

double yt = pow (1-t, 3) * y[0] + 3 * t * pow (1-t, 2) * y[1] +

3 * pow (t, 2) * (1-t) * y[2] + pow (t, 3) * y[3];

putpixel (xt, yt, WHITE);

}

for (i=0; i<4; i++)

putpixel (x[i], y[i], YELLOW);
getch();
closegraph();
return;
}

void main()
{
int x[4], y[4];
int i;
printf ("Enter the x- and y-coordinates of the four control points.\n");
for (i=0; i<4; i++)
scanf ("%d%d", &x[i], &y[i]);
bezier (x, y);
}

59
Output:

60
 Experiment-11

Simple animations using transformations

11. Write C-programs for designing simple animations using transformations?

Aim: To develop programs for making simple animations using transformations like rotation, scaling and
translation. The simple animations are given below:

i. Circle moving from left to right and vice versa

ii. Man object moving
iii. Wind mill rotation
iv. Man walking
v. Simple animation of football goal
Description:
For moving any object, we incrementally calculate the object coordinates and redraw the

picture to give a feel of animation by using for loop.

Suppose if we want to move a circle from left to right means, we have to shift the position of

circle along x-direction continuously in regular intervals.

The below programs illustrate the movement of objects by using for loop and also using

transformations like rotation, translation etc.

For windmill rotation, we use 2D rotation concept and formulas.

i. Program for moving circle in different directions

#include<stdio.h>
#include<graphics.h>
#include<conio.h>
#include<dos.h>
void main()
{
int gd=DETECT,gm,i;
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
//for moving circle from left to right,the following loop works
for(i=50;i<=getmaxx();i++)
{
setcolor(3);
setfillstyle(SOLID_FILL,9);
circle(50+i,50,50);
floodfill(52+i,52,3);
delay(20);
cleardevice();
}
//for moving circle from right to left, the following loop
works for(i=getmaxy();i>=0;i--)

61
 {
setcolor(3);
setfillstyle(SOLID_FILL,9);
circle(i,50,50);
floodfill(i+2,52,3);
delay(20);
cleardevice();
}
//for moving circle from top to bottom,the following loop works
for(i=50;i<=getmaxy();i++)
{
setcolor(3);
setfillstyle(SOLID_FILL,9);
circle(50,i,50);
floodfill(52,i+2,3);
delay(20);
cleardevice();
}
//for moving circle from bottom to top,the following loop works
for(i=getmaxy();i>=0;i--)
{
setcolor(3);
setfillstyle(SOLID_FILL,9);
circle(50,i,50);
floodfill(52,i+2,3);
delay(20);
cleardevice();
}
//for moving circle in diagonal direction,the following loop works
for(i=50;i<=getmaxx();i++)
{
setcolor(3);
setfillstyle(SOLID_FILL,9);
circle(i,i,50);
floodfill(i+2,i+2,3);
delay(20);
cleardevice();
}
//for moving circle in reverse diagonal direction,the following loop works
for(i=getmaxx();i>=0;i--)
{
setcolor(3);
setfillstyle(SOLID_FILL,9);
circle(i,i,50);
floodfill(i+2,i+2,3);
delay(20);
cleardevice();
}

getch();
}

62
Output for moving circle:

63
ii. program for man object moving:
#include<stdio.h>
#include<graphics.h>
#include<conio.h> #include<dos.h>

void main()
{
int gd=DETECT,gm,i;
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
//creation of man object by using
circle,line. setcolor(7);
setfillstyle(SOLID_FILL,10); circle(50,50,30);
// drawing head floodfill(52,52,7);

setcolor(13);
line(50,80,50,200); //drawing
body line(50,110,20,140); //left
hand line(50,110,80,140); //right
hand line(50,200,20,230); //left
leg line(50,200,80,230); //right leg
// for loop for moving man
for(i=50;i<=getmaxx();i++)
{
setcolor(7);
setfillstyle(SOLID_FILL,10);
circle(i,50,30); // drawing head
floodfill(i+2,52,7); setcolor(13);
line(i,80,i,200); //drawing body
line(i,110,i-30,140); //left hand
line(i,110,i+30,140); //right
hand line(i,200,i-30,230); //left
leg line(i,200,i+30,230); //right
leg cleardevice();

delay(10);
}
//doing simple animation using translation
for(i=50;i<=getmaxx()/2;i++)
{
setcolor(7);
setfillstyle(SOLID_FILL,10);
circle(i,50,30); // drawing head
floodfill(i+2,52,7); setcolor(13);
line(i,80,i,200); //drawing body
line(i,110,i-30,140); //left hand
line(i,110,i+30,140); //right
hand line(i,200,i-30,230); //left
leg line(i,200,i+30,230); //right
leg cleardevice(); delay(10);

64
 getch();
}
output for man moving:

65
iii.program for windmill rotation:
#include<stdio.h>
#include<graphics.h>
#include<math.h>
void wind(float x[7],float y[7]);
void main()
{
int gd=DETECT,gm;
float x[7],y[7],maxx,maxy,xw1,yw1,xw2,yw2;
float theta=30;
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
maxx=getmaxx();
maxy=getmaxy();
x[0]=maxx/2;
y[0]=maxy/2;
x[1]=y[4]=x[2]=-90;
y[6]=y[5]=y[1]=60;
y[2]=35;
y[3]=-100;
x[4]=20;
x[3]=0;
x[5]=90;
x[6]=65;
theta=theta*22/7/180;
while(kbhit()==0)
{
wind(x,y);
xw1=cos(theta)*x[1]+sin(theta)*y[1];
yw1=-sin(theta)*x[1]+cos(theta)*y[1];
xw2=cos(theta)*x[2]+sin(theta)*y[2];
yw2=-sin(theta)*x[2]+cos(theta)*y[2];
x[1]=xw1;
y[1]=yw1;
x[2]=xw2;
y[2]=yw2;
xw1=cos(theta)*x[3]+sin(theta)*y[3];
yw1=-sin(theta)*x[3]+cos(theta)*y[3];
xw2=cos(theta)*x[4]+sin(theta)*y[4];
yw2=-sin(theta)*x[4]+cos(theta)*y[4];
x[3]=xw1;
y[3]=yw1;
x[4]=xw2;
y[4]=yw2;
xw1=cos(theta)*x[5]+sin(theta)*y[5];
yw1=-sin(theta)*x[5]+cos(theta)*y[5];
xw2=cos(theta)*x[6]+sin(theta)*y[6];
yw2=-sin(theta)*x[6]+cos(theta)*y[6];
x[5]=xw1;
y[5]=yw1;
x[6]=xw2;
y[6]=yw2;

66
 delay(50);
cleardevice();
}
closegraph();
}

void wind(float x[7],float y[7])

{
cleardevice();
line(x[0],y[0],x[0]-50,y[0]+200);
line(x[0],y[0],x[0]+50,y[0]+200);
line(x[0]-60,y[0]+200,x[0]+60,y[0]+200);
line(x[0],y[0],x[0]+x[1],y[0]-y[1]);
line(x[0],y[0],x[0]+x[2],y[0]-y[2]);
line(x[0]+x[1],y[0]-y[1],x[0]+x[2],y[0]-y[2]);
line(x[0],y[0],x[0]+x[3],y[0]-y[3]);
line(x[0],y[0],x[0]+x[4],y[0]-y[4]);
line(x[0]+x[3],y[0]-y[3],x[0]+x[4],y[0]-y[4]);
line(x[0],y[0],x[0]+x[5],y[0]-y[5]);
line(x[0],y[0],x[0]+x[6],y[0]-y[6]);
line(x[0]+x[5],y[0]-y[5],x[0]+x[6],y[0]-y[6]);
}
Output:

67
iv. program for man walking:
#include<stdio.h>
#include<dos.h>
#include<conio.h>
#include<graphics.h>
#include<stdlib.h>

void main()
{
int gd = DETECT, gm = DETECT, c = -200, i = 0, x = 40, l = 15, h = 15, ht =
0; initgraph(&gd, &gm, "C:\\TurboC3\\BGI"); cleardevice();

setcolor(BROWN);
line(0, 201, 600, 201);
cont:
while (!kbhit()) {
setcolor(4);
ellipse(x, 100, 0, 180, 50, 30);
line(x - 50, 100, x + 50, 100);
line(x, 100, x, 150);
circle(x - 20, 115, 15);
line(x - 20, 130, x - 20, 175);
line(x - 20, 175, x - 20 - l, 200);
line(x - 20, 175, x - 20 + l, 200);
line(x - 20, 140, x, 150);
line(x - 20, 140, x - 20 - h, 160);
setcolor(0);
delay(50);
ellipse(x, 100, 0, 180, 50, 30);
line(x - 50, 100, x + 50, 100);
line(x, 100, x, 150);
circle(x - 20, 115, 15);
line(x - 20, 130, x - 20, 175);
line(x - 20, 175, x - 20 - l, 200);
line(x - 20, 175, x - 20 + l, 200);
line(x - 20, 140, x, 150);
line(x - 20, 140, x - 20 - h, 160);
line(x + 50, 100, x + 50, 200);
x++;
l--;
if (l == -15)
l = 15;
if (ht == 1)
h++;
else
h--;

if (h == 15)
ht = 0;
else if (h == -15)
ht = 1;

68
 }
if (getch() == ' ') {
while (!kbhit());
getch();
goto cont;
}
}
Output:

69
vi. program for simple animation of football goal:
#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<dos.h>
void main()
{
int x=0,gd=DETECT,gm,points[]={0,220,1600,220,1600,900,0,900,0,220};
float y=0;
initgraph(&gd,&gm,"C:\\TURBOC3\\BGI");
setcolor(MAGENTA);
settextstyle(6,HORIZ_DIR,6);
outtextxy(200,250,"Hi"); delay(1000);
cleardevice(); settextstyle(7,VERT_DIR,1);
outtextxy(200,50,"GET READY FOR
ANIMATION"); delay(1000);

cleardevice();
setcolor(GREEN);
setfillstyle(SOLID_FILL,GREEN);
fillpoly(5,points);
setcolor(WHITE);
circle(100,100,25);
delay(1000);
line(100,125,100,185);
delay(1000);
line(100,135,125,170);
delay(1000);
line(100,135,75,170);
delay(1000);
line(100,185,125,220);
delay(1000);
line(100,185,75,220);
delay(1000); setcolor(RED);
setfillstyle(SOLID_FILL,RED);
fillellipse(135+x,210-y,10,10);
for(x=0;x<50;x++)

{
setcolor(WHITE);
line(100,185,75+x,220-
y); delay(100);
setcolor(BLACK);
line(100,185,75+x,220-
y); y=y+0.25;
}
setcolor(WHITE);
line(100,185,125,220);
line(100,185,75,220);

70
for(x=0,y=0;y<100;x++)
{
setcolor(RED);
setfillstyle(SOLID_FILL,RED);
fillellipse(135+x,210-y,10,10);
delay(10);
setcolor(GREEN);
setfillstyle(SOLID_FILL,GREEN);
fillpoly(5,points);
setcolor(BLACK);
setfillstyle(SOLID_FILL,BLACK);
fillellipse(135+x,210-y,10,10);
y=y+0.5;
}
for(;x<490;x++)
{
setcolor(RED);
setfillstyle(SOLID_FILL,RED);
fillellipse(135+x,y,10,10);
delay(10);
setcolor(BLACK);
setfillstyle(SOLID_FILL,BLACK);
fillellipse(135+x,y,10,10);
y=y+0.25;
}
setcolor(RED);
setfillstyle(SOLID_FILL,RED);
fillellipse(135+x,y,10,10);
delay(2000);
cleardevice();
setbkcolor(CYAN);
settextstyle(3,HORIZ_DIR,10);
outtextxy(200,80,"GOAL");
getch();
closegraph();
}

Output:

71
72
73
74