MAHARAJA

SURAJMAL INSTITUTE

Practical IX - CG Lab
(BCA 351)

Submitted By: Submitted To:

NAME : Ritik Kumar Mr. Kumar Gaurav

ROLL NUMBER : 07114902018 Associate Professor
COURSE : BCA 5​TH​ SEMESTER Deptt. Of Computer Science
SECTION : ‘B’
Q1. Write a program to draw a hut.

Source Code:

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

int main() {
int gd = DETECT, gm;
initgraph(&gd,&gm,"C:\\TURBOC3\\BGI");
setcolor(WHITE);
rectangle(150,180,250,300);
rectangle(250,180,420,300);
rectangle(180,250,220,300);
line(200,100,150,180);
line(200,100,250,180);
line(200,100,370,100);
line(370,100,420,180);

setfillstyle(SOLID_FILL, BROWN);
floodfill(152,182,WHITE);
floodfill(252,182,WHITE);
setfillstyle(SLASH_FILL, BLUE);
floodfill(182,252,WHITE);
setfillstyle(HATCH_FILL, GREEN);
floodfill(200,105,WHITE);
floodfill(210,105,WHITE);
getch();
closegraph();
return 0;
}
Output:
Q2. Write a program to draw a face.

Source Code:

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

int main() {
int gr = DETECT, gm;
initgraph(&gr, &gm, "C:\\TURBOC3\\BGI");
setcolor(YELLOW);
circle(300, 100, 40);
setfillstyle(SOLID_FILL, YELLOW);
floodfill(300, 100, YELLOW);
setcolor(BLACK);
setfillstyle(SOLID_FILL, BLACK);
fillellipse(310, 85, 2, 6);
fillellipse(290, 85, 2, 6);
ellipse(300, 100, 205, 335, 20, 9);
ellipse(300, 100, 205, 335, 20, 10);
ellipse(300, 100, 205, 335, 20, 11);
getch();
closegraph();
return 0;
}
Output:
Q3. Write a program to implement Bresenham’s Line Drawing Algorithm.

Source Code:

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
void drawline(int,int,int,int);
int main()
{
clrscr();
int gdriver=DETECT, gmode, error, x0, y0, x1, y1;
initgraph(&gdriver, &gmode, "C:\\TurboC3\\BGI");
printf("Enter coordinates of first point(X1 Y1): ");
scanf("%d %d", &x0, &y0);
printf("Enter coordinates of second point(X2 Y2): ");
scanf("%d %d", &x1, &y1);
drawline(x0, y0, x1, y1);
getch();
return 0;
}
void drawline(int x0, int y0, int x1, int y1) {
int dx, dy, p, x, y;
dx=x1-x0;
dy=y1-y0;
x=x0;
y=y0;
p=2*dy-dx;
while(x=0) {
putpixel(x,y,7);
y=y+1;
p=p+2*dy -2*dx;
}
else {
putpixel(x,y,7);
p=p+2*dy;
}
x=x+1;
}
}
Output:
Q4. Write a program on scan converting lines using the MidPoint Circle
Algorithm.

Source Code:

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

void midPointCircleDraw(int x_centre, int y_centre, int r) {

int x = r, y = 0;
printf("(%d, %d) ", x + x_centre, y + y_centre);
if (r > 0) {
printf("(%d, %d) ", x + x_centre, -y + y_centre);
printf("(%d, %d) ", y + x_centre, x + y_centre);
printf("(%d, %d)\n", -y + x_centre, x + y_centre);
}
int P = 1 - r;
while (x > y) {
y++;
if (P <= 0)
P = P + 2*y + 1;
else {
x--;
P = P + 2*y - 2*x + 1;
}
if (x < y)
break;
printf("(%d, %d) ", x + x_centre, y + y_centre);
printf("(%d, %d) ", -x + x_centre, y + y_centre);
printf("(%d, %d) ", x + x_centre, -y + y_centre);
printf("(%d, %d)\n", -x + x_centre, -y + y_centre);
if (x != y) { printf("(%d, %d) ", y + x_centre, x + y_centre);
printf("(%d, %d) ", -y + x_centre, x + y_centre);
printf("(%d, %d) ", y + x_centre, -x + y_centre);
printf("(%d, %d)\n", -y + x_centre, -x + y_centre);
}
}
}
int main()
{
midPointCircleDraw(0, 0, 3);
return 0;
}

Output:
Q5. Write a program on scan converting lines using Bresenham’s Circle
Drawing Algorithm.

Source Code:

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

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

