Scribd
Upload
2K views35 pages

MCSL-54 (53) Computer Graphics - Solved Lab Manual

The document contains code for several OpenGL graphics exercises: 1. The first exercise draws a yellow rectangle on a black background using functions for window initialization, display, and the main loop. 2. Subsequent exercises draw additional primitives like lines, triangles, and circles using functions like glBegin and glVertex, and implement algorithms like DDA line generation and Bresenham's circle algorithm. 3. Later exercises draw more complex shapes like a convex polygon and add features like line stippling. 4. The final exercises focus on 2D graphics and drawing using different primitives, colors, and coordinate points. The code demonstrates basic OpenGL programming.

Uploaded by

sharanya_12
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOC, PDF, TXT or read online on Scribd
2K views35 pages

MCSL-54 (53) Computer Graphics - Solved Lab Manual

The document contains code for several OpenGL graphics exercises: 1. The first exercise draws a yellow rectangle on a black background using functions for window initialization, display, and the main loop. 2. Subsequent exercises draw additional primitives like lines, triangles, and circles using functions like glBegin and glVertex, and implement algorithms like DDA line generation and Bresenham's circle algorithm. 3. Later exercises draw more complex shapes like a convex polygon and add features like line stippling. 4. The final exercises focus on 2D graphics and drawing using different primitives, colors, and coordinate points. The code demonstrates basic OpenGL programming.

Uploaded by

sharanya_12
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOC, PDF, TXT or read online on Scribd

----Session 2---Exercise 4: #include<windows.h> #include<gl/gl.h> #include<gl/glu.h> #include<gl/glut.h> void init() { glClearColor(0.0,0.0,0.0,0.0); // background Color glColor3f(1.0,1.0,0.

0);//Drawing Color glPointSize(4); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0,800,0.0,600.0); } void display() { glClear(GL_COLOR_BUFFER_BIT); glBegin(GL_POLYGON); glVertex2i(100,100); glVertex2i(100,500); glVertex2i(700,500); glVertex2i(700,100); glEnd(); glFlush(); } void main(int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); glutInitWindowSize(800,600); glutCreateWindow("Session2, Exer4(Niraj)"); glutDisplayFunc(display); init(); glutMainLoop(); }

Output:

Exercise 5: /* * Problem definition: Yello rectange on black background * By: Prasun Pal(prsn) * Date: 21/04/2009 */ #include<windows.h> #include<gl/gl.h> #include<gl/glu.h> #include<gl/glut.h> void init() { glClearColor(0.0,0.0,0.0,0.0); // background Color glColor3f(1.0,0.0,0.0);//Drawing Color glPointSize(4); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0,800,0.0,600.0); } void display() { glClear(GL_COLOR_BUFFER_BIT); glBegin(GL_POLYGON);

glVertex2i(100,100); glVertex2i(100,500); glVertex2i(700,500); glVertex2i(700,100); glEnd(); glFlush(); } void main(int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); glutInitWindowSize(800,600); glutCreateWindow("Session2, Exer4(Niraj)"); glutDisplayFunc(display); init(); glutMainLoop(); } Output:

Exercise 6: /* * Problem definition: just to draw basic primitives of OpenGl * such as GL_INES, GL_QUAD, GL_TRIANGLES etc. * By: Prasun Pal(prsn)

* Date: 21/04/2009 */ #include<windows.h> #include<gl/gl.h> #include<gl/glu.h> #include<gl/glut.h> void init() { glClearColor(1.0,1.0,1.0,0.0); //background Color glColor3f(0.0,0.0,0.0);//Drawing Color glPointSize(4); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0,800,0.0,600.0); } void display() { glClear(GL_COLOR_BUFFER_BIT); glBegin(GL_LINES); glVertex2i(500,500); glVertex2i(550,400); glEnd(); glBegin(GL_QUADS); glVertex2i(125,350); glVertex2i(362,254); glVertex2i(154,352); glVertex2i(346,254); glVertex2i(258,45); glVertex2i(454,253); glVertex2i(259,475); glVertex2i(12,389); glEnd(); glBegin(GL_TRIANGLES); glVertex2i(600,200);

