Boundary and flood fill ( Recursive and non recursive)

#include
#include
#include
#include
#define round(a)((int)(a+0.5))
struct point{ int xc;int yc;}curpix, stk [9999];
int top=-1;
void push(int x,int y)
{ top++;
stk[top].xc=x;
stk[top].yc=y;
}
void pop()
{ curpix.xc=stk[top].xc;
curpix.yc=stk[top].yc;
top--;
}

void ddaline(int x1,int y1,int x2,int y2,int col)
{
int dx,dy,steps,k;
float x,y,xinc,yinc;
dx=x2-x1;
dy=y2-y1;
if(abs(dx)>abs(dy))
steps=abs(dx);
else
steps=abs(dy);
xinc=(float)dx/steps;
yinc=(float)dy/steps;
x=x1;y=y1;
putpixel(round(x),round(y),col);
for(k=0;k { x+=xinc;
y+=yinc;
putpixel(round(x),round(y),col);
}
}
void bfill(int x,int y,int bclr,int fclr)
{ int curclr;
curclr=getpixel(x,y);
if(curclr!=fclr && curclr!=bclr)
{
putpixel(x,y,fclr);
bfill(x+1,y,bclr,fclr);
bfill(x,y+1,bclr,fclr);
bfill(x-1,y,bclr,fclr);
bfill(x,y-1,bclr,fclr);
}
}

void ffill(int x,int y,int oclr,int fclr)
{ int curclr;
curclr=getpixel(x,y);
if(curclr==oclr)
{
putpixel(x,y,fclr);
ffill(x+1,y,oclr,fclr);
ffill(x,y+1,oclr,fclr);
ffill(x-1,y,oclr,fclr);
ffill(x,y-1,oclr,fclr);
}
}

void rff(int x,int y,int oclr,int fclr)
{ int curclr;
while(top!=-1)
{ curclr=getpixel(x,y);
if(curclr==oclr)
{
putpixel(x,y,fclr);
push(x+1,y);
push(x,y+1);
push(x-1,y);
push(x,y-1);
}
pop();
x=curpix.xc;
y=curpix.yc;

}
}
void rbf(int x,int y,int bclr,int fclr)
{ int curclr;
while(top!=-1)
{ curclr=getpixel(x,y);
if(curclr!=bclr && curclr!=fclr)
{
putpixel(x,y,fclr);
push(x+1,y);
push(x,y+1);
push(x-1,y);
push(x,y-1);
}
pop();
x=curpix.xc;
y=curpix.yc;

}
}
//*********************************************
void main()
{ int gd,gm;
detectgraph(&gd,&gm);
int x[10],y[10],n,i,sumx=0,sumy=0,seedx,seedy,old;
initgraph(&gd,&gm,"..\\bgi");
printf("\n enter the no of sides of polygon\n");
scanf("%d",&n);
printf("\n enter the end points of polygon\n");
for(i=0;i {
scanf("%d",&x[i]);
scanf("%d",&y[i]);
sumx+=x[i];sumy+=y[i];
}
x[i]=x[0];y[i]=y[0];
for(i=0;i {
ddaline(x[i],y[i],x[i+1],y[i+1],2);
}
seedx=sumx/n;
seedy=sumy/n;
old=getpixel(seedx,seedy);
push(seedx,seedy);
rbf(seedx,seedy,2,RED);
getch();
}

Ball Moving on sphere

#include
#include
#include
#include
#define pi 3.14285
#define round(a)((int)(a+0.5))
int i;
void parcircle(int ,int ,float,int ) ;
void parcir(int xc,int yc,float r,int sang,int eang,int col)
{ int k;
float x,y;

for(k=sang;k { x=xc+r*cos(pi*k/180);
y=yc+r*sin(pi*k/180);
putpixel(round(x),round(y),col);
}
}

void drawcir(int x,int y,float r,int sang)
{ int k=0;
int eang;
eang=sang+120;
while(k!=3)
{
parcir(x,y,r,sang,eang,(k+1));
sang=eang;
eang+=120;
k++;
}
}
void parc(int xc,int yc,float r1,int i)
{ int k=0,r; float x,y;
r=r1+20;
for(k=0;k<360;k++)
{ x=xc+r*cos(pi*k/180);
y=yc+r*sin(pi*k/180);

cleardevice();
parcircle(xc,yc,r1,11);
i+=5;
drawcir(round(x),round(y),20,i);

}

}
void parcircle(int xc,int yc,float r,int col)
{ int k=0; float x,y;
for(k=0;k<360;k++)
{ x=xc+r*cos(pi*k/180);
y=yc+r*sin(pi*k/180);
putpixel(round(x),round(y),col);

}
}
//========================
void main()
{ int gd,gm;
detectgraph(&gd,&gm);
int x,y,xc,yc; float r,r1;
i=0;

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

printf("\n enter the centre");
scanf("%d",&x);
scanf("%d",&y);
printf("\n enter the radius");
scanf("%f",&r);
xc=x;yc=y;

while(!kbhit())
{

parc(xc,yc,r,i);


}

}

revolution of saturn and jupiter around the sun

#include
#include
#include
#include
#define pi 3.14285
#define round(a)((int)(a+0.5))
int i;
void drawellipse(int xc,int yc,int a,int b)
{ float x,y;int i;
for(i=0;i<360;i++)
{ x=xc+a*cos(i*pi/180);
y=yc+b*sin(i*pi/180);
putpixel(round(x),round(y),11);
}
}
void parcircle(int ,int ,float,int ) ;
void parcir(int xc,int yc,float r,int sang,int eang,int col)
{ int k;
float x,y;

for(k=sang;k { x=xc+r*cos(pi*k/180);
y=yc+r*sin(pi*k/180);
putpixel(round(x),round(y),col);
}
}

void drawcir(int x,int y,float r,int sang)
{ int k=0;
int eang;
eang=sang+120;
while(k!=3)
{
parcir(x,y,r,sang,eang,(k+1));
sang=eang;
eang+=120;
k++;
}
}
void parc(int xc,int yc,float r1,int i)
{ int k=0,r,m; float x,y;
r=r1+60;m=r1+120;
for(k=0;k<360;k++)
{ x=xc+2*r*cos(pi*k/180);
y=yc+r*sin(pi*k/180);
delay(10);
cleardevice();
parcircle(xc,yc,r1,11);
i+=5;
drawcir(round(x),round(y),10,i);
x=xc+2*m*cos(pi*k/180);
y=yc+m*sin(pi*k/180);

drawcir(round(x),round(y),20,i);
drawellipse(round(x),round(y),30,10);

}

}
void parcircle(int xc,int yc,float r,int col)
{ int k=0; float x,y;
for(k=0;k<360;k++)
{ x=xc+r*cos(pi*k/180);
y=yc+r*sin(pi*k/180);
putpixel(round(x),round(y),col);

}
}
//========================
void main()
{ int gd,gm;
detectgraph(&gd,&gm);
int x,y,xc,yc; float r,r1;
i=0;

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

printf("\n enter the centre of the sun");
scanf("%d",&x);
scanf("%d",&y);
printf("\n enter the radius of the sun");
scanf("%f",&r);
xc=x;yc=y;

while(!kbhit())
{

parc(xc,yc,r,i);

}




getch();
}

Bezier Curve

#include
#include

void circl(int x, int y, int r)
{
int x1,y1,p;
x1=0;
y1=r;
p=3-2*r;

while(x1 {
plotcircle(x,y,x1,y1);
if(p<0)
p=p+4*x1+6;
else
{
p=p+4*(x1-y1)+10;
y1=y1-1;
}
x1=x1+1;
}

if(x1==y1)
plotcircle(x,y,x1,y1);
}

plotcircle(int x,int y, int x1, int y1)
{
putpixel(x+x1,y+y1,RED);
putpixel(x-x1,y+y1,RED);
putpixel(x+x1,y-y1,RED);
putpixel(x-x1,y-y1,RED);
putpixel(x+y1,y+x1,RED);
putpixel(x-y1,y+x1,RED);
putpixel(x+y1,y-x1,RED);
putpixel(x-y1,y-x1,RED);
return 0;
}

void cubic(int x1,int y1,int x2, int y2, int x3, int y3, int x4, int y4, int color)
{
int Cx[4],Cy[4];
int ax,ay,bx,by,cx,cy,dx,dy,x,y;
int i=0;
double stepsize,t;
Cx[0]=x1;
Cy[0]=y1;
Cx[1]=x2;
Cy[1]=y2;
Cx[2]=x3;
Cy[2]=y3;
Cx[3]=x4;
Cy[3]=y4;
for(i=0;i<4;i++)
{
setcolor(color);
circl(Cx[i],Cy[i],3);
}
setcolor(color);
ax=-Cx[0]+3*Cx[1]+(-3*Cx[2])+Cx[3];
ay=-Cy[0]+3*Cy[1]+(-3*Cy[2])+Cy[3];
bx=3*Cx[0]+(-6*Cx[1])+3*Cx[2];
by=3*Cy[0]+(-6*Cy[1])+3*Cy[2];
cx=-3*Cx[0]+3*Cx[1];
cy=-3*Cy[0]+3*Cy[1];
dx=Cx[0];
dy=Cy[0];
for(i=0;i<4;i++)
{
putpixel(Cx[i],Cy[i],RED);
}
setcolor(WHITE);
for(i=0;i<3;i++)
{
line(Cx[i],Cy[i],Cx[(i+1)%4],Cy[(i+1)%4]);
}
setcolor(RED);
stepsize=1.0/1000.0;
for(i=0;i<1000;i++)
{
t=stepsize*(double)i;
x=ax*(t*t*t)+bx*(t*t)+cx*t+dx;
y=ay*(t*t*t)+by*(t*t)+cy*t+dy;
putpixel(x,y,RED);
}
}

main()
{
int gd,gm,x,y;
detectgraphI&gd,&gm);
initgraph(&gd,&gm,"..\\bgi ");

cleardevice();
cubic(50,300,100,50,250,50,350,300,6);
getch();
cleardevice();
cubic(50,300,350,300,100,50,250,50,6);
getch();
cleardevice();
cubic(50,300,100,50,350,300,250,50,6);
getch();
cleardevice();
cubic(350,300,50,300,100,50,250,50,6);
getch();

return 0;
}

Pie Chart

#include
#include
#include
#include
#include"math.h"
#define round(a) (int)(a+0.5)
void pie(int stangle,int endangle,int radius,int z)
{
int i,x,y,x1,y1;
for(radius=0;radius<100;radius++)
{
for(i=stangle;i{
x=getmaxx()/2+round(radius*cos((3.142*i)/180));
y=getmaxy()/2+round(radius*sin((3.142*i)/(180)));
putpixel(x,y,z);
}
}
}

int main(void)
{
/* request auto detection */
int gdriver, gmode, errorcode,sum=0,i,n,data[10],z=1;
detectgraph(&gdriver,&gmode);
int stangle = 0, endangle = 0, radius = 100;
printf("enter the no. of data");
scanf("%d",&n);
one:
sum=0;
for(i=0;i { printf("\nenter the %age of data");
scanf("%d",&data[i]);
}
for(i=0;i sum=sum+data[i];

if(sum!=100)
{
printf("error in data entry ");
getch();
clrscr();
goto one;
}
/* initialize graphics and local variables */
initgraph(&gdriver,&gmode, "..\\bgi");

/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}

/* set fill style and draw a pie slice */
outtextxy(100,100,"PIE CHART");
for(i=0;i {
stangle=endangle;
endangle=stangle+round((data[i]*360)/100);
pie(stangle, endangle, radius,z);
z++;
}
/* clean up */
getch();
closegraph();
return 0;
}

PendulUm

#include<graphics.h>
#include<conio.h>
#include<stdlib.h>
#include<dos.h>
void main()
{
int xc,yc,r,x=0,y=0;
int gd=DETECT,gm;
initgraph(&gd,&gm,"");
setcolor(2);
line(320,100,280,260);
circle(280,280,20);
for(x=250,y=230;x<330,y<310;x=x+10,y=y+10)
{
line(320,100,x,y);
circle(x,y,20);
sleep(1);
clrscr();
}
for(x=330,y=290;x>390,y>230;x=x+10,y=y-10)
{
line(320,100,x,y);
circle(x,y,20);
sleep(1);
clrscr();
}
//return
for(x=390,y=230;x>320,y<300;x=x-10,y=y+10)
{
line(320,100,x,y);
circle(x,y,20);
sleep(1);
clrscr();
}

for(x=310,y=290;x>250,y>230;x=x-10,y=y-10)
{
line(320,100,x,y);
circle(x,y,20);
sleep(1);
clrscr();
}




getch();
}

Man Walking

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<stdlib.h>
#include<dos.h>
void main()
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"");
for(int i=1;i<=400;i++)
{
setlinestyle(0,5,2);
setcolor(4);
//umbrella
pieslice(100+i,225,0,180,50);
arc(100+i,225,355,185,50);
line(100+i,225,100+i,285);
arc(104+i,285,180,360,4);
//man
circle(75+i,250,15);
line(75+i,265,75+i,310);
line(75+i,290,98+i,280);
line(65+i,330,75+i,310);
line(85+i,330,75+i,310);

//rain
setlinestyle(1,5,2);
setcolor(11);
line(0,0,40,150);
line(10,0,50,150);
line(20,0,60,150);
line(30,0,70,150);
line(40,0,80,150);
line(50,0,90,150);
line(60,0,100,150);
line(70,0,110,150);
line(80,0,120,150);
//road
setlinestyle(0,5,3);
setcolor(12);
line(0,340,680,340);
       // cloud
setcolor(BLUE);
setlinestyle(0,5,2);
fillellipse(250,30,40,10);
fillellipse(250,40,15,8);
fillellipse(290,30,20,5);
delay(20);
cleardevice();
}
getch();
}

Helicopter Hit

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<stdlib.h>
void blast(int);
void main()
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"");

//for plane ddawing
for(int i=1;i<=150;i++)
{
//star
setcolor(11);
circle(350,150,2);
circle(350,150,1);
circle(400,100,1);
circle(250,75,2);
circle(250,75,1);
circle(200,50,1);
circle(400,155,2);
circle(400,155,1);
circle(10,100,1);
circle(265,175,2);
circle(265,175,1);
circle(550,50,1);

//for plane
setcolor(YELLOW);
circle(496-i,120,2);
circle(496-i,120,1);
setcolor(4);
line(370-i,130,470-i,140);
line(370-i,130,410-i,110);
line(410-i,110,480-i,130);

line(470-i,140,493-i,122);
line(472-i,140,495-i,122);
line(474-i,140,497-i,122);

    // line(523-i,122,465-i,105);
     // line(474,140,474,150);
rectangle(410-i,120,415-i,125);
rectangle(412-i,120,415-i,125);
rectangle(414-i,120,415-i,125);

rectangle(420-i,123,425-i,128);
rectangle(422-i,123,425-i,128); //plane windows


rectangle(424-i,123,425-i,128);

rectangle(430-i,126,435-i,131);
rectangle(432-i,126,435-i,131);
rectangle(434-i,126,435-i,131);

line(400-i,133,366-i,155);
line(402-i,133,368-i,155);
line(404-i,133,370-i,155);
line(406-i,133,372-i,155);
line(408-i,133,374-i,155);
line(410-i,133,376-i,155);
line(412-i,133,378-i,155);

line(410-i,135,380-i,155);
line(380-i,155,366-i,155);

line(425-i,113,445-i,100);
line(427-i,114,447-i,100);
line(429-i,115,449-i,100);
line(431-i,116,451-i,100);
line(433-i,117,453-i,100);
line(435-i,118,455-i,100);

line(433-i,117,458-i,100);
line(445-i,100,458-i,100);

//for gun drawing

setcolor(GREEN);
line(261,294,261,394);
line(264,294,264,394);
line(267,294,267,394);
line(261,294,270,294);

line(270,294,270,394);
line(250,394,280,394);
line(250,394,250,450);
line(280,394,280,450);
line(240,450,290,450);
line(240,450,240,480);
line(290,450,290,480);
     // line(400,475,375,425);
      // line(325,425,375,425);
    // line(345,425,290,327);
     // line(353,425,298,325);
//bullet
setcolor(12);
circle(265,290-i,5);
circle(265,290-i,4);
circle(265,290-i,3);
circle(265,290-i,2);
circle(265,290-i,1);
if(i==150)
{
setcolor(4);
blast(i);
}
getch();
cleardevice();
}
getch();
}
void blast(int j)
{       getch();
cleardevice();
for(int i=2;i<=75;i++)
{
setcolor(4);
line(j,130,170,140);
line(220,130,320,110);
line(200,110,300,130);

line(260-i,135,265-i,120);
line(250-i,140,255-i,115);
line(270,120-i,290,85-i);
line(280+i,135,290+i,150);
line(290+i,130,300+i,155);



line(275+i,113-i,295+i,100-i);
line(283+i,117-i,308+i,100-i);
line(295+i,100-i,308+i,100-i);

line(250-i,143+i,216-i,175+i);
line(260-i,145+i,230-i,175+i);
line(230-i,175+i,216-i,175+i);

rectangle(260,120-i,265,125-i);
rectangle(262,120-i,265,125-i);
rectangle(264,120-i,265,125-i);

rectangle(270,123+i,275,128+i);
rectangle(272,123+i,275,128+i);
rectangle(274,123+i,275,128+i);

rectangle(280+i,126,285+i,131);
rectangle(282+i,126,285+i,131);
rectangle(284+i,126,285+i,131);
//for bullet
setcolor(12);
circle(265,130-i,1);
circle(265,145+i,1);
circle(260-i,140,1);
circle(275+i,140,1);
circle(267,125-i,1);
circle(262,150+i,1);
circle(255-i,137,1);
circle(280+i,142,1);

//for gun
setcolor(GREEN);
line(261,294,261,394);
line(264,294,264,394);
line(267,294,267,394);
line(261,294,270,294);
line(270,294,270,394);
line(250,394,280,394);
line(250,394,250,450);
line(280,394,280,450);
line(240,450,290,450);
line(240,450,240,480);
line(290,450,290,480);
//star
setcolor(11);
circle(350,150,2);
circle(350,150,1);
circle(400,100,1);
circle(250,75,2);
circle(250,75,1);
circle(200,50,1);
circle(400,155,2);
circle(400,155,1);
circle(10,100,1);
circle(265,175,2);
circle(265,175,1);
circle(550,50,1);

     // line(170-i,140,193-i,122);
     // line(223-i,122,4165-i,125);
     // line(200-i,133,166-i,155);
     // line(210-i,135,180-i,155);
     // line(180-i,155,166-i,155);
     // line(225-i,113,245-i,100);
     // line(233-i,117,258-i,100);
     // line(245-i,100,258-i,100);
getch();
cleardevice();
}
getch();
       // cleardevice();
}

Chess Board

#include<stdio.h>
#include<graphics.h>
#include<stdlib.h>
#include<conio.h>
#include<dos.h>
void right(int,int);
void main()
{
int gd=DETECT,gm,i,t,j;
initgraph(&gd,&gm,"");
setcolor(4);

//vertical
line(225,200,225,400);
line(250,200,250,400);
line(275,200,275,400);
line(300,200,300,400);
line(325,200,325,400);
line(350,200,350,400);
line(375,200,375,400);
//horizontal
line(200,225,400,225);
line(200,250,400,250);
line(200,275,400,275);
line(200,300,400,300);
line(200,325,400,325);
line(200,350,400,350);
line(200,375,400,375);
setlinestyle(0,5,3);
rectangle(200,200,400,400);
//circle
setlinestyle(0,5,1);
setcolor(YELLOW);
circle(212,212,1);
circle(212,212,2);
printf("Enter your option for move:\n");
printf("1:Right\n2:Forward\n3:Side\tOption:");
scanf("%d",&t);
switch(t)
{
case 1:
{
int m=0;
j=1;
right(m,j);
}
case 2:
{
int m=1;
j=0;
right(m,j);
}



}
getch();
}
void right(int l,int i)
{
if(l==1)
{
i=l;
}
getch();
for(i=1;i<=25;i++)
{
setcolor(4);

//vertical
line(225,200,225,400);
line(250,200,250,400);
line(275,200,275,400);
line(300,200,300,400);
line(325,200,325,400);
line(350,200,350,400);
line(375,200,375,400);
//horizontal
line(200,225,400,225);
line(200,250,400,250);
line(200,275,400,275);
line(200,300,400,300);
line(200,325,400,325);
line(200,350,400,350);
line(200,375,400,375);
setlinestyle(0,5,3);
rectangle(200,200,400,400);
//circle
setlinestyle(0,5,1);
setcolor(YELLOW);
circle(212+l,212+i,1);
circle(212+l,212+i,2);
delay(50);
cleardevice();
}
}

Car Moving

//moving car
#include<graphics.h>
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<dos.h>
void main()
{
int xc,yc,x1,y1,x;
int gd=DETECT,gm;
initgraph(&gd,&gm,"");
for(x=0;x<200;x=x+20)
{
line(100+x,100,50+x,200);
line(100+x,100,300+x,100);
line(300+x,100,325+x,150);
line(325+x,150,375+x,150);
line(375+x,150,375+x,200);
line(50+x,200,125+x,200);
circle(150+x,200,25);
line(175+x,200,225+x,200);
circle(250+x,200,25);
line(275+x,200,375+x,200);
line(50+x,200,25+x,200);
line(58+x,190,25+x,190);
circle(25+x,195,5);

fillellipse(10-x,195,5,5);
fillellipse(25-x,195,5,5);
fillellipse(40-x,195,5,5);
fillellipse(65-x,195,5,5);
fillellipse(80-x,195,5,5);
fillellipse(95-x,195,5,5);

sleep(1);
clrscr();
}
getch();
}

Bucket

#include<graphics.h>
#include<conio.h>
#include<stdlib.h>
#include<dos.h>
void main()
{
int xc,yc,r,x=0,y=0;
int gd=DETECT,gm;
initgraph(&gd,&gm,"");

for(int i=0;i<50;i=i+5)
{
setcolor(4);
line(200,90,340,90);
line(200,86,340,86);
line(340,90,330,180);
line(340,86,350,180);
circle(340,88,2);
line(320,120,320,200);
line(320,200,400,200);
line(400,200,400,120);
ellipse(360,120,0,360,40,10);
fillellipse(360,200,40,10);
rectangle(320,200-i,400,200);
sleep(1);
clrscr();
fillellipse(360,200-i,40,10);
//floodfill(360,200,1);
}

}

Bouncing Ball

#include<stdio.h>
#include<graphics.h>
#include<math.h>
#define ROUND(a)((int)(a+0.5))
void paraCircle(int,int,int,int);
int base=400;
int color=15;
void parabola()
{
 int xo=70,x=0,yo=base,theta=0;
 float vh=10.0,vy=80.0;
 int vhit=0;
 int y=0;
 float t;
 int dly=40;
 int xmax=getmaxx();
 outtextxy(20,50,"Press any key to throw");
 paraCircle(xo,yo,10,theta);
 line(0,base+10,xmax-20,base+10);
 line(xmax-20,0,xmax-20,base+10);
 getch();
 do
 {
  theta=0;
  paraCircle(xo,yo,10,theta);
  for(t=1;;t+=.2)
  {
   x=ROUND(xo+(vh*t));
   y=ROUND(yo-(vy*t)+5*(t*t));
   line(0,base+10,xmax-20,base+10);
   line(xmax-20,0,xmax-20,base+10);
   paraCircle(x,y,10,theta);
   delay(dly);
   cleardevice();
   if(x==xmax-30)
   {
    vh=-vh;
    vhit=1;
   }
   if(vhit==0)
    theta+=10;
   else  
    theta-=10;
   if(y==base)
    break;
  }
  vy-=5;
  if(vhit==0)
   vh-=1;
  else if(vhit==1)
   vh+=1;
  dly-=4;
  paraCircle(x,y,10,theta);
  xo=x;
 }while(vy>0&&vh!=0);
 line(0,base+10,xmax-20,base+10);
 line(xmax-20,0,xmax-20,base+10);
}
void paraCircle(int xc,int yc,int r,int t)
{
 int i,x,y;
 for(i=0;i<90;i++)
 {
  x=xc+ROUND(r*cos(3.1412*(i+t)/180));
  y=yc+ROUND(r*sin(3.1412*(i+t)/180));
  putpixel(x,y,5);
 }
 for(i=90;i<180;i++)
 {
  x=xc+ROUND(r*cos(3.1412*(i+t)/180));
  y=yc+ROUND(r*sin(3.1412*(i+t)/180));
  putpixel(x,y,2);
 }
 for(i=180;i<270;i++)
 {
  x=xc+ROUND(r*cos(3.1412*(i+t)/180));
  y=yc+ROUND(r*sin(3.1412*(i+t)/180));
  putpixel(x,y,12);
 }
 for(i=270;i<360;i++)
 {
  x=xc+ROUND(r*cos(3.1412*(i+t)/180));
  y=yc+ROUND(r*sin(3.1412*(i+t)/180));
  putpixel(x,y,7);
 }
}
int main()
{
 int gd=DETECT,gm=VGAMAX;
 initgraph(&gd,&gm,"NULL");
 parabola();
 while(!kbhit());
 closegraph();
 return 0;
}

Line Clipping Algorithm

#include <stdio.h>
#include <graphics.h>
#include <conio.h>
#include <math.h>
#define TRUE 1
#define FALSE 0
typedef unsigned int outcode;
outcode CompOutCode(float x,float y);
enum  {  TOP = 0x1,
BOTTOM = 0x2,
RIGHT = 0x4,
LEFT = 0x8
};
float xmin,xmax,ymin,ymax;
void clip(float x0,float y0,float x1,float y1)
{
outcode outcode0,outcode1,outcodeOut;
int accept = FALSE,done = FALSE;
outcode0 = CompOutCode(x0,y0);
outcode1 = CompOutCode(x1,y1);
do
{
if(!(outcode0|outcode1))
{
accept = TRUE;
done = TRUE;
}
else
if(outcode0 & outcode1)
done = TRUE;
else
{
float x,y;
outcodeOut = outcode0?outcode0:outcode1;
if(outcodeOut & TOP)
{
 
x = x0+(x1-x0)*(ymax-y0)/(y1-y0);
y = ymax;
}
else
if(outcodeOut & BOTTOM)
{
x = x0+(x1-x0)*(ymin-y0)/(y1-y0);
y = ymin;
}
else
if(outcodeOut & RIGHT)
{
y = y0+(y1-y0)*(xmax-x0)/(x1-x0);
x = xmax;
}
else
{
y = y0+(y1-y0)*(xmin-x0)/(x1-x0);
x = xmin;
}
if(outcodeOut==outcode0)
{
x0 = x;
y0 = y;
outcode0 = CompOutCode(x0,y0);
}
else
{
x1 = x;
y1 = y;
outcode1 = CompOutCode(x1,y1);
}
}
}while(done==FALSE);
if(accept)
line(x0,y0,x1,y1);
outtextxy(200,20,"LINE AFTER CLIPPING");
rectangle(xmin,ymin,xmax,ymax);
}
 
outcode CompOutCode(float x,float y)
{
outcode code = 0;
if(y>ymax)
code|=TOP;
else
if(y<ymin)
code|=BOTTOM;
if(x>xmax)
code|=RIGHT;
else
if(x<xmin)
code|=LEFT;
return code;
}
void main( )
{
float x1,y1,x2,y2;
int gdriver = DETECT, gmode ;
printf("\nEnter the endpoints of line\n");
scanf("%f%f%f%f",&x1,&y1,&x2,&y2);
printf("Enter the rectangular coordinates of clipping window\n");
scanf("%f%f%f%f",&xmin,&ymin,&xmax,&ymax);
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "c:\\tc\\bgi");
outtextxy(200,20,"LINE BEFORE CLIPPING");
line(x1,y1,x2,y2);
rectangle(xmin,ymin,xmax,ymax);
getch( );
cleardevice( );
clip(x1,y1,x2,y2);
getch( );
restorecrtmode( );
}

Polygon Clipping Program

     #include <stdio.h>
#include <graphics.h>
#include <conio.h>
#include <math.h>
#include <process.h>
#define TRUE 1
#define FALSE 0
typedef unsigned int outcode;
outcode CompOutCode(float x,float y);
enum  {  TOP = 0x1,
BOTTOM = 0x2,
RIGHT = 0x4,
LEFT = 0x8
};
float xmin,xmax,ymin,ymax;
void clip(float x0,float y0,float x1,float y1)
{
outcode outcode0,outcode1,outcodeOut;
int accept = FALSE,done = FALSE;
outcode0 = CompOutCode(x0,y0);
outcode1 = CompOutCode(x1,y1);
do
{
if(!(outcode0|outcode1))
{
accept = TRUE;
done = TRUE;
}
else
if(outcode0 & outcode1)
done = TRUE;
else
{
float x,y;
 
outcodeOut = outcode0?outcode0:outcode1;
if(outcodeOut & TOP)
{
x = x0+(x1-x0)*(ymax-y0)/(y1-y0);
y = ymax;
}
else
if(outcodeOut & BOTTOM)
{
x = x0+(x1-x0)*(ymin-y0)/(y1-y0);
y = ymin;
}
else
if(outcodeOut & RIGHT)
{
y = y0+(y1-y0)*(xmax-x0)/(x1-x0);
x = xmax;
}
else
{
y = y0+(y1-y0)*(xmin-x0)/(x1-x0);
x = xmin;
}
if(outcodeOut==outcode0)
{
x0 = x;
y0 = y;
outcode0 = CompOutCode(x0,y0);
}
else
{
x1 = x;
y1 = y;
outcode1 = CompOutCode(x1,y1);
}
}
}while(done==FALSE);
if(accept)
line(x0,y0,x1,y1);
outtextxy(150,20,"POLYGON AFTER CLIPPING");
 
rectangle(xmin,ymin,xmax,ymax);
}
outcode CompOutCode(float x,float y)
{
outcode code = 0;
if(y>ymax)
code|=TOP;
else
if(y<ymin)
code|=BOTTOM;
if(x>xmax)
code|=RIGHT;
else
if(x<xmin)
code|=LEFT;
return code;
}
void main( )
{
float x1,y1,x2,y2;
/* request auto detection */
int gdriver = DETECT, gmode, n,poly[14],i;
clrscr( );
printf("Enter the no of sides of polygon:");
scanf("%d",&n);
printf("\nEnter the coordinates of polygon\n");
for(i=0;i<2*n;i++)
{
scanf("%d",&poly[i]);
}
poly[2*n]=poly[0];
poly[2*n+1]=poly[1];
printf("Enter the rectangular coordinates of clipping window\n");
scanf("%f%f%f%f",&xmin,&ymin,&xmax,&ymax);
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "c:\\tc\\bgi");
 
outtextxy(150,20,"POLYGON BEFORE CLIPPING");
drawpoly(n+1,poly);
rectangle(xmin,ymin,xmax,ymax);
getch( );
cleardevice( );
for(i=0;i<n;i++)
clip(poly[2*i],poly[(2*i)+1],poly[(2*i)+2],poly[(2*i)+3]);
getch( );
restorecrtmode( );
}