{
putpixel(xc+x, yc+y, RED);
putpixel(xc-x, yc+y, RED);
putpixel(xc+x, yc-y, RED);
putpixel(xc-x, yc-y, RED);
putpixel(xc+y, yc+x, RED);
putpixel(xc-y, yc+x, RED);
putpixel(xc+y, yc-x, RED);
putpixel(xc-y, yc-x, RED);
}
void circleBres(int xc, int yc, int r)
{
int x = 0, y = r;
int d = 3 - 2 * r;
drawCircle(xc, yc, x, y);
while (y >= x)
{ x++;
if (d > 0)
{
y--;
d = d + 4 * (x - y) + 10;
}
else
d = d + 4 * x + 6;
drawCircle(xc, yc, x, y);
delay(50);
}
}
int main()
{
int xc = 50, yc = 50, r = 30;
int gd = DETECT, gm;
initgraph(&gd, &gm, "C://TURBOC3//BGI");
circleBres(xc, yc, r);
return 0;
}

Output:
Q6. Write a program to implement the Ellipse Drawing Algorithm.

Source Code:

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
void disp();
float x,y;
int xc,yc;
void main()
{
int gd=DETECT,gm,a,b;
float p1,p2;
clrscr();
initgraph(&gd,&gm,"C:\\TURBOC3\\BGI");
printf("*** Ellipse Generating Algorithm ***\n");
printf("Enter the value of Xc\t");
scanf("%d",&xc);
printf("Enter the value of yc\t");
scanf("%d",&yc);
printf("Enter X axis length\t");
scanf("%d",&a);
printf("Enter Y axis length\t");
scanf("%d",&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;
disp();
 x=-x;
delay(50);
}
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;
disp();
y=-y;
delay(50);
}
getch();
closegraph();
}
void disp()
{
putpixel(xc+x,yc+y,7);
putpixel(xc-x,yc+y,7);
putpixel(xc+x,yc-y,7);
putpixel(xc+x,yc-y,7);
}
Output:
Q7. Write a program to implement 2D Translation.

Source Code:

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

int main() {
int i,a,gd=DETECT,gm;
int x1,x2,x3,x4,y1,y2,y3,y4,x,y,r;
initgraph(&gd,&gm,"C:\\TURBOC3\\BGI");
printf("Enter the coordinates: ");
printf("\n Enter x1: ");
scanf("%d",&x1);
printf("\n Enter y1: ");
scanf("%d",&y1);
printf("\n Enter x2: ");
scanf("%d",&x2);
printf("\n Enter y2: ");
scanf("%d",&y2);
setcolor(2);
line(x1,y1,x2,y2);
printf("\n Enter the new translation factor: ");
printf("\n Enter x: ");
scanf("%d", &x);
printf("\n Enter y: ");
scanf("%d", &y);
x1 = x1 + x;
y1 = y1 + y;
x2 = x2 + x;
y2 = y2 + y;
setcolor(3);
line(x1,y1,x2,y2);
getch();
closegraph();
}
Output:
Q8. Write a program to implement translation in 2D using Circle.

Source Code:

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

int main() {
int x,y,r,x1,y1;
int gd=DETECT,gm;
initgraph(&gd,&gm,"C:\\TURBOC3\\BGI");
printf("Enter the coordinates of Circle: ");
printf("\nEnter x: ");
scanf("%d", &x);
printf("Enter y: ");
scanf("%d", &y);
printf("Enter radius: ");
scanf("%d", &r);
setcolor(2);
circle(x,y,r);
printf("Enter the coordinates of translation: ");
printf("\nEnter x: ");
scanf("%d", &x1);
printf("Enter y: ");
scanf("%d", &y1);
x = x + x1;
y = y + y1;
setcolor(3);
circle(x,y,r);
getch();
closegraph();
}
Output:
Q9. Write a program to perform rotation in 2D.

Source Code:

#include<stdio.h>
#include<graphics.h>
#include<math.h>
#include<process.h>
#include<conio.h>
#include<dos.h>
void TriAngle(int x1,int y1,int y2,int x2,int x3,int y3);
void Rotate(int x1,int y1,int x2,int y2,int x3,int y3);
void main() {
int gd=DETECT,gm;
int x1,y1,x2,y2,x3,y3;
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
printf("enter the first point of the triangle:");
scanf("%d%d",&x1,&y1);
printf("enter the 2nd point for the triangle:");
scanf("%d%d",&x2,&y2);
printf("enter the 3rd point for the triangle:");
scanf("%d%d",&x3,&y3);
TriAngle(x1,y1,x2,y2,x3,y3);
getch();
cleardevice();
Rotate(x1,y1,x2,y2,x3,y3);
setcolor(1);
TriAngle(x1,y1,x2,y2,x3,y3);
getch();
}
void TriAngle(int x1,int y1,int x2,int y2,int x3,int y3)
{
line(x1,y1,x2,y2);
line(x2,y2,x3,y3);
line(x3,y3,x1,y1);
}
void Rotate(int x1,int y1,int x2,int y2,int x3,int y3)
{
int x,y,a1,b1,a2,b2,a3,b3,p=x2,q=y2;
float Angle;
printf("enter the angle of rotation:");
scanf("%f",&Angle);
cleardevice();
Angle=(Angle*3.14)/180;
a1=p+(x1-p)*cos(Angle)-(y1-q)*sin(Angle);
b1=q+(x1-p)*sin(Angle)+(y1-q)*cos(Angle);
a2=p+(x2-p)*cos(Angle)+(y2-q)*sin(Angle);
b2=q+(x2-p)*sin(Angle)+(y2-q)*cos(Angle);
a3=p+(x3-p)*cos(Angle)+(y3-q)*sin(Angle);
b3=q+(x3-p)*sin(Angle)+(y3-q)*cos(Angle);
printf("Rotate"); TriAngle(a1,b1,a2,b2,a3,b3);
}