glVertex2i(650,300); glVertex2i(700,200); glEnd(); glFlush(); } void main(int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); glutInitWindowSize(800,600); glutCreateWindow("Session2, Exer4(prsn)"); glutDisplayFunc(display); init(); glutMainLoop(); } Output:

----Session 3---Exercise 7:

/* * Problem definition:To impement DDA Line-generation algorithm * By: Prasun Pal(prsn) * Date: 21/04/2009 */ #include<windows.h> #include<gl/gl.h> #include<gl/glu.h> #include<gl/glut.h> #include<math.h> void nkjSwap(float *,float *); void nkjInit() { glClearColor(1.0,1.0,1.0,0.0); //Black background Color glColor3f(0.0,0.0,0.0);//Drawing Color yellow glPointSize(2); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0,800,0.0,600.0); } void nkjDDA4f(float x1, float y1, float x2, float y2) { if(x1>x2) { nkjSwap(&x1,&x2); nkjSwap(&y1,&y2); } float slope=(y2-y1)/(float)(x2-x1); if(slope>0 && slope<1) { while(x1<=x2) { glVertex2i((int)x1,int(y1)); x1++;

y1+=slope; } } else if(slope>=1) { float slope1=1/slope; while(y1<=y2) { glVertex2i(int(x1),int(y1)); y1++; x1+=slope1; } } } void nkjSwap(float *x, float *y) { float temp=*x; *x=*y; *y=temp; } void nkjDisplay() { glClear(GL_COLOR_BUFFER_BIT); glBegin(GL_POINTS); nkjDDA4f(100.0,100.0,350.0,350.0);//two points p1(100,100), p2(350,350) glEnd(); glFlush(); }

void main(int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);

glutInitWindowSize(800,600); glutCreateWindow("Session2, Exer4(Niraj)"); glutDisplayFunc(nkjDisplay); nkjInit(); glutMainLoop(); } Output:

Exercise 8: /* * Problem definition:To impement Bresenham Circle-generation algorithm

* By: Prasun Pal(prsn) * Date: 21/04/2009 */ #include<windows.h> #include<gl/gl.h> #include<gl/glu.h> #include<gl/glut.h> #include<math.h> #include<stdio.h> void nkjSwap(float *,float *); void nkjInit() { glClearColor(1.0,1.0,1.0,0.0); //Black background Color glColor3f(0.0,0.0,0.0);//Drawing Color yellow glPointSize(2); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0,800,0.0,600.0); } void nkjBresenhamCircleGeneration3f(float x1, float y1, float radious) { float dcsnPrmtr=5/4-radious;//decision Parameter int k=0; float x=x1, y=y1; x1=0; y1=radious; while(x1<y1) { if(dcsnPrmtr<0) { dcsnPrmtr += 2 * x1 + 2 + 1; x1++; }

else //if(dcsnPrmtr { dcsnPrmtr += 2 * x1 + 2 - 2 * y1 - 2 + 1; x1++; y1--; } //generate symmetry points glVertex2i((int)(x+x1),(int)(y+y1)); glVertex2i((int)(x-x1),(int)(y+y1)); glVertex2i((int)(x+x1),(int)(y-y1)); glVertex2i((int)(x-x1),(int)(y-y1)); glVertex2i((int)(x+y1),(int)(y+x1)); glVertex2i((int)(x-y1),(int)(y+x1)); glVertex2i((int)(x+y1),(int)(y-x1)); glVertex2i((int)(x-y1),(int)(y-x1)); } } void nkjDisplay() { glClear(GL_COLOR_BUFFER_BIT); glBegin(GL_POINTS); nkjBresenhamCircleGeneration3f(400.0,300.0,150.0); glEnd(); glFlush(); } void main(int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); glutInitWindowSize(800,600); glutCreateWindow("Session2, Exer4(nkj)"); glutDisplayFunc(nkjDisplay); nkjInit(); glutMainLoop(); }

Output:

