Graphics program for Bouncing-ball

#include"stdio.h"

#include"math.h"

#include"graphics.h"



#define ROUND(a) ((int) (a+0.5))

void paracircle(int xcen, int ycen, int r);

//////////////////////////////////////////////////////////////////////

void ddaline2(int xa, int ya, int xb, int yb)

{

int dx = xb - xa, dy = yb - ya, steps, k ;

float xinc,yinc,x = xa,y = ya;

if (abs (dx) > abs (dy) )

steps = abs(dx);

else

steps = abs(dy);

xinc = dx/(float) steps;

yinc = dy/(float) steps;

putpixel( ROUND(x), ROUND(y),RED);

for(k = 0; k < steps ; k++)

{

x += xinc;

y += yinc;

putpixel(ROUND(x),ROUND(y),BROWN);

}

}

//////////////////////////////////////////////////////////////////////

void ddaline(int xa, int ya, int xb, int yb)

{

int dx = xb - xa, dy = yb - ya, steps, k ;

float xinc,yinc,x = xa,y = ya;

if (abs (dx) > abs (dy) )

steps = abs(dx);

else

steps = abs(dy);

xinc = dx/(float) steps;

yinc = dy/(float) steps;

putpixel( ROUND(x), ROUND(y),RED);

for(k = 0; k < steps ; k++)

{

x += xinc;

y += yinc;

ddaline2(0,400,getmaxx(),400);

paracircle(ROUND(x),ROUND(y),30);

delay(5);

if(k % 2 == 0)

cleardevice();

}

}

///////////////////////////////////////////////////////////////////

void paracircle(int xcen, int ycen, int r)

{

float x = 0;

float y;

int theta = 0;

static int i;

for(; theta <= 360; theta++)

{

x = xcen + r * cos( (theta * 3.14) / 180);

y = ycen + r * sin( (theta * 3.14) / 180);

putpixel( (int)x,(int)y, BROWN);

}

putpixel(xcen,ycen,RED);

ddaline2(xcen,ycen,xcen + r*cos((i+120)*3.1415/180),ycen + r*sin((i+120)*3.1415/180) );

ddaline2(xcen,ycen,xcen + r*cos((i+240)*3.1415/180),ycen + r*sin((i+240)*3.1415/180) );

ddaline2(xcen,ycen,xcen + r*cos((i+360)*3.1415/180),ycen + r*sin((i+360)*3.1415/180) );

i++;

}

///////////////////////////////////////////////////////////////////////////

void main()

{

int i,j;

int gd = DETECT,gm;

initgraph(&gd,&gm,"C:\\TC\\BGI");



ddaline(30,30,180,370);

ddaline(180,370,330,130);

ddaline(330,130,480,370);

ddaline(480,370,550,230);

ddaline(550,230,600,370);

ddaline(600,370,getmaxx(),370);

getch();

closegraph();

}

Graphics program for polygon clipping

//Polygon clipping

