Computer Graphics

Index:
(1) DIGITAL DIFFERENTIAL ANALYSER CODE
(2) Center shifted Modified Bresenham algorithm
(3) BRESENHAM'S CIRCLE
(4) Midpoint circle algorithm
(5) Mid point Ellipse Drawing
(6) SUTHERLAND-HODGMAN POLYGON CLIPPING
(7) Liang Barsky Algorithm
(8) Line clipping using cohen sutherland
(9) Polygon filling algorithm using scanline fill algorithm
 
---------------------------------------------------------------------------------------------------------------------------------  
 Programs:

(1) DIGITAL DIFFERENTIAL ANALYSER CODE

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

void main()
{

int gd,gm;
float xi,yi,x,y;
int xmax,ymax,xo,yo; /*declaring x and y increments,coordinates*/
int x1,y1,x2,y2,dx,dy,steps,k; /*declaring pixel positions*/

clrscr();

printf("Enter the co-ordinates of first point (x1 y1) : ");
scanf("%d %d",&x1,&y1);
printf("Enter the co-ordinates of second point (x2 y2): ");
scanf("%d %d",&x2,&y2);

detectgraph(&gd,&gm);
initgraph(&gd,&gm,"c:\\tc\\bgi"); /*Initialisation of graphics*/

xmax=640;ymax=480;
xo=xmax/2;yo=ymax/2; /*divides the screen so that the origin is
shifte to origin*/
line(320,0,320,480); /*plotting x and y axis on the screen*/
line(0,240,640,240);

dx = x2 - x1; /*calculating the distance between the x coordinates(Horizontal difference)*/
dy = y2 - y1; /*calculating the distance between the y coordinates(vertical difference)*/

if(abs(dx) > abs(dy)) /*checking the value of slope to determine the value of parameter steps*/
steps = abs(dx);
else
steps = abs(dy);

xi = (float)dx/steps;
yi = (float)dy/steps;


x = x1; /*original values*/
y = y1;

for(k=0;k<=steps;k++) /*Looping through the process steps time*/
{
putpixel(xo+x, ymax-(yo+y), WHITE);

/*If dx>dy and x1<x2,values of increments in x and y are 1 and m,but if
x1>x2,decrements of -1 and -m generate new point on the line*/
/* otherwise if dy>dx unit increment or decrement in y direction and x increment or decrement of 1/m */

x = x + xi;
y = y + yi;

}

getch();
closegraph();

}/*-main()-*/
 
  ---------------------------------------------------------------------------------------------------------------------------------

(2) Center shifted Modified Bresenham algorithm

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

void main()
{
int k,dx,dy,x,y,p,x1,y1,x2,y2;
int gd,gm,xo,yo,xmax,ymax,xincre,yincre ;

clrscr();

printf("\n\n\tEnter the co-ordinates of first point : ");
scanf("%d %d",&x1,&y1);
printf("\n\n\tEnter the co-ordinates of second point : ");
scanf("%d %d",&x2,&y2);

dx = (x2 - x1);
dy = (y2 - y1);

p = 2 * abs(dy) - abs(dx);

detectgraph(&gd,&gm);
initgraph(&gd,&gm,"c:\\tc\\bgi");

xmax = 640; ymax = 480;
xo = xmax/2; yo = ymax/2;

line(320,0,320,480);
line(0,240,640,240);

x = x1; y = y1;

putpixel(xo+x1, ymax-(yo+y1), WHITE);

xincre = dx/abs(dx);
yincre = dy/abs(dy);

if(abs(dy) < abs(dx))
{
for(k=0; k<=abs(dx); k++)
{

x = x + xincre;

if(p < 0)
p = p + 2 * abs(dy);
else
{
y = y + yincre;
p = p + 2 * (abs(dy) - abs(dx));
}

putpixel(xo+x, ymax-(yo+y), WHITE);
}
}
else
{
for(k=0; k<=abs(dy); k++)
{
y = y + yincre;

if(p < 0)
p = p + 2 * abs(dx);
else
{
x = x + xincre;
p = p + 2 * (abs(dx) - abs(dy));
}

putpixel(xo+x, ymax-(yo+y), WHITE);
}
}

getch();
closegraph();

}

---------------------------------------------------------------------------------------------------------------------------------
 