Output:
Q10. Write a program to implement Scaling Line in 2D.

Source Code:

#include<iostream.h>
#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<dos.h>
#include<process.h>
void main()
{
int gd=DETECT,gm,x,x1,x2,x3,y,y1,y2,y3,a,r,n;
char q;
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
printf("Enter the coordinates of the line:\n");
printf("(x1,y1):");
cin>>x1>>y1;
printf("(x2,y2):");
cin>>x2>>y2;
x1=x1;
y1=y1;
x2=x2;
y2=y2;
line(x1,y1,x2,y2);
printf("Enter the scaling factors\n");
printf("(x,y):");
cin>>x>>y;
x1=x1*x;
x2=x2*x;
y1=y1*y;
y2=y2*y;
line(x1,y1,x2,y2);
getch();
closegraph();
}
Output:
Q11. Write a program to implement Scaling in Circle in 2D.

Source Code:

#include<iostream.h>
#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<process.h>
#include<dos.h>
void main()
{
int gd=DETECT,gm,x,x1,x2,x3,y,y1,y2,y3,a,r,n;
char q;
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
printf("Enter the coordinates of the circle\n");
printf("(x1,y1):");
cin>>x1>>y1;
cout<<"Enter the radius\n"; printf("(r):");
cin>>r;
circle(x1,y1,r);
cout<<"Enter the scaling factor\n";
cin>>n; r=r*n;
circle(x1,y1,r);
getch();
closegraph();
}
Output:
Q12. Write a program to implement Reflection in 2D.

Source Code:

#include<graphics.h>
#include<math.h>
#include<conio.h>
#include<stdio.h>
void main()
{
int gd=DETECT,gm;
int i,xmid,ymid,x1,y1,x2,y2,x3,y3,x,y,dy,dx,p,gap=50,temp,option;
int x1dash,x2dash,x3dash,y1dash,y2dash,y3dash;
double theta;float m;char str[5];
clrscr();
initgraph(&gd,&gm,"..\\bgi");
printf("Enter first co-ords of the triangle\n");
scanf("%d %d",&x1,&y1);
printf("Enter second co-ords of the triangle\n");
scanf("%d %d",&x2,&y2);
printf("Enter third co-ords of the triangle\n");
scanf("%d %d",&x3,&y3);
xmid= getmaxx()/2; ymid= getmaxy()/2;
line(5,ymid,getmaxx()-5,ymid);
line(xmid+3,5,xmid+3,getmaxy()-5);
for( i= xmid+gap;i<getmaxx()-5;i=i+gap)
{
outtextxy(i,ymid-3,"|");
itoa(i-xmid,str,10);
outtextxy(i,ymid+3,str);
}
for( i= ymid-gap;i>5;i=i-gap) {
outtextxy(xmid,i,"-");
itoa(ymid-i,str,10);
outtextxy(xmid+5,i,str);
}
for( i= xmid-gap;i>5;i=i-gap) {
outtextxy(i,ymid-3,"|");
itoa(-(xmid-i),str,10);
outtextxy(i-6,ymid+3,str);
}
for( i= ymid+gap;i<getmaxy()-5;i=i+gap)
{
outtextxy(xmid,i,"-");
itoa(-(i-ymid),str,10);
outtextxy(xmid+8,i,str);
}
line(x1+xmid,ymid-y1,x2+xmid,ymid-y2);
line(x2+xmid,ymid-y2,x3+xmid,ymid-y3);
line(x3+xmid,ymid-y3,x1+xmid,ymid-y1);
setcolor(255);
printf("Reflection about \n");
printf("X axis : 1\n");
printf("Y axis : 2\n");
printf("X=Yaxis : 3\n");
printf(" Enter the option (1-3):");
scanf("%d",&option);
switch( option){
case 1: y1=-y1;
y2=-y2;
y3=-y3;
break;
case 2: x1=-x1;
x2=-x2;
x3=-x3;
break;
case 3: y1=-y1;
y2=-y2;
y3=-y3;
theta = ((double) 90 *3.14f )/(double)180;
x1dash=x1*cos(theta)-y1*sin(theta);
x2dash=x2*cos(theta)-y2*sin(theta);
x3dash=x3*cos(theta)-y3*sin(theta);
y1dash=x1*sin(theta)+y1*cos(theta);
y2dash=x2*sin(theta)+y2*cos(theta);
y3dash=x3*sin(theta)+y3*cos(theta);
x1=x1dash;x2=x2dash;x3=x3dash;
y1=y1dash;y2=y2dash;y3=y3dash;
}
line(x1+xmid,ymid-y1,x2+xmid,ymid-y2);
line(x2+xmid,ymid-y2,x3+xmid,ymid-y3);
line(x3+xmid,ymid-y3,x1+xmid,ymid-y1);
getch();
closegraph();
}