Exercise 9: /* * Problem definition:To draw a convex hall polygon * By: Prasun Pal(prsn) * Date: 21/04/2009 */ #include<windows.h> #include<gl/gl.h> #include<gl/glu.h> #include<gl/glut.h> #include<math.h> #include<stdio.h>

void prsnInit() { glClearColor(1.0,1.0,1.0,0.0); //Black background Color

glColor3f(0.0,0.0,0.0);//Drawing Color yellow glPointSize(4); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0,800,0.0,600.0); } void prsnConvexHallPolygon() { glVertex2i(200,200); glVertex2i(150,250); glVertex2i(150,250); glVertex2i(150,300); glVertex2i(150,300); glVertex2i(200,350); glVertex2i(200,350); glVertex2i(250,300); glVertex2i(250,300); glVertex2i(250,250); glVertex2i(250,250); glVertex2i(200,200); }

void prsnDisplay() { glClear(GL_COLOR_BUFFER_BIT); glBegin(GL_LINES); prsnConvexHallPolygon(); glEnd(); glFlush(); }

void main(int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); glutInitWindowSize(800,600); glutCreateWindow("Session2, Exer4(prsn)"); glutDisplayFunc(prsnDisplay); prsnInit(); glutMainLoop(); }

Output:

----Session 4---Exercise 10: #include<windows.h> #include<gl/gl.h> #include<gl/glu.h> #include<gl/glut.h> #include<iostream.h> void display(); void myInit(); void main(int i,char **ptr) { glutInit(&i, ptr); glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); glutInitWindowSize(800,600); glutInitWindowPosition(100,100); glutCreateWindow("OpenGL Window"); glutDisplayFunc(display); myInit(); glutMainLoop(); } void myInit() { glClearColor(1.0,1.0,1.0,0.0); glColor3f(0.0f,0.0f,0.0f); glPointSize(4.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0,800.0,0.0,800.0); } void display()

{ glClear(GL_COLOR_BUFFER_BIT); glBegin(GL_LINES); glVertex2i(200,200); glVertex2i(500,200); glVertex2i(200,400); glVertex2i(500,400); glVertex2i(300,100); glVertex2i(300,500); glVertex2i(400,500); glVertex2i(400,100); glEnd(); glFlush(); } Output:

Exercise 11: #include<windows.h> #include<gl/gl.h>

#include<gl/glu.h> #include<gl/glut.h> #include<iostream.h> void display(); void myInit(); void main(int i,char **ptr) { glutInit(&i, ptr); glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); glutInitWindowSize(800,600); glutInitWindowPosition(100,100); glutCreateWindow("OpenGL Window"); glutDisplayFunc(display); myInit(); glutMainLoop(); } void myInit() { glClearColor(1.0,1.0,1.0,0.0); glColor3f(0.0f,0.0f,0.0f); glPointSize(4.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0,800.0,0.0,800.0); } void display() { glClear(GL_COLOR_BUFFER_BIT); glLineWidth(4.0); glBegin(GL_LINES); glVertex2i(100,200); glVertex2i(400,200); glVertex2i(100,400); glVertex2i(400,400); glVertex2i(200,100); glVertex2i(200,500);

glVertex2i(300,500); glVertex2i(300,100); glEnd(); glEnable(GL_LINE_STIPPLE); glLineStipple(1,0xAAAA); glBegin(GL_LINES); glVertex2i(450,200); glVertex2i(750,200); glVertex2i(450,400); glVertex2i(750,400); glVertex2i(550,100); glVertex2i(550,500); glVertex2i(650,500); glVertex2i(650,100); glEnd(); glDisable(GL_LINE_STIPPLE); glFlush(); }

Output:

Exercise 12: #include<windows.h> #include<gl/gl.h> #include<gl/glu.h> #include<gl/glut.h> void display(); void main(int argc, char *argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); glutInitWindowPosition(50,50); glutCreateWindow("EX-12 GRAPHICS"); glutDisplayFunc(display); //init glClearColor(1.0,1.0,1.0,0.0); glColor3f(1.0,1.0,0.0); glPointSize(4);

glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0,800.0,0.0,600.0); glutMainLoop(); } void display() { glClear(GL_COLOR_BUFFER_BIT); glColor3f(0.0,1.0,1.0); glBegin(GL_LINES); glVertex2i(140,310); glVertex2i(40,210); glVertex2i(140,310); glVertex2i(240,210); glVertex2i(40,210); glVertex2i(40,10); glVertex2i(240,210); glVertex2i(240,10); glVertex2i(40,180); glVertex2i(240,180); glVertex2i(240,210); glVertex2i(240,310); glVertex2i(240,310); glVertex2i(220,310); glVertex2i(220,310); glVertex2i(220,230); glVertex2i(120,180); glVertex2i(120,10); glVertex2i(120,10); glVertex2i(160,10); glVertex2i(160,10); glVertex2i(160,180); glVertex2i(40,10); glVertex2i(240,10); glEnd();

glBegin(GL_QUADS);

glVertex2i(50,205); glVertex2i(50,180); glVertex2i(75,180); glVertex2i(75,205); glVertex2i(205,205); glVertex2i(205,180); glVertex2i(230,180); glVertex2i(230,205); glEnd(); glFlush(); }

Output:

----Session 5---Exercise 13: #include<windows.h> #include<gl/gl.h> #include<gl/glu.h> #include<gl/glut.h> #include<iostream.h> void display(); void myInit(); void main(int i,char **ptr) { glutInit(&i, ptr); glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); glutInitWindowSize(400,400); glutInitWindowPosition(100,100); glutCreateWindow("OpenGL Window");

glutDisplayFunc(display); myInit(); glutMainLoop(); } void myInit() { glClearColor(1.0,1.0,1.0,0.0); glColor3f(0.0f,0.0f,0.0f); glPointSize(4.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0,800.0,0.0,800.0); } void display() { glClear(GL_COLOR_BUFFER_BIT); int i=0,j=0; int scale=100; for(i=0;i<8;i++) { for(j=0;j<8;j++) { if((i+j)%2==0) { glColor3f(0.0,0.0,0.0); } else { glColor3f(1.0,1.0,1.0); } glBegin(GL_POLYGON); glVertex2i(j*scale,i*scale); glVertex2i(j*scale,i*scale+scale); glVertex2i(j*scale+scale,i*scale+scale); glVertex2i(j*scale+scale,i*scale); glEnd(); } }

glFlush(); }

Output:

Exercise 15: #include<windows.h> #include<gl/gl.h> #include<gl/glu.h> #include<gl/glut.h> #include<stdio.h> #include<math.h> #include<stdarg.h> //function that implements Sutherand-Cohen algorithm void nkjImpementsSutherlandCohen(int [], int , ... ); //function to deside visibiity of any line int nkjDecideVisibility(int [],int *,int *,int *,int *); //function to generate bit code of points int nkjGenerateCode(int,int, int, int, int ,int); //to perform swapping void nkjSwap(int * , int *); void nkjInit()

{ glClearColor(1.0,1.0,1.0,0.0); glColor3f(0.0f,0.0f,0.0f); glPointSize(4); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0,200.0,0.0,200.0); } void nkjDisplayLines() { int points[]={110,110,10,10};// points for window position int xMax,yMax,xMin,yMin; xMax=yMax=110; xMin=yMin=10; glClear(GL_COLOR_BUFFER_BIT); //Drawing Window glBegin(GL_LINES); glVertex2i(xMin,yMin); glVertex2i(xMin,yMax); glVertex2i(xMin,yMax); glVertex2i(xMax,yMax); glVertex2i(xMax,yMax); glVertex2i(xMax,yMin); glVertex2i(xMax,yMin); glVertex2i(xMin,yMin);

nkjImpementsSutherlandCohen(points,12,25,75,90,100,125,35,110,120,50, 50,120,120); glEnd(); glFlush(); }