(3) BRESENHAM'S CIRCLE

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

void main()
{
int gd=DETECT,gm;
int r,x,y,p,xc=320,yc=240; /*INPUT radius and center coordinates*/

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


printf("Enter the radius ");
scanf("%d",&r);


x=0; /*obtaining first point on circmference of circle*/
y=r;
putpixel(xc+x,yc-y,1);

p=3-(2*r); /*decision parameter*/

for(x=0;x<=y;x++)
{
if (p<0)
{
y=y;
p=(p+(4*x)+6);
}
else
{
y=y-1;

p=p+((4*(x-y)+10));
}

putpixel(xc+x,yc-y,1);
putpixel(xc-x,yc-y,2);
putpixel(xc+x,yc+y,3);
putpixel(xc-x,yc+y,4);
putpixel(xc+y,yc-x,5);
putpixel(xc-y,yc-x,6);
putpixel(xc+y,yc+x,7);
putpixel(xc-y,yc+x,8);

}
getch();
closegraph();
}


---------------------------------------------------------------------------------------------------------------------------------
  
 (4) Midpoint circle algorithm

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

void main() /*main Startes*/
{

int gd=DETECT,gm;
int x,y,r;
void Drawcircle(int,int,int);
/*taking radius*/
printf("Enter the Mid points and Radious:");
scanf("%d%d%d",&x,&y,&r);
initgraph(&gd,&gm,"c:\\tc\\bgi ");
Drawcircle(x,y,r);/*function called*/
getch();
closegraph();
} /*main ends*/
/*function for drawing circle*/
void Drawcircle(int x1,int y1,int r)
{

int x=0,y=r,p=1-r;
void cliplot(int,int,int,int);
cliplot(x1,y1,x,y); /*function called */
/*calculate pixel position(x,y) onto the cercular pat center on (x0y0)
and plot the co-ordinates*/
while(x<y)
{
x++;
if(p<0)
p+=2*x+1;
else
{
y--;
p+=2*(x-y)+1;
}
cliplot(x1,y1,x,y);
}
}
/*drawing*/
void cliplot(int xctr,int yctr,int x,int y)/*function*/
{

putpixel(xctr +x,yctr +y,1);
putpixel(xctr -x,yctr +y,1);
putpixel(xctr +x,yctr -y,1);
putpixel(xctr -x,yctr -y,1);
putpixel(xctr +y,yctr +x,1);
putpixel(xctr -y,yctr +x,1);
putpixel(xctr +y,yctr -x,1);
putpixel(xctr -y,yctr -x,1);
getch();
}
---------------------------------------------------------------------------------------------------------------------------------

(5) Mid point Ellipse Drawing 

 #include<stdio.h>