#include"stdio.h"
#include"graphics.h"
struct point
{
int x;
int y;
}wmin,wmax,p1,p2,ipt,pin[50],pout[50];
int np=0,n;
void newpin();
void drawpolygon();
void showpoints();
void clippolygon()
{
float m=0.0;
int i,j;
np=0;

for(i=0,j=0;i=wmin.x||p1.x>=wmin.x&&p2.x<=wmin.x) { if(p1.x!=p2.x) m=(float)(p1.y-p2.y)/(float)(p1.x-p2.x); ipt.x=wmin.x; ipt.y=p1.y+(wmin.x-p1.x)*m; if(p1.xwmin.x) || (p1.x==wmin.x && p2.x==wmin.x))
{
pout[j]=p2;
j++;
np++;
}
else if(p1.x==wmin.x && p2.xwmin.x&&p2.x>wmin.x)
{
pout[j]=p2;
np++;
j++;
}
}
newpin();
cleardevice();
outtextxy(220,10,"After left clip");
drawpolygon();
showpoints();
getch();
// while (!kbhit());
// closegraph();
// initgraph(&gd,&gm,"NULL");
np=0;
for(i=0,j=0;i=wmax.x&&p2.x<=wmax.x||p1.x<=wmax.x&&p2.x>=wmax.x)
{
if(p1.x!=p2.x)
m=(float)(p1.y-p2.y)/(float)(p1.x-p2.x);
ipt.x=wmax.x;
ipt.y=p1.y+(wmax.x-p1.x)*m;
if(p1.x>wmax.x)
{
pout[j]=ipt;
pout[j+1]=p2;
np=np+2;
j=j+2;
}
else if((p1.x==wmax.x && p2.xwmax.x)
{
}
else
{
p2=ipt;
pout[j]=ipt;
np++;
j++;
}
}
else if(p1.x=wmin.y||p1.y>=wmin.y&&p2.y<=wmin.y) { if(p1.x!=p2.x) m=(float)(p1.y-p2.y)/(float)(p1.x-p2.x); ipt.y=wmin.y; if(m!=0) ipt.x=p1.x+(float)(wmin.y-p1.y)*(float)(1/m); else ipt.x=p1.x; if(p1.ywmin.y) || (p1.y==wmin.y && p2.y==wmin.y))
{
pout[j]=p2;
j++;
np++;
}
else if(p1.y==wmin.y && p2.ywmin.y&&p2.y>wmin.y)
{
pout[j]=p2;
np++;
j++;
}
}
newpin();