Output:
Q13. Write a program to implement Shearing in 2D.

Source Code:

#include<iostream.h>
#include<graphics.h>
#include<math.h>
#include<conio.h>
#include<dos.h>

//function declarations
void mul(int mat[3][3],int vertex[10][3],int n);
void shear(int vertex[10][3],int n);
void init(int vertex[10][3],int n);
int main() {
int i,x,y;
int vertex[10][3],n;
//clear the screen clrscr();
//taking inputs for the polygon object
cout<<"\nEnter the no. of vertex : ";
cin>>n;
for(i=0;i<n;i++)
{
cout<<"Enter the points (x,y): ";
cin>>x>>y;
vertex[i][0]=x;
vertex[i][1]=y;
vertex[i][2]=1;
}
//calling the shear() function to perform shearing of the given object
shear(vertex,n);
getch();
return 0;
}
void init(int vertex[10][3],int n)
{
//initialisation of the graphics driver
int gd=DETECT,gm,i;
initgraph(&gd,&gm,"C:\\turboc3\\bgi");
//drawing the co-ordinate axes
setcolor(10);
line(0,240,640,240); //drawing X axis
line(320,0,320,480); //drawing Y axis
//drawing graph legends
setcolor(3);
line(450,20,490,20);
setcolor(15);
line(450,50,490,50);
setcolor(6);
outtextxy(500,20,"Original");
outtextxy(500,50,"Transformed");
//drawing the object
setcolor(3);
for(i=0;i<n-1;i++)
{
line(320+vertex[i][0],240-vertex[i][1],320+vertex[i+1][0],240-vertex[i+1]
[1]);
}
line(320+vertex[n-1][0],240-vertex[n-1][1],320+vertex[0][0],240-vertex[0][1]);
}
void mul(int mat[3][3],int vertex[10][3],int n)
{
int i,j,k; // loop variables
//array for storing final image matrix
int res[10][3];
//multiplying the object matrix with shearing transformation matrix
for(i=0;i<n;i++)
{
for(j=0;j<3;j++)
{
res[i][j]=0;
for(k=0;k<3;k++)
{
res[i][j] = res[i][j] + vertex[i][k]*mat[k][j];
}
}
}
setcolor(15);
for(i=0;i<n-1;i++)
{
line(320+res[i][0],240-res[i][1],320+res[i+1][0],240-res[i+1][1]);
}
line(320+res[n-1][0],240-res[n-1][1],320+res[0][0],240-res[0][1]);
}

void shear(int vertex[10][3],int n)

{
int opt; //shearing transformation matrix
int shear_array[3][3]; //taking user input for shear direction
cout<<"\n1.x-shear\n2.y-shear\nYour Choice: ";
cin>>opt; //initializing the shearing transformation matrix as per the required direction
switch(opt)
{
case 1: int xsh;
cout<<"\nEnter the x shear : ";
cin>>xsh; //values for X shear
shear_array[0][0]=1;
shear_array[1][0]=xsh;
shear_array[2][0]=0;
shear_array[0][1]=0;
shear_array[1][1]=1;
shear_array[2][1]=0;
shear_array[0][2]=0;
shear_array[1][2]=0;
shear_array[2][2]=1;
mul(shear_array,vertex,n);
break;
case 2: int ysh;
cout<<"\nEnter the y shear : ";
cin>>ysh; //values for Y shear
shear_array[0][0]=1;
shear_array[1][0]=0;
shear_array[2][0]=0;
shear_array[0][1]=ysh;
shear_array[1][1]=1;
shear_array[2][1]=0;
shear_array[0][2]=0;
shear_array[1][2]=0;
shear_array[2][2]=1;
break;
}
}
Output:
Q14. Write a program to implement 3D Translation.

Source Code:

#include<iostream.h>
#include<conio.h>
#include<stdio.h>
#include<graphics.h>
#include<math.h>
void main()
{
int maxx,maxy,midx,midy;
int x,y,z,o,x1,x2,y1,y2;
int gd=DETECT,gm;
initgraph(&gd,&gm,"c:\\tc\\bgi");
cleardevice();
maxx=getmaxx();
maxy=getmaxy();
midx=maxx/2; midy=maxy/2;
line(midx,0,midx,maxy);
line(0,midy,maxx,midy);
bar3d(midx+50,midy-100,midx+60,midy-90,10,1);
cout<<"Enter translation factor\n";
cin>>x>>y;
cout<<"After translation:";
cleardevice();
line(midx,0,midx,maxy);
line(0,midy,maxx,midy);
bar3d(midx+x+50,midy-(y+100),midx+x+60,midy-(y+90),10,1);
getch();
closegraph();
}
Output:
Q15. Draw a Rectangle using the DDA method.

