Bezier Curves

#include”GL/glut.h”
#include <math.h>

struct Points
{
float x,y;
}draw;

int i,p[4][2];
float t;
void display();

void Init()
{
glClearColor(0.0,0.0,0.0,0.0);

gluOrtho2D(0.0,640,0.0,480.0);

}

void draw_curve()
{
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_POINTS);
glEnd();
glFlush();
glColor3f(1.0,0.0,1.0);
glBegin(GL_LINE_STRIP);
for(t=0;t<=1;t=t+0.01)
{
draw.x=powf((1-t),3)*p[0][0]+3*powf((1-t),2)*t*p[1][0]+3*(1-t)*t*t*p[2][0]+t*t*t*p[3][0];
draw.y=powf((1-t),3)*p[0][1]+3*powf((1-t),2)*t*p[1][1]+3*(1-t)*t*t*p[2][1]+t*t*t*p[3][1];

glVertex2f(draw.x,draw.y);
}
glEnd();
}

void display()
{
p[0][0]=100;
p[0][1]=100;
p[1][0]=220;
p[1][1]=220;
p[2][0]=350;
p[2][1]=250;
p[3][0]=500;
p[3][1]=180;
draw_curve();

glutSwapBuffers();

}

int main (int argc,char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
glutInitWindowSize(640,480);
glutCreateWindow(“b  curves”);
glutDisplayFunc(display);
Init();
glClear(GL_COLOR_BUFFER_BIT);
glutMainLoop();
return 0;
}

2dimensional transformation

#include<stdio.h>
#include<math.h>
#include<GL/glut.h>

void Changesize(GLsizei w,GLsizei h)
{
glViewport(0,0,w,h);
glLoadIdentity();
gluOrtho2D(0,640,0,480);
}

void draw(void)
{

float x1=110.0,y1=110.0,x2=260.0,y2=260.0,len,xinc,yinc,xn,yn;
int i=0;
float x=0,x3=0,y3=0,y=0,tx,ty,ang=(3.14/2),sy=0.350,sx=0.250,j;
tx=200;
ty=200;

if(fabs(x2-x1)>=fabs(y2-y1))
len= fabs(x2-x1);

else
len= fabs(y2-y1);

xinc = (x2-x1)/len;
yinc = (y2-y1)/len;

glClear(GL_COLOR_BUFFER_BIT);

for(i=0;i<len;i++)
{
glBegin(GL_POINTS);
glColor3f(0.0,0.0,1.0);
glVertex2f(x1,y1);
glEnd();
x1 = x1+xinc;
y1 = y1+yinc;
}
x1=110.0;y1=110.0;x2=260.0;y2=260.0;
for(i=0;i<len;i++)                    /* transformation*/
{
glBegin(GL_POINTS);
glColor3f(1.0,0.0,0.0);
glVertex2f(x1+tx,y1+ty);
glEnd();
x1 = x1+xinc;
y1 = y1+yinc;
}
x1=110.0;y1=110.0;x2=260.0;y2=260.0;
x=x1;
y=y1;
for(i=0;i<len;i++)                   /*rotation*/
{
glBegin(GL_POINTS);
glColor3f(0.0,1.0,1.0);
xn=x+(x1-x)*cos(ang)-(y1-y)*sin(ang);
yn=y+(y1-y)*cos(ang)+(x1-x)*sin(ang);
glVertex2f(xn,yn);
glEnd();
x1 = x1+xinc;
y1 = y1+yinc;
}
x1=110.0;y1=110.0;x2=260.0;y2=260.0;
for(i=0;i<len;i++)                      /*scaling*/
{
glBegin(GL_POINTS);
glColor3f(1.0,1.0,1.0);
glVertex2f(x1*sx,y1*sy);
glEnd();
x1 = x1+xinc;
y1 = y1+yinc;
}
}

int main(int argc,char *argv)
{
glutInit(&argc,&argv);
glutInitWindowSize(640,480);
glutCreateWindow(“2D_TRANSFORMATIONS”);
glutDisplayFunc(draw);
glutReshapeFunc(Changesize);
glColor3f(1.0,1.0,1.0);
glutMainLoop();
return 0;
}