#include<graphics.h>
#include<conio.h>
void putelpix(float xc,float yc,float x,float y)
{
putpixel((int)(xc+x),(int)(yc+y),15);
putpixel((int)(xc-x),(int)(yc-y),15);
putpixel((int)(xc+x),(int)(yc-y),15);
putpixel((int)(xc-x),(int)(yc+y),15);
}
/*Calculating initial value of decision parameter in regions*/
void mdpt(float xc,float yc,float rx,float ry)
{
float x=0,y=ry,p1,p2,t1,t2;
int k;
/*Calculating initial value of decision parameter in region 1*/
p1=ry*ry-rx*rx*ry+0.25*rx*rx;
putelpix(xc,yc,x,y);
for(k=0;(2*ry*ry*x)<=(2*rx*rx*y);k++)
{
t1=2*ry*ry*x+2*ry*ry;
t2=2*rx*rx*y-2*rx*rx;
if(p1<0)
p1=p1+t1+ry*ry;
else
{
p1=p1+t1-t2+ry*ry;
y--;
}
x++;
putelpix(xc,yc,x,y);

}
/*Calculating initial value of decision parameter in region 2*/
p2=ry*ry*(x+.5)*(x+.5)+rx*rx*(y-1)*(y-1)-rx*rx*ry*ry;
putelpix(xc,yc,x,y);
for(k=0;y>=0;k++)
{
t1=2*ry*ry*x+2*ry*ry;
t2=2*rx*rx*y-2*rx*rx;
if(p2>0)
p2=p2-t2+rx*rx;
else
{
p2=p2+t1-t2+rx*rx;
x++;
}
y--;
putelpix(xc,yc,x,y);

}
}
void main()/*Main started*/
{
int gd=DETECT,gm;
float xc,yc,rx,ry;
initgraph(&gd,&gm,"c:\\tc\\bgi");
/* obtaining the first point on an ellipse for centering the origin*/
printf("Enter Ellipes center coordinates x,y");
scanf("%f%f",&xc,&yc);
printf("Enter Ellipes center coordinates rx,ry");
scanf("%f%f",&rx,&ry);
mdpt(xc,yc,rx,ry); /**Calling midpoint function/
getch();
closegraph();
}/*Main Endes */
 

---------------------------------------------------------------------------------------------------------------------------------

(6) SUTHERLAND-HODGMAN POLYGON CLIPPING

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

int n,p,x,y,i,j;
int xwmin,ywmin,xwmax,ywmax;
int x1,y1,x2,y2,xmax,ymax;
float m;
char flag;
float dy,dx;

main()
{


int gd,gm;
int a[10][10],b[10][10],c[10][10],d[10][10],e[10][10];

detectgraph(&gd,&gm);
initgraph(&gd,&gm,"c:\\tc\\bgi");


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];


printf("\n\tEnter the co_ordinates of window :\n ");
printf("\n\txwmin , ywmin : ");
scanf("%d %d",&xwmin,&ywmin);
printf("\n\txwmax , ywmax : ");
scanf("%d %d",&xwmax,&ywmax);


xmax = 640; ymax = 480;

cleardevice();

setcolor(35);
for(i=0;i<n;i++)
{
line(a[i][0],ymax-a[i][1],a[i+1][0],ymax-a[i+1][1]);
}
rectangle(xwmin,ymax-ywmin,xwmax,ymax-ywmax);
getch();
setcolor(35);

clip_left(a,b);
clip_right(b,c);
clip_bottom(c,d);
clip_top(d,e);

cleardevice();
setcolor(63);
for(i=0;i<p;i++)
{
line(e[i][0],ymax-e[i][1],e[i+1][0],ymax-e[i+1][1]);
}
getch();




}/*-main()-*/

/*---------------------------------------------------------------*/

clip_left(int a[10][10], int b[10][10])
{

p=0;flag=0;m=0;
for(i=0;i<n;i++)
{

dy=a[i+1][1]-a[i][1];
dx=a[i+1][0]-a[i][0];


if((dx!=0)&&(dy!=0))
{
m=(dy/dx);
}

if((a[i][0]<xwmin)&&(a[i+1][0]>=xwmin) ) flag=0;
if((a[i][0]>=xwmin)&&(a[i+1][0]>=xwmin)) flag=1;
if((a[i][0]>=xwmin)&&(a[i+1][0]<xwmin)) flag=2;
if((a[i][0]<xwmin)&&(a[i+1][0]<xwmin) ) flag=3;


switch(flag)
{
case 0 :
x=xwmin;
if(dy!=0)
y=(int)(a[i][1]+m*(x-a[i][0]));
else
y=a[i][1];

b[p][0]=x;
b[p][1]=y;
p++;

b[p][0]=a[i+1][0];
b[p][1]=a[i+1][1];
p++;
break;

case 1 :
b[p][0]=a[i+1][0];
b[p][1]=a[i+1][1];
p++;
break;

case 2 :
x=xwmin;
if(dy!=0)
y=(int)(a[i][1]+m*(x-a[i][0]));
else
y=a[i][1];

b[p][0]=x;
b[p][1]=y;
p++;
}


}/*-for()-*/

b[p][0]=b[0][0];
b[p][1]=b[0][1];

cleardevice();
setcolor(35);
rectangle(xwmin,ymax-ywmin,xwmax,ymax-ywmax);
setcolor(63);

for(i=0;i<p;i++)
{
line(b[i][0],ymax-b[i][1],b[i+1][0],ymax-b[i+1][1]);
getch();
}
getch();
}

/*--------------------------------------------------------*/