Source Code:

#include<stdio.h>
#include<graphics.h>
int abs (int n) {
return ( (n>0) ? n : ( n * (-1)));
}
void DDA(int X0, int Y0, int X1, int Y1)
{
int dx = X1 - X0;
int dy = Y1 - Y0;
int steps = abs(dx) > abs(dy) ? abs(dx) : abs(dy);
float Xinc = dx / (float) steps;
float Yinc = dy / (float) steps;
float X = X0;
float Y = Y0;
for (int i = 0; i <= steps; i++)
{
putpixel (X,Y,RED);
X += Xinc;
Y += Yinc;
}
}
int main() {
int gd = DETECT, gm; initgraph (&gd, &gm, "C:\\TURBOC3\\BGI");
DDA(10,10,50,10);
DDA(10,10,10,50);
DDA(50,10,50,50);
DDA(10,50,50,50);
return 0;
}
Output:
Q16. Write a program to rotate a coin.

Source Code:

#include<stdlib.h>
#include<stdio.h>
#include<conio.h>
#include<graphics.h>
int main(void) {
int gd=DETECT,gm,errorcode;
int midx,midy,k=1,b=60,a=60;
int xradius,yradius=60;
initgraph(&gd,&gm,"C:\\TurboC3\\bgi");
errorcode =graphresult();
if (errorcode != grOk) {
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1);
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
setcolor(getmaxcolor());
while(!kbhit()) {
for(a=60;a>=0;a=a-1)
{
cleardevice();
xradius=a;
if(a==0)
{
k=k+1;
for(b=a;b<=60;b++)
{
cleardevice();
xradius=b;
if(k%2==1)
{
outtextxy(midx-10,midy-90,"TAIL");
setfillstyle(4,1);
}
else { outtextxy(midx-10,midy-90,"HEAD");
setfillstyle(5,3);
}
if(b>0 &&b<57)
{
int xradius1=b-3;
fillellipse(midx,midy,xradius1+1, yradius);
fillellipse(midx,midy,xradius1+2, yradius);
fillellipse(midx,midy,xradius1+3, yradius);
}
outtextxy(10,5,"PROGRAM:TO SHOW THE ROTATION OF A COIN");
fillellipse(midx,midy,xradius, yradius);
delay(10);
}
}
if(a<57) {
int xradius1=a+3;
fillellipse(midx,midy,xradius1-1, yradius);
fillellipse(midx,midy,xradius1-2, yradius);
fillellipse(midx,midy,xradius1-3, yradius); }
if (k%2==1)
{
outtextxy(midx-10,midy-90,"TAIL");
setfillstyle(4,1);
}
else
{
outtextxy(midx-10,midy-90,"HEAD");
setfillstyle(5,3); }
outtextxy(10,5,"PROGRAM:TO SHOW THE ROTATION OF A COIN");
fillellipse(midx,midy,xradius, yradius);
delay(10);
}
}
getch();
closegraph();
return 0;
}
Output:
Q18. Write a program to show Cohen’s Sutherland Algorithm.

Source Code:

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<graphics.h>
#include<dos.h>

typedef struct coordinate

{
int x,y;
char code[4];
}PT;

void drawwindow();
void drawline(PT p1,PT p2);
PT setcode(PT p);
int visibility(PT p1,PT p2);
PT resetendpt(PT p1,PT p2);

void main()
{
int gd=DETECT,v,gm;
PT p1,p2,p3,p4,ptemp;

printf("\nEnter x1 and y1\n");

scanf("%d %d",&p1.x,&p1.y);
printf("\nEnter x2 and y2\n");
scanf("%d %d",&p2.x,&p2.y);

initgraph(&gd,&gm,"c:\\turboc3\\bgi");
drawwindow();
delay(500);

drawline(p1,p2);
delay(500);
cleardevice();

delay(500);
 p1=setcode(p1);
p2=setcode(p2);
v=visibility(p1,p2);
delay(500);

switch(v)
{
case 0: drawwindow();
delay(500);
drawline(p1,p2);
break;
case 1: drawwindow();
delay(500);
break;
case 2: p3=resetendpt(p1,p2);
p4=resetendpt(p2,p1);
drawwindow();
delay(500);
drawline(p3,p4);
break;
}

delay(5000);
closegraph();
}

void drawwindow()
{
line(150,100,450,100);
line(450,100,450,350);
line(450,350,150,350);
line(150,350,150,100);
}

void drawline(PT p1,PT p2)

{
line(p1.x,p1.y,p2.x,p2.y);
}

PT setcode(PT p) //for setting the 4 bit code