cleardevice();
outtextxy(220,10,"After bottom clip");
drawpolygon();
showpoints();
getch();
// while (!kbhit());
// closegraph();
// initgraph(&gd,&gm,"NULL");
np=0;
for(i=0,j=0;i=wmax.y&&p2.y<=wmax.y||p1.y<=wmax.y&&p2.y>=wmax.y)
{
if(p1.x!=p2.x)
m=(float)(p1.y-p2.y)/(float)(p1.x-p2.x);
ipt.y=wmax.y;
if(m!=0)
ipt.x=p1.x+(float)(wmax.y-p1.y)*(float)(1/m);
else
ipt.x=p1.x;
if(p1.y>wmax.y)
{
pout[j]=ipt;
pout[j+1]=p2;
np=np+2;
j=j+2;
}
else if((p1.y==wmax.y && p2.ywmax.y)
{
}
else
{
p2=ipt;
pout[j]=ipt;
np++;
j++;
}
}
else if(p1.y {
pout[j]=p2;
np++;
j++;
}
}
newpin();
cleardevice();
outtextxy(220,10,"clipped Polygon");
showpoints();
drawpolygon();
}
void newpin()
{
int i,j;
for(j=0,i=0;j pin[i]=pout[j];
n=i;
}
void showpoints()
{
int j;
printf("Vertex");
for(j=0;j printf("\n%d.(%d,%d)",j+1,pin[j].x,pin[j].y);
}
void drawpolygon()
{
int j;
setcolor(10);
rectangle(wmin.x,wmin.y,wmax.x,wmax.y);
setcolor(6);
for(j=0;j line(pin[j].x,pin[j].y,pin[(j+1)%n].x,pin[(j+1)%n].y);
}
int main()
{
int c,j;
int gd=DETECT,gm;
initgraph(&gd,&gm,"..//BGI");
printf("Enter the window minimum coordinates");
scanf("%d%d",&wmin.x,&wmin.y);
printf("Enter the window max coordinates");
scanf("%d%d",&wmax.x,&wmax.y);
printf("Enter the no of sides in polygon:\n");
scanf("%d",&n);
printf("Enter the coordinates(x,y)\n");
for(j=0;j{
printf("Enter the coordinate %d\n",j+1);
scanf("%d%d",&pin[j].x,&pin[j].y);
}
initgraph(&gd,&gm,"NULL");
outtextxy(220,10,"Orginal Polygon");
drawpolygon();
getch();
// while (!kbhit());
// closegraph();
// initgraph(&gd,&gm,"NULL");
clippolygon();
while (!kbhit());
closegraph();
return 0;
}

Computer Graphics program for line-clipping

//Line-clipping

#include"stdio.h"
#include"math.h"
#include"graphics.h"

#define ROUND(a) (int)(a + 0.5)
#define TOP 1
#define BOT 2
#define RT 4
#define LT 8
void lineclip(int x1,int y1,int x2,int y2);
void ddaline(int xa, int ya, int xb, int yb);
int xmin,xmax,ymin,ymax;
void main ()
{
int cho,x1,y1,x2,y2;
char ch;
int gd = DETECT, gm;
initgraph(&gd,&gm,"C:\\TC\\BGI");
clrscr();
do{
printf("\nENTER X-COORD. & Y-COORD. OF STARTING POINT OF LINE: ");
scanf("%d %d",&x1,&y1);
putpixel(x1,y1,3); //3 IS COLOR CODE OF CYAN
printf("\nENTER X-COORD. & Y-COORD. OF END POINT OF LINE: ");
scanf("%d %d",&x2,&y2);
putpixel(x2,y2,3);
printf("\nENTER X-min & Y-min OF CLIPPING WINDOW: ");
scanf("%d %d",&xmin,&ymin);
putpixel(xmin,ymin,5); //5 IS COLOR CODE OF RED
printf("\nENTER X-max & Y-max OF CLIPPING WINDOW: ");
scanf("%d %d",&xmax,&ymax);
putpixel(xmax,ymax,5);
clrscr();
ddaline(x1, y1, x2, y2);
delay(500);
ddaline(xmin, ymin, xmax, ymin);
delay(500);
ddaline(xmax, ymin, xmax, ymax);
delay(500);
ddaline(xmax, ymax, xmin, ymax);
delay(500);
ddaline(xmin, ymax, xmin, ymin);
delay(500);
getch();
lineclip(x1,y1,x2,y2);
getch();
printf("\nIF YOU WISH TO CONTINUE PRESS Y/y , ELSE ANY OTHER CHAR TO EXIT: ");
scanf(" %c",&ch);
}while(ch == 'y' || ch == 'Y');
getch();
closegraph();
}
////////////////////////////////////////////////////////////////////////////
void ddaline(int xa, int ya, int xb, int yb)
{
int dx = xb - xa, dy = yb - ya, steps, k ;
float xinc,yinc,x = xa,y = ya;
if (abs (dx) > abs (dy) )
steps = abs(dx);
else
steps = abs(dy);
xinc = dx/(float) steps;
yinc = dy/(float) steps;
putpixel( ROUND(x), ROUND(y),RED);
for(k = 0; k < steps ; k++)
{
x += xinc;
y += yinc;
putpixel( ROUND(x), ROUND(y),BROWN);
}
}
/////////////////////////////////////////////////////////////////////////
int findcode(int x, int y)
{
int code = 0;
if(y > ymax)
code |= TOP;
if(y < ymin)
code |= BOT;
if(x > xmax)
code |= RT;
if(x < xmin)
code |= LT;

return code;
}
/////////////////////////////////////////////////////////////////////////
void lineclip(int x1,int y1,int x2,int y2)
{
int code1,code2,t;
int done = 0,accept = 0;
float m,c;
m = (y2 - y1) / (x2 - x1);
c = y1 - m * x1;
while(!done)
{
code1 = findcode(x1,y1);
code2 = findcode(x2,y2);
if( (code1 | code2) == 0 )
{ accept = 1; done = 1; }
else
{
if( (code1 & code2) != 0 )
{ done = 1; }
else
{
if( code1 == 0 )
{
t = x1; x1 = x2; x2 = t;
t = y1; y1 = y2; y2 = t;
t = code1; code1 = code2; code2 = t;
}
if( (code1 & TOP) != 0)
{ y1 = ymax; x1 = (y1 - c) / m; }
else if( (code1 & BOT) != 0 )
{ y1 = ymin; x1 = (y1 - c) / m; }
else if( (code1 & LT) != 0)
{ x1 = xmin; y1 = m * x1 + c; }
else if( (code1 & RT) != 0)
{ x1 = xmax; y1 = m * x1 + c; }
}
}
}
clrscr();
if(accept)
ddaline(x1, y1, x2, y2);
ddaline(xmin, ymin, xmax, ymin);
delay(500);
ddaline(xmax, ymin, xmax, ymax);
delay(500);
ddaline(xmax, ymax, xmin, ymax);
delay(500);
ddaline(xmin, ymax, xmin, ymin);
delay(500);
}

Computer graphics lab// Transformation

// TRANSFORMATION

#include"stdio.h"
#include"math.h"
#include"graphics.h"

#define ROUND(a) ((int) (a+0.5))
void putpixelby(int x, int y, int col,int);
void paracircle(int xcen, int ycen, int r,int);
void circle1(int x, int y, int xcen, int ycen,int);
void rotation(int sx, int sy, float ang);
void translate(int tx, int ty);
void scaling(int sx, int sy, int px, int py);
void ddaline(int xa, int ya, int xb, int yb);
float transfm[3][3] = { {1.0,0.0,0.0},{0.0,1.0,0.0},{0.0,0.0,1.0} } ;
float translt[3][3] = { {1.0,0.0,0.0},{0.0,1.0,0.0},{0.0,0.0,1.0} } ;
float rotate[3][3] = { {1.0,0.0,0.0},{0.0,1.0,0.0},{0.0,0.0,1.0} } ;
float scale[3][3] = { {1.0,0.0,0.0},{0.0,1.0,0.0},{0.0,0.0,1.0} } ;
///////////////////////////////////////////////////////////////////////////
void main()
{
int cho1,cho2,xc,yc,r,n,i,x[10],y[10],u[10],v[10],tx,ty,sx,sy,px,py,temp;
float ang;
int gd = DETECT,gm;
initgraph(&gd,&gm,"C:\\TC\\BGI");
printf("\n ******");
printf("\n*********************** MENU *************************");
printf("\n ******");
printf("\n1.CIRCLE\n2.POLYGON\nENTER YOUR CHOICE: ");
scanf("%d",&cho1);
switch(cho1)
{
case 1:
printf("\nENTER X & Y COORD. OF CENTER & RADIUS: ");
scanf("%d %d %d",&xc,&yc,&r);
break;
case 2:
printf("\nENTER NO. OF SIDES OF THE POLYGON: ");
scanf("%d",&n);
for(i = 0; i < n ; i++)
{
printf("\nENTER X & Y COORD. OF SIDE %d : ",i+1);
scanf("%d %d",&x[i],&y[i]);
u[i] = x[i]; v[i] = y[i];
}
x[n] = x[0]; y[n] = y[0];
u[n] = x[0]; v[n] = y[0];

for(i = 0; i < n ; i++)
{ ddaline(x[i],y[i],x[i+1],y[i+1]); delay(500); }
break;
default:
printf("\nINVALID CHOICE.....");
}
//////////////////////////////////////////////////////
do{
printf("\n ******");
printf("\n*********************** MENU *************************");
printf("\n ******");
printf("\n1.TRANSLATE\n2.ROTATE\n3.SACLE\n4.EXIT\n\nENTER YOUR CHOICE: ");
scanf("%d",&cho2);
switch(cho2)
{
case 1:
printf("\nENTER X & Y COORD OF POINT OF TRANSLATION: ");
scanf("%d %d",&tx,&ty);
translate(tx,ty);
break;
case 2:
printf("\nENTER ANGLES IN DEGREE: ");
scanf("%f",&ang);
printf("\nENTER COORD. X & Y OF PIVOT POINT: ");
scanf("%d %d",&px,&py);
rotation(px,py,(ang*3.14)/180);
break;
case 3:
printf("\nENTER SCALING FACTOR X & Y: ");
scanf("%d %d",&sx,&sy);
printf("\nENTER COORD. X & Y OF PIVOT POINT: ");
scanf("%d %d",&px,&py);
scaling(sx,sy,px,py);
break;
case 4:
break;
default:
printf("\nINVALID CHOICE.....");
}
}while(cho2 == 1 || cho2 == 2 || cho2 == 3);
///////////////////////////////////////////////
cleardevice();
getch();
ddaline( (getmaxx()/2),0,(getmaxx()/2),(getmaxy()) );
ddaline( 0,(getmaxy()/2),(getmaxx()),(getmaxy()/2) );
if(cho1 == 2)
{
for(i = 0; i < n; i++)
{ //TO SVAE THE VALUE OF x[i]
temp = transfm[0][0]*x[i] + transfm[0][1]*y[i] + transfm[0][2] ;
y[i] = transfm[1][0]*x[i] + transfm[1][1]*y[i] + transfm[1][2] ;

x[i] = temp; //RESTORE THE VALUE OF x[i]
}
x[n] = x[0]; y[n] = y[0];
for(i = 0; i < n; i++)
{
v[i] = (-1) * v[i];
y[i] = (-1) * y[i];
}
x[n] = x[0]; y[n] = y[0];
u[n] = u[0]; v[n] = v[0];
for(i = 0; i < n; i++)
{
u[i] = (getmaxx()/2) + u[i];
v[i] = (getmaxy()/2) + v[i];
x[i] = (getmaxx()/2) + x[i];
y[i] = (getmaxy()/2) + y[i];
}
x[n] = x[0]; y[n] = y[0];
u[n] = u[0]; v[n] = v[0];
for(i = 0; i < n ; i++)
{ ddaline(u[i],v[i],u[i+1],v[i+1]); delay(500); }
for(i = 0; i < n ; i++)
{ ddaline(x[i],y[i],x[i+1],y[i+1]); delay(500); }
}
///////////////////////////////////////////////////////////////////
else if(cho1 == 1)
{
paracircle(xc,yc,r,1);
paracircle(xc,yc,r,2);
}
getch();
closegraph();
}
///////////////////////////////////////////////////////////////////////////
void translate(int tx, int ty)
{
float temp[3][3];
int i,j;
translt[0][2] = tx;
translt[1][2] = ty;
for(i = 0; i < 3; i++)
for(j = 0; j < 3 ; j++)
temp[i][j] = transfm[i][0]*translt[0][j] + transfm[i][1]*translt[1][j] + transfm[i][2]*translt[2][j];
for(i = 0; i < 3; i++)
for(j = 0; j < 3 ; j++)
transfm[i][j] = temp[i][j];
}
///////////////////////////////////////////////////////////////////////////
void rotation(int px, int py, float ang)
{
float temp[3][3];
int i,j;
float c,s,p,q;
c = cos(ang); s = sin(ang);
p = px*(1 - c) + py * s;
q = py*(1 - c) - px * s;
rotate[0][0] = c;
rotate[0][1] = (-1) * s;
rotate[0][2] = p;
rotate[1][0] = s;
rotate[1][1] = c;
rotate[1][2] = q;
for(i = 0; i < 3; i++)
for(j = 0; j < 3 ; j++)
temp[i][j] = transfm[i][0]*rotate[0][j] + transfm[i][1]*rotate[1][j] + transfm[i][2]*rotate[2][j];
for(i = 0; i < 3; i++)
for(j = 0; j < 3; j++)
transfm[i][j] = temp[i][j];
}
///////////////////////////////////////////////////////////////////////////
void scaling(int sx, int sy, int px, int py)
{
float temp[3][3];
int i,j;
scale[0][0] = sx;
scale[0][2] = px*(1 - sx);
scale[1][1] = sy;
scale[1][2] = py*(1 - sy);
for(i = 0; i < 3; i++)
for(j = 0; j < 3 ; j++)
temp[i][j] = transfm[i][0]*scale[0][j] + transfm[i][1]*scale[1][j] + transfm[i][2]*scale[2][j];
for(i = 0; i < 3; i++)
for(j = 0; j < 3 ; j++)
transfm[i][j] = temp[i][j];
}
///////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////
void ddaline(int xa, int ya, int xb, int yb)
{
int dx = xb - xa, dy = yb - ya, steps, k ;
float xinc,yinc,x = xa,y = ya;
if (abs (dx) > abs (dy) )
steps = abs(dx);
else
steps = abs(dy);
xinc = dx/(float) steps;
yinc = dy/(float) steps;
putpixel( ROUND(x), ROUND(y),RED);
for(k = 0; k < steps ; k++)
{
x += xinc;
y += yinc;
putpixel( ROUND(x), ROUND(y),BROWN);
}
}
////////////////////////////////////////////////////////////////////////////
void paracircle(int xcen, int ycen, int r, int position)
{
float x = 0;
float y;
int theta = 0;
//circle1((int)x,(int)y,xcen,ycen,position);
for(; theta <= 45; theta++)
{
x = r * cos( (theta * 3.14) / 180);
y = r * sin( (theta * 3.14) / 180);
circle1(x, y, xcen, ycen,position);
}
putpixel(xcen,ycen,RED);
}
///////////////////////////////////////////////////////////////////////////
void circle1(int x, int y, int xcen, int ycen,int position)
{
putpixelby(xcen + x, ycen + y, BROWN,position);
putpixelby(xcen - x, ycen + y, BROWN,position);
putpixelby(xcen + x, ycen - y, BROWN,position);
putpixelby(xcen - x, ycen - y, BROWN,position);
putpixelby(xcen + y, ycen + x, BROWN,position);
putpixelby(xcen - y, ycen + x, BROWN,position);
putpixelby(xcen + y, ycen - x, BROWN,position);
putpixelby(xcen - y, ycen - x, BROWN,position);
}
//////////////////////////////////////////////////////////////////////////
void putpixelby(int x, int y, int col,int position)
{
float temp;
if(position == 2)
{
temp = transfm[0][0]*x + transfm[0][1]*y + transfm[0][2] ;
y = transfm[1][0]*x + transfm[1][1]*y + transfm[1][2] ;
x = temp;
}
y = (-1) * y;
x = (getmaxx()/2) + x;
y = (getmaxy()/2) + y;
putpixel(x,y,col);
}
///////////////////////////////////////////////////////////////////////////

Computer graphics// Program to fill water in a bucket from pipe

//program to fill water in a bucket

#include"stdio.h"
#include"graphics.h"
#include"math.h"

void main()
{
int gd=DETECT,gm=DETECT,i,j;
initgraph(&gd,&gm,"c:\\tc\\bgi");
ellipse(300,200,0,360,50,25);
ellipse(300,300,0,360,50,25);
line(250,200,250,300);
line(350,200,350,300);
ellipse(300,100,180,360,5,2);
line(295,100,295,80);
line(305,100,305,86);
arc(300,80,90,180,5);
putpixel(306,85,15);
putpixel(307,84,15);
line(308,84,630,84);
line(300,75,303,75);
line(314,75,630,75);
putpixel(304,74,15);
putpixel(305,73,15);
line(306,72,306,65);
line(311,72,311,65);
putpixel(312,73,15);
putpixel(313,74,15);
pieslice(309,62,0,360,5);
setfillstyle(SOLID_FILL,BLUE);
setcolor(BLUE);
for(i=0;i<7;i++)
{
line(297+i,103,297+i,300);
}
for(i=1;i<100;i++)
{
setcolor(LIGHTBLUE);
ellipse(300,300-i,180,360,4,2);
delay(30);
fillellipse(300,300-i,49,25);
setcolor(1);
line(297,275-i,303,275-i);
setcolor(15);
ellipse(300,200,180,360,50,25);
delay(50);
}
ellipse(300,200,0,360,50,25);
setcolor(0);
for(i=0;i<7;i++)
line(297+i,103,297+i,174);
getch();
}

What does double precision variable mean in C?

If you know what float is, then double is like an advanced version of float. It can hold a larger number value because the variable can hold more bytes of memory.
Now if you don't know what a float is then read this:
if you notice. If you name a variable with the type "int" you can only put in whole numbers and not decimal numbers (Ex: 1 , -1 , 100 , -100 , etc)

With double you can store any type of number in the variable Ex: 1.0 , 2.56783 , 2.192
Now float is a lower version of double and can still store any number but it can't store very large numbers. Most times people use double instead of float , but there's some good situations when you'd use float over double for example. Say the variable won't be a large value then you'd use float because it takes up less space and therefore the program will run faster.

So to sum it all up
1.Double means that the number stored in the variable is a real number , meaning you can store numbers with decimals and what not.
2. Double can hold a larger number value than int or float because it can hold more bytes of memory.
3. Double is most commonly used , rather than float.

diff between exit(0) and return(0)

Returning a value from main() and calling exit() with
that value are almost perfectly equivalent. The subtle
difference is that the local `auto' variables in main()
cease to exist when main() returns, so if any program
cleanup code -- atexit() routines, the automatic flushing
and closing of open I/O streams, and so on -- tries to
use these variables, there will probably be trouble that
wouldn't occur if exit() had been called instead.

Why return 0 gives in end of main function in c language?

The return code from a c program does not have to be zero.
Zero is a value that happens to indicate a successful completion of the program.

The use of this return code can be seen in this link for batch processing.

A return code of 4 usually indicates a warning has occurred.
A return code of 8 or more indicates an error.

computer graphics lab

//PROGRAM FOR FAN


#include

#include

#include


#define pi 3.142857

#define ROUND(a) ((int)(a+0.5))

void pie(int sa,int ea,int xc,int yc,int r)

{

double a1,a2;
int x,y;

a1=(pi*sa)/180;

x=xc+r*cos(a1);

y=yc+r*sin(a1);

line(xc,yc,x,y);

a2=-(pi*ea)/180;

x=xc+r*cos(a2);

y=yc+r*sin(a2);

line(xc,yc,x,y);

}


///////////////////////////////////////////////////


void runfan(int d)

{
int i=0,sa=0,ea=1;


while(!kbhit())

{
delay(d);

cleardevice();

circle(100,100,50);

line(90,150,90,250);

line(110,150,110,250);

line(40,250,40,300);

line(160,250,160,300);

line(40,300,160,300);

line(40,250,160,250);

outtextxy(45,275,"0");

outtextxy(75,275,"1");

outtextxy(105,275,"2");

outtextxy(135,275,"3");


pie(sa,ea,100,100,50);

pie(sa+150,ea+150,100,100,50);

pie(sa+300,ea+300,100,100,50);

i++;

sa=sa-10;
ea=ea+10;

}

}

/////////////////////////////////////////////////


int main()

{

int d=0,cho;

int gd=DETECT,gm;

initgraph(&gd,&gm," ");

runfan(0);

do
{

//runfan(0);

printf("\n enter the speed of regulator");

scanf("%d",&d);

switch(d)

{

case 0:

runfan(d);

break;

case 1:

runfan(70);
break;

case 2:

runfan(50);
break;

case 3:

runfan(20);
break;

}

printf("\n press 1 to continue");

scanf("%d",&cho);

}
while(cho==1);

getch();

return (0);

}

computer graphics lab //PROGRAM OF CIRCUM-CIRCLE

//PROGRAM OF CIRCUM-CIRCLE



#include

#include
#include
void main()
{
int n,i,x[10],y[10],a[10],b[10];
float m[10],c[10],xc,yc,r;
int gd=DETECT,gm;
initgraph(&gd,&gm,"..//bgi");
printf("enterd no of sides: ");
scanf("%d",&n);
for(i=0;i
{
printf(" Enter the x and y cordinates: ");
scanf("%d %d",&x[i],&y[i]);
}
x[n]=x[0]; y[n]=y[0];
for(i=0;i
{
line(x[i],y[i],x[i+1],y[i+1]);
delay(500);
}
for(i=0;i
{
a[i]=(x[i]+x[i+1])/2;
b[i]=(y[i]+y[i+1])/2;
}
for(i=0;i
{
if(y[i]!=y[i+1])
{
m[i]=-(float)(x[i]-x[i+1])/(y[i]-y[i+1]);
c[i]=b[i]-m[i]*a[i];
}
else
m[i]=0;
}
i=0;
if(y[i]==y[i+1])
{
xc=a[i];
yc=(float)(m[i+1]*xc+c[i+1]);
}
else if(y[i+1]==y[i+2])
{
xc=a[i+1];
yc=(float)(m[i+2]*xc+c[i+2]);
}
else
{
xc=(c[i+1]-c[i])/(m[i]-m[i+1]);
yc=m[i]*xc+c[i];
}
printf("%f %f %d %d\n",xc,yc,x[1],y[1]);
r=sqrt((xc-x[1])*(xc-x[1])+(yc-y[1])*(yc-y[1]));
putpixel((int)xc,(int)yc,2);
setcolor(3);
printf("%f %f %f",xc,yc,r);
circle((int)xc,(int)yc,r);
setcolor(5);
getch();
}

computer graphics lab

//PROGRAM TO DRAW A CAR

#include

#include

#define round(x) ((int)(x+0.5))

void parametric(int x,int y)

{ int i;

float r=40,x2,y2;

for(i=180;i<360;i++)

{

x2=(float)(x)+r*cos((i*3.1415)/180);

y2=(float)(y)+r*sin((i*3.1415)/180);

putpixel(round(x2),round(y2),15);

}

}

void car()

{

int x1=0,x2=20,x3=40,x4=50,x5=60,x6=70,x7=100,x8=120,x9=130,x10=180,x11=200,x12=205,x13=210,x14=220,x15=240,x16=260,x17=300;

while(x17<600)

{

cleardevice();

line(x1,250,x1,350);

line(x1,350,x3,350);

line(x1,250,x3,150);

line(x2,250,x4,250);

line(x2,250,x4,175);

line(x4,250,x4,175);

line(x5,250,x5,175);

circle(x6,350,38);

circle(x6,350,25);

parametric(x6,350);

line(0,388,650,388);

line(x5,175,x8,175);

line(x5,250,x8,250);

line(x8,175,x8,250);

line(x9,175,x9,250);

line(x9,175,x11,175);

line(x9,250,x11,250);

line(x11,175,x11,250);

line(x7,350,x10,350);

line(x12,175,x12,250);

line(x12,175,x15,250);

line(x12,250,x15,250);

line(x3,150,x14,150);

line(x14,150,x16,225);

circle(x13,350,38);

circle(x13,350,25);

parametric(x13,350);

line(x16,225,x17,250);

line(x15,350,x17,350);

line(x17,250,x17,350);

delay(20);

x1++; x2++;x3++;x4++;x5++; x6++; x7++; x8++; x9++; x10++; x11++; x12++; x13++;

x14++; x15++; x16++; x17++;

}

}

void main()

{

int gd=DETECT,gm;

initgraph(&gd,&gm,"..//bgi");

car();

getch();

}