clip_right(int b[10][10],int c[10][10])
{

n=p; p=0; m=0;

for(i=0;i<n;i++)
{
dy=b[i+1][1]-b[i][1];
dx=b[i+1][0]-b[i][0];

if((dx!=0)&&(dy!=0))
{
m=(dy/dx);
}

if((b[i][0]>xwmax)&&(b[i+1][0]<=xwmax) ) flag=0;
if((b[i][0]<=xwmax)&&(b[i+1][0]<=xwmax) ) flag=1;
if((b[i][0]<=xwmax)&&(b[i+1][0]>xwmax) ) flag=2;
if((b[i][0]>xwmax)&&(b[i+1][0]>xwmax) ) flag=3;


switch(flag)
{
case 0 :
x=xwmax;
if(dy!=0)
y=(int)(b[i][1]+m*(x-b[i][0]));
else
y=b[i][1];

c[p][0]=x;
c[p][1]=y;
p++;
c[p][0]=b[i+1][0];
c[p][1]=b[i+1][1];
p++;
break;

case 1 :
c[p][0]=b[i+1][0];
c[p][1]=b[i+1][1];
p++;
break;

case 2 :
x=xwmax;
if(dy!=0)
y=(int)(b[i][1]+m*(x-b[i][0]));
else
y=b[i][1];

c[p][0]=x;
c[p][1]=y;
p++;
}


}/*-for()-*/

c[p][0]=c[0][0];
c[p][1]=c[0][1];

cleardevice();
setcolor(35);
rectangle(xwmin,ymax-ywmin,xwmax,ymax-ywmax);
setcolor(63);

for(i=0;i<p;i++)
{
line(c[i][0],ymax-c[i][1],c[i+1][0],ymax-c[i+1][1]);
getch();
}
getch();


}


/*--------------------------------------------------------*/

clip_bottom(int c[10][10],int d[10][10])
{

n=p; p=0; m=0;

for(i=0;i<n;i++)
{
dy=c[i+1][1]-c[i][1];
dx=c[i+1][0]-c[i][0];

if((dx!=0)&&(dy!=0))
{
m=(dy/dx);
}


if((c[i][1]<ywmin)&&(c[i+1][1]>=ywmin) ) flag=0;
if((c[i][1]>=ywmin)&&(c[i+1][1]>=ywmin) ) flag=1;
if((c[i][1]>=ywmin)&&(c[i+1][1]<ywmin) ) flag=2;
if((c[i][1]<ywmin)&&(c[i+1][1]<ywmin) ) flag=3;


switch(flag)
{

case 0 :
y=ywmin;
if(dx!=0)
x=abs((int)(c[i][0]+(1/m)*(y-c[i][1])));
else
x=c[i][0];

d[p][0]=x;
d[p][1]=y;
p++;
d[p][0]=c[i+1][0];
d[p][1]=c[i+1][1];
p++;
break;

case 1 :
d[p][0]=c[i+1][0];
d[p][1]=c[i+1][1];
p++;
break;

case 2 :
y=ywmin;
if(dx!=0)
x=abs((int)(c[i][0]+(1/m)*(y-c[i][1])));
else
x=c[i][0];

d[p][0]=x;
d[p][1]=y;
p++;
}



}/*-for()-*/

d[p][0]=d[0][0];
d[p][1]=d[0][1];

cleardevice();
setcolor(35);
rectangle(xwmin,ymax-ywmin,xwmax,ymax-ywmax);
setcolor(63);

for(i=0;i<p;i++)
{
line(d[i][0],ymax-d[i][1],d[i+1][0],ymax-d[i+1][1]);
getch();
}
getch();


}

/*--------------------------------------------------------*/

clip_top(int d[10][10],int e[10][10])
{

n=p;
p=0;

for(i=0;i<n;i++)
{

dy=d[i+1][1]-d[i][1];
dx=d[i+1][0]-d[i][0];

if((dx!=0)&&(dy!=0))
{
m=(dy/dx);
}

if((d[i][1]>ywmax)&&(d[i+1][1]<=ywmax) ) flag=0;
if((d[i][1]<=ywmax)&&(d[i+1][1]<=ywmax) ) flag=1;
if((d[i][1]<=ywmax)&&(d[i+1][1]>ywmax) ) flag=2;
if((d[i][1]>ywmax)&&(d[i+1][1]>ywmax) ) flag=3;

switch(flag)
{
case 0 :
y=ywmax;
if(dx!=0)
x=abs((int)(d[i][0]+(1/m)*(y-d[i][1])));
else
x=d[i][0];

e[p][0]=x;
e[p][1]=y;
p++;
e[p][0]=d[i+1][0];
e[p][1]=d[i+1][1];
p++;
break;

case 1 :
e[p][0]=d[i+1][0];
e[p][1]=d[i+1][1];
p++;
break;

case 2 :
y=ywmax;
if(dx!=0)
x=abs((int)(d[i][0]+(1/m)*(y-d[i][1])));
else
x=d[i][0];

e[p][0]=x;
e[p][1]=y;
p++;
}

}/*-for()-*/

e[p][0]=e[0][0];
e[p][1]=e[0][1];


cleardevice();
setcolor(35);
rectangle(xwmin,ymax-ywmin,xwmax,ymax-ywmax);
setcolor(63);

for(i=0;i<p;i++)
{
line(e[i][0],ymax-e[i][1],e[i+1][0],ymax-e[i+1][1]);
getch();
}
 getch();
}

 

---------------------------------------------------------------------------------------------------------------------------------

(7) Liang Barsky Algorithm 

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

void main()
{
int gd, gm ;
int x1 , y1 , x2 , y2 ;

int wxmin , wymin , wxmax , wymax ;
float u1 = 0.0 , u2 = 1.0 ;

int p1 , q1 , p2 , q2 , p3 , q3 , p4 ,q4 ;
float r1 , r2 , r3 , r4 ;
int x11 , y11 , x22 , y22 ;

clrscr();
printf("Enter the windows left , bottom boundry\n");
scanf("%d%d",&wxmin,&wymin);
printf("Enter the windows right ,bottom boundry\n");
scanf("%d%d",&wxmax,&wymax);

printf("Enter line x1 , y1 co-ordinate\n");
scanf("%d%d",&x1,&y1);

printf("Enter line x2 , y2 co-ordinate\n");
scanf("%d%d",&x2,&y2);


p1 = -(x2 - x1 ); q1 = x1 - wxmin ;
p2 = ( x2 - x1 ) ; q2 = wxmax - x1 ;
p3 = - ( y2 - y1 ) ; q3 = y1 - wymin ;
p4 = ( y2 - y1 ) ; q4 = wymax - y1 ;

if( ( ( p1 == 0.0 ) && ( q1 < 0.0 ) ) ||
( ( p2 == 0.0 ) && ( q2 < 0.0 ) ) ||
( ( p3 == 0.0 ) && ( q3 < 0.0 ) ) ||
( ( p4 == 0.0 ) && ( q4 < 0.0 ) ) )
{
printf("Line is rejected\n");
initgraph(&gd,&gm,"c:\\tc\\bgi");
setcolor(2);
rectangle(wxmin,wymax,wxmax,wymin);
setcolor(1);
line(x1,y1,x2,y2);
getch();
setcolor(0);
line(x1,y1,x2,y2);
getch();
}
else
{
if( p1 != 0.0 )
{
r1 =(float) q1 /p1 ;
if( p1 < 0 )
u1 = max(r1 , u1 );
else
u2 = min(r1 , u2 );
}
if( p2 != 0.0 )
{
r2 = (float ) q2 /p2 ;
if( p2 < 0 )
u1 = max(r2 , u1 );
else
u2 = min(r2 , u2 );

}
if( p3 != 0.0 )
{
r3 = (float )q3 /p3 ;
if( p3 < 0 )
u1 = max(r3 , u1 );
else
u2 = min(r3 , u2 );
}
if( p4 != 0.0 )
{
r4 = (float )q4 /p4 ;
if( p4 < 0 )
u1 = max(r4 , u1 );
else
u2 = min(r4 , u2 );
}

if( u1 > u2 )
printf("line rejected\n");
else
{
x11 = x1 + u1 * ( x2 - x1 ) ;
y11 = y1 + u1 * ( y2 - y1 ) ;

x22 = x1 + u2 * ( x2 - x1 );
y22 = y1 + u2 * ( y2 - y1 );

printf("Original line cordinates\n");
printf("x1 = %d , y1 = %d, x2 = %d, y2 = %d\n",x1,y1,x2,y2);

printf("Windows coordiante are \n");
printf("wxmin = %d, wymin = %d,wxmax = %d , wymax = %d ",wxmin,wymin,wxmax,wymax);

printf("New coordinates are \n");
printf("x1 = %d, y1 = %d,x2 = %d , y2 = %d\n",x11,y11,x22,y22);

initgraph(&gd,&gm,"");
setcolor(2);
rectangle(wxmin,wymax,wxmax,wymin);
setcolor(1);
line(x1,y1,x2,y2);
getch();
setcolor(0);
line(x1,y1,x2,y2);

setcolor(3);
line(x11,y11,x22,y22);
getch();

}
}
}

---------------------------------------------------------------------------------------------------------------------------------

 (8) Line clipping using cohen sutherland

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

typedef unsigned int outcode;
enum { TOP=0x1, BOTTOM=0x2, RIGHT=0x4, LEFT=0x8 };

void lineclip(x0,y0,x1,y1,xwmin,ywmin,xwmax,ywmax )
float x0,y0,x1,y1,xwmin,ywmin,xwmax,ywmax;
{

int gd,gm;
outcode code0,code1,codeout;
int accept = 0, done=0;

code0 = calcode(x0,y0,xwmin,ywmin,xwmax,ywmax);
code1 = calcode(x1,y1,xwmin,ywmin,xwmax,ywmax);

do{
if(!(code0 | code1))
{ accept =1 ; done =1; }
else
if(code0 & code1) done = 1;
else
{
float x,y;
codeout = code0 ? code0 : code1;
if(codeout & TOP)
{
x = x0 + (x1-x0)*(ywmax-y0)/(y1-y0);
y = ywmax;
}
else
if( codeout & BOTTOM)
{
x = x0 + (x1-x0)*(ywmin-y0)/(y1-y0);
y = ywmin;
}
else
if ( codeout & RIGHT)
{
y = y0+(y1-y0)*(xwmax-x0)/(x1-x0);
x = xwmax;
}
else
{
y = y0 + (y1-y0)*(xwmin-x0)/(x1-x0);
x = xwmin;
}
if( codeout == code0)
{
x0 = x; y0 = y;
code0=calcode(x0,y0,xwmin,ywmin,xwmax,ywmax);
}
else
{
x1 = x; y1 = y;
code1 = calcode(x1,y1,xwmin,ywmin,xwmax,ywmax);
}
}
} while( done == 0);

if(accept) line(x0,y0,x1,y1);

rectangle(xwmin,ywmin,xwmax,ywmax);

getch();

}
/*--------------------------------------------------------------------*/

int calcode (x,y,xwmin,ywmin,xwmax,ywmax)
float x,y,xwmin,ywmin,xwmax,ywmax;
{
int code =0;

if(y> ywmax)
code |=TOP;
else if( y<ywmin)
code |= BOTTOM;
else if(x > xwmax)
code |= RIGHT;
else if ( x< xwmin)
code |= LEFT;

return(code);
}

/*-------------------------------------------------*/

main()
{

float x2,y2,x1,y1,xwmin,ywmin,xwmax,ywmax;
int gd,gm;

detectgraph(&gd,&gm);
initgraph(&gd,&gm,"c:\\tc\\bgi");

clrscr();
printf("\n\n\tEnter the co-ordinates of Line :");

printf("\n\n\tX1 Y1 : ");
scanf("%f %f",&x1,&y1);

printf("\n\n\tX2 Y2 : ");
scanf("%f %f",&x2,&y2);


printf("\n\tEnter the co_ordinates of window :\n ");
printf("\n\txwmin , ywmin : ");
scanf("%f %f",&xwmin,&ywmin);
printf("\n\txwmax , ywmax : ");
scanf("%f %f",&xwmax,&ywmax);

line(x1,y1,x2,y2);
rectangle(xwmin,ywmin,xwmax,ywmax);
getch();
cleardevice();

lineclip(x1,y1,x2,y2,xwmin,ywmin,xwmax,ywmax );
getch();
closegraph();

}


---------------------------------------------------------------------------------------------------------------------------------

 (9) Polygon filling algorithm using scanline fill algorithm

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

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," ");

for(i=0;i<n;i++) /*- draw poly -*/
{
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++)
{

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(RED);
for(i=0;i<k;i+=2)
{
line(xi[i],y,xi[i+1]+1,y);
delay(10);
}

}/*-for(y)-*/
getch();

}/*-main()-*/