{
 PT ptemp;

if(p.y<100)
ptemp.code[0]='1'; //Top
else
ptemp.code[0]='0';

if(p.y>350)
ptemp.code[1]='1'; //Bottom
else
ptemp.code[1]='0';

if(p.x>450)
ptemp.code[2]='1'; //Right
else
ptemp.code[2]='0';

if(p.x<150)
ptemp.code[3]='1'; //Left
else
ptemp.code[3]='0';

ptemp.x=p.x;
ptemp.y=p.y;

return(ptemp);
}

int visibility(PT p1,PT p2)

{
int i,flag=0;

for(i=0;i<4;i++)
{
if((p1.code[i]!='0') || (p2.code[i]!='0'))
flag=1;
}

if(flag==0)
return(0);
 for(i=0;i<4;i++)
{
if((p1.code[i]==p2.code[i]) && (p1.code[i]=='1'))
flag='0';
}

if(flag==0)
return(1);

return(2);
}

PT resetendpt(PT p1,PT p2)

{
PT temp;
int x,y,i;
float m,k;

if(p1.code[3]=='1')
x=150;

if(p1.code[2]=='1')
x=450;

if((p1.code[3]=='1') || (p1.code[2]=='1'))
{
m=(float)(p2.y-p1.y)/(p2.x-p1.x);
k=(p1.y+(m*(x-p1.x)));
temp.y=k;
temp.x=x;

for(i=0;i<4;i++)
temp.code[i]=p1.code[i];

if(temp.y<=350 && temp.y>=100)

return (temp);
}

if(p1.code[0]=='1')
y=100;
 if(p1.code[1]=='1')
y=350;

if((p1.code[0]=='1') || (p1.code[1]=='1'))
{
m=(float)(p2.y-p1.y)/(p2.x-p1.x);
k=(float)p1.x+(float)(y-p1.y)/m;
temp.x=k;
temp.y=y;

for(i=0;i<4;i++)
temp.code[i]=p1.code[i];

return(temp);
}
else
return(p1);
}
Output:
Q19. Write a program to draw Flying Balloons.

Source Code:

#include<stdio.h>
#include<graphics.h>
#include<conio.h>
#include<alloc.h>
#include<dos.h>
void main()
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
setcolor(WHITE);
outtextxy(0,1,"COLOURED BALLOONS");
void *balloon[4];
setfillstyle(SLASH_FILL,RED);
setcolor(RED);
fillellipse(75,200,10,15);
line(75,215,75,250);
balloon[0]=malloc(imagesize(60,180,90,255));
getimage(60,180,90,255,balloon[0]);
setfillstyle(CLOSE_DOT_FILL,YELLOW);
setcolor(YELLOW);
circle(200,350,10);
line(200,360,200,400);
floodfill(200,350,YELLOW);
balloon[1]=malloc(imagesize(190,340,210,400));
getimage(190,340,210,400,balloon[1]);
setfillstyle(SOLID_FILL,BLUE);
setcolor(BLUE);
fillellipse(330,300,10,15);
fillellipse(330,320,10,15);
fillellipse(330,340,10,15);
line(330,355,330,400);
balloon[2]=malloc(imagesize(320,280,340,400));
getimage(320,280,340,400,balloon[2]);
setfillstyle(SOLID_FILL,GREEN);
setcolor(GREEN);
circle(500,400,25);
line(500,425,500,475);
floodfill(500,400,GREEN);
balloon[3]=malloc(imagesize(475,375,525,475));
getimage(475,375,525,475,balloon[3]);
int x[4]={60,190,320,475};
int y[4]={180,340,280,375};
int x1[4]={250,400,120,15};
int y1[4]={290,185,190,350};
while(!kbhit())
{
for(int i=0;i<4;i++)
{
if(y[i]<0)
{
x[i]+=50;
if(x[i]>550) x[i]=50; y[i]=470;
}
if(y1[i]<0)
{
x1[i]+=50;
if(x1[i]>550)
x1[i]=50; y1[i]=470;
}
}
i=0;
//RED BALLOON
putimage(x[i],y[i]--,balloon[i],XOR_PUT);
putimage(x[i],y[i],balloon[i],OR_PUT);
putimage(x1[i],y1[i]--,balloon[i],XOR_PUT);
putimage(x1[i],y1[i],balloon[i],OR_PUT);
i++;
//YELLOW BALLOON
putimage(x[i],y[i]--,balloon[i],XOR_PUT);
putimage(x[i],y[i],balloon[i],OR_PUT);
putimage(x1[i],y1[i]--,balloon[i],XOR_PUT);
putimage(x1[i],y1[i],balloon[i],OR_PUT);
i++;
//BLUE BALLOON
putimage(x[i],y[i]--,balloon[i],XOR_PUT);
putimage(x[i],y[i],balloon[i],OR_PUT);
putimage(x1[i],y1[i]--,balloon[i],XOR_PUT);
putimage(x1[i],y1[i],balloon[i],OR_PUT);
i++;
//GREEN BALLOON
putimage(x[i],y[i]--,balloon[i],XOR_PUT);
putimage(x[i],y[i],balloon[i],OR_PUT);
putimage(x1[i],y1[i]--,balloon[i],XOR_PUT);
putimage(x1[i],y1[i],balloon[i],OR_PUT);
delay(10);
}
closegraph();
}