Boundary Filling

#include<stdio.h>
#include<math.h>
#include<GL/glut.h>

//Function to draw line from (x1,y1) to (x2,y2)
void line(float x1,float y1,float x2,float y2)
{
int i,s1,s2,d,dx,dy,t,j;

if((x2-x1)>0)
s1=1;
else
s1=-1;

if((y2-y1)>0)
s2=1;
else
s2=-1;

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

if(dy>dx)
{
t=dx;
dx=dy;
dy=t;
i=1;
}
else
i=0;

d = 2 + dy – dx;

j=0;
glBegin(GL_POINTS);
while(j<=dx)
{
glVertex2f(x1,y1);

while(d>=0)
{
if(i==1)
x1=x1+s1;
else
y1=y1+s1;

d = d – 2 * dx;
}
if(i==1)

y1 = y1 + s2;
else
x1 = x1 + s1;
d = d + 2 * dy;
j++;
}
glEnd();
}

void bfill(int x,int y,GLubyte fc[],GLubyte bc[])
{
GLubyte pixel[3];

glReadPixels(x,y,1,1,GL_RGB,GL_UNSIGNED_BYTE,(void *)pixel);

if(!(fc[0]==pixel[0] && fc[1]==pixel[1] && fc[2]==pixel[2]) && !(bc[0]==pixel[0] && bc[1]==pixel[1] && bc[2]==pixel[2]))
{
glColor3f(fc[0],fc[1],fc[2]);
glBegin(GL_POINTS);
glVertex2f(x,y);
glEnd();

bfill(x+1,y,fc,bc);
bfill(x-1,y,fc,bc);
bfill(x,y+1,fc,bc);
bfill(x,y-1,fc,bc);
}
}

void Draw()
{
int p[4][2]={{50,50},{150,50},{150,150},{50,150}};    //matrix representing polygon

int i,n,x,y;
GLubyte bc[3],fc[3];

n=4;
x=50;
y=50;

fc[0]=0;
fc[1]=0;
fc[2]=255;

glClear(GL_COLOR_BUFFER_BIT);

for(i=0;i<n-1;i++)
line(p[i][0],p[i][1],p[i+1][0],p[i+1][1]);

line(p[i][0],p[i][1],p[0][0],p[0][1]);

glReadPixels(x,y,1,1,GL_RGB,GL_UNSIGNED_BYTE,(void *)bc);

x=100;
y=100;
bfill(x,y,fc,bc);
}

void change(GLsizei w,GLsizei h)
{
glViewport(0.0,0.0,w,h);
glLoadIdentity();
glOrtho(0.0,640.0,0.0,480.0,0.0,1.0);
}

int main(int argc,char *argv)
{
glutInit(&argc,&argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(640,480);
glutInitWindowPosition(100,150);
glutCreateWindow(“Boundary Fill”);
glutDisplayFunc(Draw);
glutReshapeFunc(change);
glutMainLoop();
return 0;
}

Flood Filling

#include<stdio.h>
#include<math.h>
#include<GL/glut.h>

//Function to draw line from (x1,y1) to (x2,y2)
void line(float x1,float y1,float x2,float y2)
{
int i,s1,s2,d,dx,dy,t,j;

if((x2-x1)>0)
s1=1;
else
s1=-1;

if((y2-y1)>0)
s2=1;
else
s2=-1;

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

if(dy>dx)
{
t=dx;
dx=dy;
dy=t;
i=1;
}
else
i=0;

d = 2 + dy – dx;

j=0;
glBegin(GL_POINTS);
while(j<=dx)
{
glVertex2f(x1,y1);

while(d>=0)
{
if(i==1)
x1=x1+s1;
else
y1=y1+s1;

d = d – 2 * dx;
}
if(i==1)

y1 = y1 + s2;
else
x1 = x1 + s1;
d = d + 2 * dy;
j++;
}
glEnd();
}

//Function to draw polygon
void drawp(int p[][2],int n)
{
int i;

for(i=0;i<n-1;i++)
line(p[i][0],p[i][1],p[i+1][0],p[i+1][1]);
line(p[i][0],p[i][1],p[0][0],p[0][1]);
}

void flood(int x,int y,GLubyte old[])
{
GLubyte pixel[3];

glReadPixels(x,y,1,1,GL_RGB,GL_UNSIGNED_BYTE,(void *)pixel);

if(old[0]==pixel[0] && old[1]==pixel[1] && old[2]==pixel[2])
{
glColor3f(255,0,0);
glBegin(GL_POINTS);
glVertex2f(x,y);
glEnd();

flood(x+1,y,pixel);
flood(x-1,y,pixel);
flood(x,y+1,pixel);
flood(x,y-1,pixel);
}
}

void Draw()
{
int poly[4][2]={{50,50},{150,50},{150,150},{50,150}};    //matrix representing polygon

int i,n,x,y;
GLubyte pixel[3];

n=4;
x=100;
y=100;

glClear(GL_COLOR_BUFFER_BIT);

drawp(poly,n);

glReadPixels(x,y,1,1,GL_RGB,GL_UNSIGNED_BYTE,(void *)pixel);
flood(x,y,pixel);
}

void change(GLsizei w,GLsizei h)
{
glViewport(0.0,0.0,w,h);
glLoadIdentity();
glOrtho(0.0,640.0,0.0,480.0,0.0,1.0);
}

int main(int argc,char *argv)
{
glutInit(&argc,&argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(640,480);
glutInitWindowPosition(100,150);
glutCreateWindow(“Flood Fill”);
glutDisplayFunc(Draw);
glutReshapeFunc(change);
glutMainLoop();
return 0;
}

Polygon Clipping

#include<stdio.h>
#include<GL/glut.h>
#include<math.h>

void clip(int,int,int,int);
void reshape(GLsizei,GLsizei);
void polygon();
int calcode(int,int,int,int,int,int);
int top=0×1,bottom=0×2,right=0×4,left=0×8;
int x[4][2]={{40,30},{60,170},{100,170},{140,50}};

int main(int argc,char*argv)
{
int *argcp = &argc;
char **argvp = &argv;

glutInit(argcp, argvp);
glutInitWindowSize(640.0,480.0);
glutCreateWindow(“PolyClip”);
glColor3f(1.0,1.0,1.0);
glutDisplayFunc(polygon);
glutReshapeFunc(reshape);
glutMainLoop();

return 0;
}
void reshape(GLsizei w,GLsizei h)
{
glViewport(0.0,0.0,w,h);
glLoadIdentity();
gluOrtho2D(0.0,640.0,0.0,480.0);
}

void polygon()
{
int j;
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_LINE_LOOP);
glVertex2f(x[0][0],x[0][1]);
glVertex2f(x[1][0],x[1][1]);
glVertex2f(x[2][0],x[2][1]);
glVertex2f(x[3][0],x[3][1]);
glEnd();

//For window
int xwmin=80,ywmin=80,xwmax=200,ywmax=200;
glColor3f(0.0,1.0,1.0);

glBegin(GL_LINE_LOOP);
glVertex2f(xwmin,ywmin);
glVertex2f(xwmax,ywmin);
glVertex2f(xwmax,ywmax);
glVertex2f(xwmin,ywmax);
glEnd();

clip(xwmin,ywmin,xwmax,ywmax);

}

void clip(int xwmin,int ywmin,int xwmax,int ywmax)
{
int a[8][2],code[4];
int i=0,j=0,p=0;
float m,c;
for(i=0;i<4;i++)
{
a[i][0]=x[i][0];
a[i][1]=x[i][1];
code[i]=calcode(x[i][0],x[i][1],xwmin,ywmin,xwmax,ywmax);
}

for(j=0;j<4;j++)
{
m=((x[j+1][1]-x[j][1])/(x[j+1][0]-x[j][0]));
if((code[j]&&code[j+1])==0)
{
if((code[j]==left)||(code[j]==right))
{
if(code[j]==left)
{a[p][0]=xwmin;

}
else if(code[j]==right)
{a[p][0]=xwmax;
}

if(x[j][1]==x[j+1][1])
{a[p][1]=x[j][1];
}
else
{a[p][1]=(m*a[p][0])+(x[j+1][1]-m*x[j+1][0]);
}

p++;
}

if((code[j]==top)||(code[j]==bottom))
{
if(code[j]==top)
{a[p][1]=ywmax;
}
else if(code[j]==bottom)
{a[p][1]=ywmin;
}

if(x[j][0]==x[j+1][0])
{a[p][0]=x[j][0];
}
else
{a[p][0]=(a[p][1]-(x[j+1][1]-m*x[j+1][0]))/m;
}

p++;
}

if(code[j]==0)
{
a[p][0]=x[j][0];
a[p][1]=x[j][1];
p++;
}
//brute force

if((code[j+1]==left)||(code[j+1]==right))
{
if(code[j+1]==left)
{a[p][0]=xwmin;

}
else if(code[j+1]==right)
{a[p][0]=xwmax;
}

if(x[j][1]==x[j+1][1])
{a[p][1]=x[j+1][1];
}
else
{a[p][1]=(m*a[p][0])+(x[j+1][1]-m*x[j+1][0]);
}

p++;
}
if((code[j+1]==top)||(code[j+1]==bottom))
{
if(code[j+1]==top)
{a[p][1]=ywmax;
}
else if(code[j+1]==bottom)
{a[p][1]=ywmin;
}

if(x[j][0]==x[j+1][0])
{a[p][0]=x[j+1][0];
}
else
{a[p][0]=(a[p][1]-(x[j+1][1]-m*x[j+1][0]))/m;
}

p++;
}

if(code[j+1]==0)
{
a[p][0]=x[j+1][0];
a[p][1]=x[j+1][1];
p++;
}

}
}
glColor3f(1.0,0.0,0.0);
glBegin(GL_LINES);
for(j=0;j<p;j++)
glVertex2f(a[j][0],a[j][1]);
glEnd();
}

int calcode(int x,int y,int xwmin,int ywmin,int xwmax,int ywmax)
{
int code=0;
if(y>ywmax)
{
code|=top;
}
if(y<ywmin)
{
code|=bottom;
}
if(x>xwmax)
{
code|=right;
}
if(x<xwmin)
{
code|=left;
}
return(code);
}

Line Clipping-v2

#include<stdio.h>
#include<GL/glut.h>
#include<math.h>

void clip(void);

void reshape();

int calcode(float,float,float,float,float,float);

enum
{
top=0×1,bottom=0×2,right=0×4,left=0×8
};
int main(int argc,char*argv)
{
int *argcp = &argc;
char **argvp = &argv;

glutInit(argcp, argvp);
glutInitWindowSize(640.0,480.0);
glutCreateWindow(“Line”);
glColor3f(1.0,1.0,1.0);
glutDisplayFunc(clip);
glutReshapeFunc(reshape);
glutMainLoop();

return 0;
}
void reshape(GLsizei w,GLsizei h)
{
glViewport(0.0,0.0,w,h);
glLoadIdentity();
gluOrtho2D(0.0,640.0,0.0,480.0);
}
int calcode(float x,float y,float xwmin,float ywmin,float xwmax,float ywmax)
{
int code=0;
if(y>ywmax)
{
code|=top;
}
if(y<ywmin)
{
code|=bottom;
}
if(x>xwmax)
{
code|=right;
}
if(x<xwmin)
{
code|=left;
}
return(code);
}

void clip()
{
float xwmin=50,ywmin=50,xwmax=250,ywmax=250,x0=10,y0=40,x1=350,y1=400,x,y;
unsigned int code0,code1,codeout;
int accept=0,done=0;
code0=calcode(x0,y0,xwmin,ywmin,xwmax,ywmax);
code1=calcode(x1,y1,xwmin,ywmin,xwmax,ywmax);

glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_LINES);
glVertex2f(x0,y0);
glVertex2f(x1,y1);

do
{
if(!(code0|code1))
{
accept=1;done=1;
}
else
if(code0 & code1)
{
done=1;
}
else
{
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)
{
glColor3f(1.0,0.0,0.0);

glBegin(GL_LINES);
glVertex2f(x0,y0);
glVertex2f(x1,y1);
glEnd();
glBegin(GL_LINE_LOOP);
glVertex2f(xwmin,ywmin);
glVertex2f(xwmax,ywmin);
glVertex2f(xwmax,ywmax);
glVertex2f(xwmin,ywmax);
glEnd();
}
}

Line Clipping

#include<stdio.h>
#include<GL/glut.h>
#include<math.h>

void plot(void);
void change();
int calc(float,float,float,float,float,float);
enum{top=0×1,bottom=0×2,right=0×4,left=0×8};
int main(int argc,char*argv)
{
int *argcp = &argc;
char **argvp = &argv;

glutIniti(argcp, argvp);
glutInitWindowSize(640.0,480.0);
glutCreateWindow(“Line”);
glColor3f(1.0,1.0,1.0);

glutDisplayFunc(plot);
glutReshapeFunc(change);
glutMainLoop();

return 0;
}
void change(GLsizei w,GLsizei h)
{
glViewport(0.0,0.0,w,h);
glLoadIdentity();
gluOrtho2D(0.0,640.0,0.0,480.0);
}
int calc(float x,float y,float xmin,float ymin,float xmax,float ymax)

{
int code=0;
if(y>ymax)
code= code | top;
if(y<ymin)
code= code | bottom;
if(x>xmax)
code=code | right;
if(x<xmin)
code=code | left;
return(code);
}
void plot()
{
float xmin=50,ymin=50,xmax=150,ymax=150,x0=30,y0=30,x1=300,y1=300,x,y;
unsigned int code1,code2,code;
int accept=0,done=0;
code1=calc(x0,y0,xmin,ymin,xmax,ymax);
code2=calc(x1,y1,xmin,ymin,xmax,ymax);
do
{
if(!(code1|code2))
{
accept=1;done=1;
}
else
if(code1 & code2)
{
done=1;
}
else
{
code=code1?code1:code2;
if(code & top)
{
x=x0+(x1-x0)*(ymax-y0)/(y1-y0);
y=ymax;
}
else if(code & bottom)
{
x=x0+(x1-x0)*(ymin-y0)/(y1-y0);
y=ymin;
}
else if(code & right)
{
y=y0+(y1-y0)*(xmax-x0)/(x1-x0);
x=xmax;
}
else
{
y=y0+(y1-y0)*(xmin-x0)/(x1-x0);
x=xmin;
}
if(code==code1)
{
x0=x;y0=y;
code1=calc(x0,y0,xmin,ymin,xmax,ymax);
}
else
{
x1=x;y1=y;
code2=calc(x1,y1,xmin,ymin,xmax,ymax);
}
}
}while(done==0);
glClear(GL_COLOR_BUFFER_BIT);
if(accept)
{
glBegin(GL_LINES);
glVertex2f(x0,y0);
glVertex2f(x1,y1);
glEnd();
glBegin(GL_LINE_LOOP);
glVertex2f(xmin,ymin);
glVertex2f(xmax,ymin);
glVertex2f(xmax,ymax);
glVertex2f(xmin,ymax);
glEnd();
}
}

Ellipse

#include<stdio.h>
#include<GL/glut.h>

void changesize(GLsizei w,GLsizei h)
{
glViewport(0.0,0.0,w,h);
glLoadIdentity();
gluOrtho2D(0.0,640.0,0.0,480.0);
}

void draw(void)
{
int a=100,b=50,xc=200,yc=200,p1,p2,x,y;
y=b,x=0;
p1 = b*b – a*a*b + (a*a/4);
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_POINTS);
glVertex2f(0,y);
glVertex2f(0,-y);

while((x*b*b) < (y*a*a))
{
glVertex2f(xc+x,yc+y);
glVertex2f(xc+x,yc-y);
glVertex2f(xc-x,yc+y);
glVertex2f(xc-x,yc-y);

x=x+1;

if(p1<0)
p1 = p1 + 2*b*b*x + b*b;

else
{
y=y-1;
p1 = p1 + 2*b*b*x – 2*a*a*y + b*b;
}
}

p2 = a*a – b*b*a + (b*b/4);
y=0;
x=a;
glVertex2f(x,0);
glVertex2f(-x,0);

while((x*b*b) > (y*a*a))
{
glVertex2f(xc+x,yc+y);
glVertex2f(xc+x,yc-y);
glVertex2f(xc-x,yc+y);
glVertex2f(xc-x,yc-y);

y=y+1;

if(p2<0)
p2 = p2 + 2*a*a*y + a*a;

else
{
x=x-1;
p2 = p2 + 2*a*a*y – 2*b*b*x + a*a;
}
}

glEnd();
}

int main(int argc,char *argv)
{
int *argcp=&argc;
char **argvp=&argv;
glutInit(argcp,argvp);
glutCreateWindow(“ELLIPSE”);
glutDisplayFunc(draw);
glutReshapeFunc(changesize);
glutMainLoop();
return 0;
}

Mid Point Circle

#include<stdio.h>
#include<math.h>
#include<GL/glut.h>

int main(int argC, char *argV)
{
int *argCp=&argC;
char **argVp=&argV;

void draw();
void ChangeSize(GLsizei, GLsizei);

glutInit(argCp, argVp);
glutCreateWindow(“Mid Point Circle”);
glutReshapeFunc(ChangeSize);
glutDisplayFunc(draw);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(640.0, 480.0);
glutInitWindowPosition(100,150);
glutMainLoop();
return 0;
}
void draw()
{
int xc=300,xo,yc=300,yo,xk,yk,r=100,k;
float Po,Pk;
//printf(“Enter center of circle Xc,Yc and radius r”);
//scanf(“%d,%d,%f”,xc,yc,r);
glClear(GL_COLOR_BUFFER_BIT);
Po=Pk=(5/4.0)-r;
xo=xk=0;
yo=yk=r;

for(k=0; xo<=yo; k++)
{
glBegin(GL_POINTS);
glVertex2f(xc+xo,yc+yo);
glVertex2f(xc+xo,yc-yo);
glVertex2f(xc-xo,yc+yo);
glVertex2f(xc-xo,yc-yo);
glVertex2f(xc+yo,yc+xo);
glVertex2f(xc+yo,yc-xo);
glVertex2f(xc-yo,yc+xo);
glVertex2f(xc-yo,yc-xo);
glEnd();

xo=xk;
xk=xo+1;
yo=yk;
yk=yo-1;
Po=Pk;
if(Po<0)
{
Pk=Po + (2*xk)+1;
xo=xk;
yk=yo;
}
else
{
Pk= Po+(2*xk)+1-(2*yk);
xo=xk;
yo=yk+2;
}
}
}

void ChangeSize(GLsizei w, GLsizei h)
{
glViewport(0.0,0.0,w,h);
glLoadIdentity();
gluOrtho2D(0.0,640.0,0.0,480.0);
}

Bresenham

#include<stdio.h>

#include<GL/glut.h>
#include<math.h>

void changeSize(GLsizei w,GLsizei h)
{    glViewport(0.0,0.0,300,400);
glLoadIdentity();
gluOrtho2D(0.0,640.0,0.0,480.0);
}

void Draw(void)
{    int x1=200;
int y1=300;

int x2=400;
int y2=500;
int i,s1,s2,d,dx,dy,t;
if((x2-x1)>0)
s1=1;
else
s1=-1;

if((y2-y1)>0)
s2=1;
else
s2=-1;

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

if(dy>dx)
{
t=dx;
dx=dy;
dy=t;
i=1;
}
else
i=0;

d=2*dy-dx;
int j=0;

while(j<=dx)
{
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_POINTS);
glVertex2f(x1,y1);
while(d>=0)
{
if(i==1)
x1=x1+s1;
else
y1=y1+s2;

d=d-2*dx;}
if(i==1)
y1=y1+s2;
else
x1=x1+s1;

d=d+2*dy;
j++;
printf(“points:%d%d”,x1,y1);

}

glEnd();
glFlush();
}

int main(int argc, char *argv)
{
int *argcp=&argc;
char **argvp=&argv;
glutInit(&argc,&argv);
glutCreateWindow(“Bresenhams line”);
glutDisplayFunc(Draw);
glutReshapeFunc(changeSize);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(640.0,480.0);
glutInitWindowPosition(100,150);
glutMainLoop();
return 0;
}