void nkjImpementsSutherlandCohen(int polygonPoints[], int vertexPoints, ... ) { int x1, y1, x2,y2; int ind, total, decision; va_list ptr; va_start(ptr, vertexPoints); if(vertexPoints%4!=0) { printf("nkjError Message! Wrong number of arguments given........\n"); return; } total=vertexPoints/4; glClear(GL_COLOR_BUFFER_BIT); for(ind=0;ind<total;ind++) { x1=va_arg(ptr,int); y1=va_arg(ptr,int); x2=va_arg(ptr,int); y2=va_arg(ptr,int); decision= nkjDecideVisibility(polygonPoints,&x1,&y1,&x2,&y2); if(decision!=-1) { //this implies ine must be drawn and points are stored //in the corresponding variables glVertex2i(x1,y1); glVertex2i(x2,y2); } } } int nkjDecideVisibility(int points[], int *x1,int *y1, int *x2, int *y2) { int xMax,yMax,xMin,yMin;

int code1,code2; xMax=points[0]; yMax=points[1]; xMin=points[2]; yMin=points[3]; for(;;) { code1=nkjGenerateCode(xMax,yMax,xMin,yMin,*x1,*y1); code2=nkjGenerateCode(xMax,yMax,xMin,yMin,*x2,*y2); if(code1==0 && code2==0) { //this indicates line is totaly visible return 1; } else if((code1 & code2)!=0) { //this implies line is totaly invisible return -1; } else { if(*x1>xMax) { //finding intersection of line[(x1,y1),(x2,y2)] and xMax *y1=(((*y2-*y1)/(*x2-*x1))*(xMax-*x1)) + *y1; *x1=xMax; } else if(*x1<xMin) { //finding intersection of line[(x1,y1),(x2,y2)] and xMin *y1=(((*y2-*y1)/(*x2-*x1))*(xMin-*x1)) + *y1; *x1=xMin; } if(*y1>yMax) {

//finding intersection of line[(x1,y1),(x2,y2)] and yMax *x1=((yMax-*y1)*((*x2-*x1)/(*y2-*y1))) + *x1; *y1=yMax; } else if(*y1<yMin) { //finding intersection of line[(x1,y1),(x2,y2)] and yMin *x1=((yMin-*y1)*((*x2-*x1)/(*y2-*y1))) + *x1; *y1=yMin; } } //generating new code for the clipped points code1=nkjGenerateCode(xMax,yMax,xMin,yMin,*x1,*y1); if(code1==0) { //interchange two points and respective flags nkjSwap(x1,x2); nkjSwap(y1,y2); nkjSwap(&code1,&code2); } } return -1; //this will never execute, just to satisfy compiler } int nkjGenerateCode(int xMax, int yMax, int xMin, int yMin, int x, int y) { int code=0; //code sequence UDLR if(x>xMax) code|=1;//0001 Right bit else if(x<xMin) code|=2;//0010 Left bit if(y>yMax) code|=8;//1000 Up/Top bit

else if(y<yMin) code|=4;//0100 Down/Bottom nit return code; } void nkjSwap(int *x, int *y) { *x=*x^*y; *y=*x^*y; *x=*x^*y; } void main(int argc, char **argv) { glutInit(&argc,argv); glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); glutInitWindowSize(400,400); glutInitWindowPosition(10,10); glutCreateWindow("Sutherland-Cohen by Prasun Pal"); glutDisplayFunc(nkjDisplayLines); nkjInit(); glutMainLoop(); } Output:

----Session 6---Exercise 16: #include<windows.h> #include<gl/gl.h> #include<gl/glu.h> #include<gl/glut.h> #include<stdio.h> #include<math.h> #include<stdarg.h> //function that implements Sutherand-Cohen algorithm void nkjImpementsSutherlandCohen(int [], int , ... ); //function to deside visibiity of any line int nkjDecideVisibility(int [],int *,int *,int *,int *); //function to generate bit code of points int nkjGenerateCode(int,int, int, int, int ,int); //to perform swapping void nkjSwap(int * , int *); void nkjInit() {

glClearColor(1.0,1.0,1.0,0.0); glColor3f(0.0f,0.0f,0.0f); glPointSize(4); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0,200.0,0.0,200.0); } void nkjDisplayLines() { int points[]={60,40,20,20};// points for window position xMax, yMax, // xMin, yMin int xMax,yMax,xMin,yMin; xMax=60; yMax=40; xMin=yMin=20; glClear(GL_COLOR_BUFFER_BIT); //Drawing Window glBegin(GL_LINES); glVertex2i(xMin,yMin); glVertex2i(xMin,yMax); glVertex2i(xMin,yMax); glVertex2i(xMax,yMax); glVertex2i(xMax,yMax); glVertex2i(xMax,yMin); glVertex2i(xMax,yMin); glVertex2i(xMin,yMin); //Total 4 points two for p and two for q nkjImpementsSutherlandCohen(points,4,40,80,120,30); glEnd(); glFlush(); }

void nkjImpementsSutherlandCohen(int polygonPoints[], int vertexPoints, ... ) { int x1, y1, x2,y2; int ind, total, decision; va_list ptr; va_start(ptr, vertexPoints); if(vertexPoints%4!=0) { printf("nkjError Message! Wrong number of arguments given......\n"); return; } total=vertexPoints/4; glClear(GL_COLOR_BUFFER_BIT); for(ind=0;ind<total;ind++) { x1=va_arg(ptr,int); y1=va_arg(ptr,int); x2=va_arg(ptr,int); y2=va_arg(ptr,int); decision= nkjDecideVisibility(polygonPoints,&x1,&y1,&x2,&y2); if(decision!=-1) { //this implies ine must be drawn and points are stored //in the corresponding variables glVertex2i(x1,y1); glVertex2i(x2,y2); } } } int nkjDecideVisibility(int points[], int *x1,int *y1, int *x2, int *y2) { int xMax,yMax,xMin,yMin; int code1,code2;

xMax=points[0]; yMax=points[1]; xMin=points[2]; yMin=points[3]; for(;;) { code1=nkjGenerateCode(xMax,yMax,xMin,yMin,*x1,*y1); code2=nkjGenerateCode(xMax,yMax,xMin,yMin,*x2,*y2); if(code1==0 && code2==0) { //this indicates line is totaly visible return 1; } else if((code1 & code2)!=0) { //this implies line is totaly invisible return -1; } else { if(*x1>xMax) { //finding intersection of line[(x1,y1),(x2,y2)] and xMax *y1=(((*y2-*y1)/(*x2-*x1))*(xMax-*x1)) + *y1; *x1=xMax; } else if(*x1<xMin) { //finding intersection of line[(x1,y1),(x2,y2)] and xMin *y1=(((*y2-*y1)/(*x2-*x1))*(xMin-*x1)) + *y1; *x1=xMin; } if(*y1>yMax) { //finding intersection of line[(x1,y1),(x2,y2)] and yMax

*x1=((yMax-*y1)*((*x2-*x1)/(*y2-*y1))) + *x1; *y1=yMax; } else if(*y1<yMin) { //finding intersection of line[(x1,y1),(x2,y2)] and yMin *x1=((yMin-*y1)*((*x2-*x1)/(*y2-*y1))) + *x1; *y1=yMin; } } //generating new code for the clipped points code1=nkjGenerateCode(xMax,yMax,xMin,yMin,*x1,*y1); if(code1==0) { //interchange two points and respective flags nkjSwap(x1,x2); nkjSwap(y1,y2); nkjSwap(&code1,&code2); } } return -1; //this will never execute, just to satisfy compiler } int nkjGenerateCode(int xMax, int yMax, int xMin, int yMin, int x, int y) { int code=0; //code sequence UDLR if(x>xMax) code|=1;//0001 Right bit else if(x<xMin) code|=2;//0010 Left bit if(y>yMax) code|=8;//1000 Up/Top bit else if(y<yMin)

code|=4;//0100 Down/Bottom nit return code; } void nkjSwap(int *x, int *y) { *x=*x^*y; *y=*x^*y; *x=*x^*y; } void main(int argc, char **argv) { glutInit(&argc,argv); glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); glutInitWindowSize(400,400); glutInitWindowPosition(10,10); glutCreateWindow("Sutherland-Cohen by Niraj Kumar Jha"); glutDisplayFunc(nkjDisplayLines); nkjInit(); glutMainLoop(); } Output:

Output for the given window size, where line is totally invisible.

You might also like