Output:
Q20. Write a program to implement the MidPoint Circle Algorithm.

Source Code:

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

void drawcircle(int x0, int y0, int radius)

{
int x = radius;
int y = 0;
int err = 0;

while (x >= y)
{
putpixel(x0 + x, y0 + y, 7);
putpixel(x0 + y, y0 + x, 7);
putpixel(x0 - y, y0 + x, 7);
putpixel(x0 - x, y0 + y, 7);
putpixel(x0 - x, y0 - y, 7);
putpixel(x0 - y, y0 - x, 7);
putpixel(x0 + y, y0 - x, 7);
putpixel(x0 + x, y0 - y, 7);

if (err <= 0)
{
y += 1;
err += 2*y + 1;
}

if (err > 0)
{
x -= 1;
err -= 2*x + 1;
}
}
}

int main()
{
int gdriver=DETECT, gmode, error, x, y, r;
 initgraph(&gdriver, &gmode, "c:\\turboc3\\bgi");

printf("Enter radius of circle: ");

scanf("%d", &r);

printf("Enter co-ordinates of center(x and y): ");

scanf("%d%d", &x, &y);
drawcircle(x, y, r);

return 0;
}

Output:
Q21. Write a program to rotate a circle outside another circle.

Source Code:

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

void main(int) {
int gd=DETECT,gm;
int midx,midy,k=1,b=60,a=60;
int xradius,yradius=60;
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
midx = getmaxx() / 2;
midy = getmaxy() / 2;
while(!kbhit()) {
for(a=60;a>=0;a=a-1) {
cleardevice();
setfillstyle(5,1);
xradius=a;
if(a==0) {
k=k+1;
for(b=a;b<=60;b++) {
cleardevice();
xradius=b;
if(b>0 &&b<57)
{ int xradius1=b-3;
fillellipse(midx,midy,xradius1+1, yradius);
fillellipse(midx,midy,xradius1+2, yradius);
fillellipse(midx,midy,xradius1+3, yradius);
}
setfillstyle(4,3);
fillellipse(midx,midy,100,100);
setfillstyle(5,1);
fillellipse(midx,midy,xradius, yradius);
delay(10);
}
}
if(a<57) {
int xradius1=a+3;
fillellipse(midx,midy,xradius1-1, yradius);
fillellipse(midx,midy,xradius1-2, yradius);
fillellipse(midx,midy,xradius1-3, yradius);
}
setfillstyle(4,3);
fillellipse(midx,midy,100,100);
setfillstyle(5,1);
fillellipse(midx,midy,xradius, yradius);
delay(10);
}
}
getch();
closegraph();
}

Output:
Q22. Write a program to rotate a circle inside another circle.

Source Code:

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

void main(int) {
int gd=DETECT,gm;
int midx,midy,k=1,b=60,a=60;
int xradius,yradius=60;
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
midx = getmaxx() / 2;
midy = getmaxy() / 2;
while(!kbhit())
{ for(a=60;a>=0;a=a-1) {
cleardevice();
setfillstyle(5,1);
xradius=a;
if(a==0)
{ k=k+1;
for(b=a;b<=60;b++) {
cleardevice();
xradius=b;
if(k%2==1) {
outtextxy(midx-10,midy-90);
}
else {
outtextxy(midx-10,midy-90);
}
if(b>0 &&b<57) {
int xradius1=b-3;
fillellipse(midx,midy,xradius1+1, yradius);
fillellipse(midx,midy,xradius1+2, yradius);
fillellipse(midx,midy,xradius1+3, yradius);
}
setfillstyle(4,3);
fillellipse(midx,midy,20,20);
setfillstyle(5,1);
fillellipse(midx,midy,xradius, yradius); delay(10);
}
}
if(a<57) {
int xradius1=a+3;
fillellipse(midx,midy,xradius1-1, yradius);
fillellipse(midx,midy,xradius1-2, yradius);
fillellipse(midx,midy,xradius1-3, yradius);
}
if (k%2==1) {
outtextxy(midx-10,midy-90);
}
else {
outtextxy(midx-10,midy-90);
}
setfillstyle(4,3);
fillellipse(midx,midy,20,20); setfillstyle(5,1);
fillellipse(midx,midy,xradius, yradius);
delay(10);
}
}
getch();
closegraph();
}
Output:
Q23. ​Write a program to rotate a circle inside and outside another circle
alternatively.

Source Code:

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

void main(int) {
int gd=DETECT,gm;
int midx,midy,k=1,b=60,a=60;
int xradius,yradius=60;
initgraph(&gd,&gm,"C:\\TURBOC3\\BGI");
midx = getmaxx() / 2;
midy = getmaxy() / 2;
while(!kbhit()) {
for(a=60;a>=0;a=a-1) {
cleardevice();
setfillstyle(5,1);
xradius=a;
if(a==0) {
k=k+1;
for(b=a;b<=60;b++) {
cleardevice();
xradius=b;
if(k%2==1) {
outtextxy(midx-10,midy-90);
} else {
outtextxy(midx-10,midy-90);
}
if(b>0 &&b<57) {
int xradius1=b-3;
fillellipse(midx,midy,xradius1+1, yradius);
fillellipse(midx,midy,xradius1+2, yradius);
fillellipse(midx,midy,xradius1+3, yradius);
}
outtextxy(10,5);
setfillstyle(4,3);
fillellipse(midx,midy,xradius+40,yradius+40);
setfillstyle(7,3);
setfillstyle(5,1);
fillellipse(midx,midy,xradius, yradius);
delay(10); }}
if(a<57) {
int xradius1=a+3;
fillellipse(midx,midy,xradius1-1, yradius);
fillellipse(midx,midy,xradius1-2, yradius);
fillellipse(midx,midy,xradius1-3, yradius);
}
if (k%2==1) {
outtextxy(midx-10,midy-90);
} else {
outtextxy(midx-10,midy-90);
}
outtextxy(10,5);
setfillstyle(4,3);
fillellipse(midx,midy,xradius+40,yradius+40);
setfillstyle(7,3);
fillellipse(midx,midy,20,20);
setfillstyle(5,1);
fillellipse(midx,midy,xradius, yradius);
delay(10);
}
}
getch();
closegraph();
}
Output:
Q24. Write a program to implement Analog Clock.

Source Code:

#include<stdio.h>
#include<conio.h>
#include<dos.h>
#include<graphics.h>
#include<math.h>
void main() {
clrscr();
int gd=DETECT,gm, x,x1=300,y,y1=55,y2=80,y3=120,a,b,c,d,i;
float angle1,angle2,angle3;
char ch,str[5];
struct time t;
initgraph(&gd,&gm,"C:\\TurboC3\\BGI");
setcolor(GREEN);
angle1=0; for(i=1;i<=12;i++) {
angle1+=30;
x=(x1-300)*cos(3.14*angle1/180)-(40-200)*sin(3.14*angle1/180)+300;
y=(x1-300)*sin(3.14*angle1/180)+(40-200)*cos(3.14*angle1/180)+200;
itoa(i,str,10); outtextxy(x,y,str);
}
setcolor(LIGHTRED);
outtextxy(220,450,"A N A L O G C L O C K ");
while(1)
{ if (kbhit()) {
ch=getch();
if(ch==27)
break;
}
gettime(&t);
if(t.ti_hour>12)t.ti_hour-=12;
angle3=(float)t.ti_sec*6;
c=(x1-300)*cos(3.14*angle3/180)-(y1-200)*sin(3.14*angle3/180)+300;
d=(x1-300)*sin(3.14*angle3/180)+(y1-200)*cos(3.14*angle3/180)+200;
setcolor(GREEN);
line(300,200,c,d);
angle2=(float)t.ti_min*6+(float)angle3/60;
a=(x1-300)*cos(3.14*angle2/180)-(y2-200)*sin(3.14*angle2/180)+300;
b=(x1-300)*sin(3.14*angle2/180)+(y2-200)*cos(3.14*angle2/180)+200;
setcolor(RED);
line(300,200,a,b);
angle1=(float)t.ti_hour*30+angle2/12;
x=(x1-300)*cos(3.14*angle1/180)-(y3-200)*sin(3.14*angle1/180)+300;
y=(x1-300)*sin(3.14*angle1/180)+(y3-200)*cos(3.14*angle1/180)+200;
setcolor(YELLOW);
line(300,200,x,y);
delay(600);
setcolor(0);
line(300,200,x,y);
line(300,200,a,b);
line(300,200,c,d);
}
closegraph();
}

Output:
Q25. Write a program to show the changing radius of a circle.

Source Code:

#include<stdio.h>
#include<graphics.h>
#include<conio.h>
void main() {
int gd=DETECT, gm, i, x, y;
initgraph(&gd, &gm, "C:\\TurboC3\\BGI");
x=getmaxx()/3;
y=getmaxx()/3;
setcolor(WHITE);
for(i=1;i<=8;i++) {
setfillstyle(i,i);
delay(100);
circle(x, y, i*20);
floodfill(x-2+i*20,y,BLACK);
}
cleardevice();
circle(x, y, i*20);
getch();
closegraph();
}
Output:
Q26. Write a program to show 2D Reflection.

Source Code:

#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("\n");
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();

}
Output: