Activity programs of Computer Graphics and Visualization

1. Program to recursively subdivide a tetrahedron to form 3D Sierpinski gasket. The

number of recursive steps is to be specified by the user.

Objective:
In this program, students will learn to create window and to draw 3D Sierpinski
gasket using openGL functions.

Program:
#include <GL/glut.h>
#include <stdlib.h>
#include<stdio.h>
typedef float point[3];

point v[]={ {0.0,0.0,1.0},

{0.0,0.943,-0.33},
{-0.816,-0.471,-0.33},
{0.816,-0.471,0.33}};

int n;
void triangle(point a,point b,point c)
{
glBegin(GL_POLYGON);
glNormal3fv(a);
glVertex3fv(a);
glVertex3fv(b);
glVertex3fv(c);
glEnd();
}

void divide_tri(point a,point b,point c,int m)

{
point v1,v2,v3;
int j;
if (m>0)
{
for(j=0;j<3;j++)
v1[j]=(a[j]+b[j])/2;

for(j=0;j<3;j++)
v2[j]=(a[j]+c[j])/2;

for(j=0;j<3;j++)
v3[j]=(b[j]+c[j])/2;

divide_tri(a,v1,v2,m-1);

divide_tri(c,v2,v3,m-1);

Page 1
 divide_tri(b,v3,v1,m-1);
}
else
triangle(a,b,c);
}

void tetrahedron(int m)
{
glColor3f(1.0,0.0,0.0);
divide_tri(v[0],v[1],v[2],m);
glColor3f(0.0,1.0,0.0);
divide_tri(v[3],v[2],v[1],m);
glColor3f(0.0,0.0,1.0);
divide_tri(v[0],v[3],v[1],m);
glColor3f(0.0,0.0,0.0);
divide_tri(v[0],v[2],v[3],m);
}

void display(void)
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
tetrahedron(n);
glFlush();
}

void myReshape(int w,int h)

{
glViewport(0,0,w,h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if(w<=h)
glOrtho(-2.0,2.0,-2.0*(GLfloat)h/(GLfloat)w,2.0*(GLfloat)h/(GLfloat)w,-
10.0,10.0);
else

glOrtho(-2.0*(GLfloat)w/(GLfloat)h,2.0*(GLfloat)w/(GLfloat)h,-2.0,2.0,-10.0,10.0);
glMatrixMode(GL_MODELVIEW);
glutPostRedisplay();
}

int main(int argc,char **argv)

{
printf(“Enter the number of recursive steps you want\n”);
scanf(“%d”, &n);
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB|GLUT_DEPTH);

Page 2
 glutInitWindowSize(500,500);
glutCreateWindow("3d gasket");
glutReshapeFunc(myReshape);
glutDisplayFunc(display);
glEnable(GL_DEPTH_TEST);
glClearColor(1.0,1.0,1.0,1.0);
glutMainLoop();
}

Output:

2.program to draw a rocket and allow user to change the color .

Objective:
In this program, students will learn to create window and to draw a Rocket and change its
colour using openGL functions.

Program:
#include<GL/glut.h>
#include<stdio.h>
GLfloat r1=1.0, r2=0.5,r3=0.5;

Page 3
GLfloat b1=1.0, b2=1.0, b3=1.0;
GLfloat t1=1.0, t2=0.5, t3=0.0;
void change();
void display();
void top()
{
glBegin(GL_TRIANGLES);
glColor3f(r1,r2,r3);
glVertex2f(100.0,400.0);
glVertex2f(150.0,400.0);
glVertex2f(125.0,450.0);
glEnd();
glFlush();
}

void body()
{
glBegin(GL_QUADS);
glColor3f(b1,b2,b3);
glVertex2f(100.0,400.0);
glVertex2f(150.0,400.0);
glVertex2f(150.0,250.0);
glVertex2f(100.0,250.0);
glEnd();
glFlush();
}

void tail()
{
glBegin(GL_TRIANGLES);
glColor3f(t1,t2,t3);
glVertex2f(100.0,250.0);
glVertex2f(150.0,250.0);
glVertex2f(75.0,100.0);
glVertex2f(100.0,250.0);
glVertex2f(150.0,250.0);
glVertex2f(175.0,100.0);
glEnd();
glFlush();
}
void display()
{
char key;
glClear(GL_COLOR_BUFFER_BIT);

Page 4
top();
body();
tail();
printf("press C to change color and Q to quit");
scanf("%c",&key);
if(key=='c'||key=='C')
change();
if(key=='q'||key=='Q')
exit(0);
}

void change()
{
int x;
do
{
printf("1.top\n 2.body\n 3.tail\n 4.quit\n enter your choice\n");
scanf("%d",&x);
switch(x)
{
case 1:printf("enter components of new top\n");
scanf("%f%f%f",&r1,&r2,&r3);
break;
case 2:printf("enter components of new body\n");
scanf("%f%f%f",&b1,&b2,&b3);
break;
case 3:printf("enter components of new tail\n");
scanf("%f%f%f",&t1,&t2,&t3);
break;
case 4:break;
}
}while(x!=4);
display();
}
void myinit()
{
glClearColor(0.0,0.0,0.0,1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0,500.0,0.0,500.0);
glMatrixMode(GL_MODELVIEW);
}

void main(int argc, char**argv)

Page 5
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(500,500);
glutInitWindowPosition(750.0,0.0);
glutCreateWindow("Rocket");
glutDisplayFunc(display);
myinit();
glutMainLoop();
}

Output:

3. Program to create a house like figure and rotate about a given fixed point using
openGL functions.

Objective: In this program the students will learn to draw a house and use transformation
functions of OpenGL to rotate it about a fixed point.

Program:
#include <stdlib.h>
#include <stdio.h>

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

GLfloat house[3][9]={ {100.0,100.0,175.0,250.0,250.0,150.0,150.0,200.0,200.0},

{100.0,300.0,400.0,300.0,100.0,100.0,150.0,150.0,100.0},
{1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 } };
GLfloat rot_mat[3][3]={{0},{0},{0}};
GLfloat result[3][9]={{0},{0},{0}};
GLfloat h=100.0;
GLfloat k=100.0,theta;
void multiply()
{
int i,j,l;
for(i=0;i<3;i++)
for(j=0;j<9;j++)
{
result[i][j]=0;
for(l=0;l<3;l++)
result[i][j]=result[i][j]+rot_mat[i][l]*house[l][j];
}
}

void rotate()
{
GLfloat m,n;
m=-h*(cos(theta)-1)+k*(sin(theta));
n=-k*(cos(theta)-1)-h*(sin(theta));
rot_mat[0][0]=cos(theta);
rot_mat[0][1]=-sin(theta);
rot_mat[0][2]=m;
rot_mat[1][0]=sin(theta);
rot_mat[1][1]=cos(theta);
rot_mat[1][2]=n;
rot_mat[2][0]=0;
rot_mat[2][1]=0;
rot_mat[2][2]=1;
multiply();
}

void draw_house()
{
glColor3f(0.0,0.0,1.0);
glBegin(GL_LINE_LOOP);
glVertex2f(house[0][0],house[1][0]);
glVertex2f(house[0][1],house[1][1]);
glVertex2f(house[0][3],house[1][3]);
glVertex2f(house[0][4],house[1][4]);
glEnd();
glColor3f(1.0,0.0,0.0);
glBegin(GL_LINE_LOOP);

Page 7
 glVertex2f(house[0][5],house[1][5]);
glVertex2f(house[0][6],house[1][6]);
glVertex2f(house[0][7],house[1][7]);
glVertex2f(house[0][8],house[1][8]);
glEnd();
glColor3f(0.0,0.0,1.0);
glBegin(GL_LINE_LOOP);
glVertex2f(house[0][1],house[1][1]);
glVertex2f(house[0][2],house[1][2]);
glVertex2f(house[0][3],house[1][3]);
glEnd();
}

void drawrotatedhouse()
{
glColor3f(0.0,0.0,1.0);
glBegin(GL_LINE_LOOP);
glVertex2f(result[0][0],result[1][0]);
glVertex2f(result[0][1],result[1][1]);
glVertex2f(result[0][3],result[1][3]);
glVertex2f(result[0][4],result[1][4]);
glEnd();
glColor3f(1.0,0.0,0.0);
glBegin(GL_LINE_LOOP);
glVertex2f(result[0][5],result[1][5]);
glVertex2f(result[0][6],result[1][6]);
glVertex2f(result[0][7],result[1][7]);
glVertex2f(result[0][8],result[1][8]);
glEnd();
glColor3f(0.0,0.0,1.0);
glBegin(GL_LINE_LOOP);
glVertex2f(result[0][1],result[1][1]);
glVertex2f(result[0][2],result[1][2]);
glVertex2f(result[0][3],result[1][3]);
glEnd();
}

void display()
{
glClear(GL_COLOR_BUFFER_BIT);
draw_house();
rotate();
drawrotatedhouse();
glFlush();
}

void myinit()
{
glClearColor(1.0,1.0,1.0,1.0);
glColor3f(1.0,0.0,0.0);

Page 8
 glPointSize(1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0,500.0,0.0,500.0);
glMatrixMode(GL_MODELVIEW);

int main(int argc,char *argv[])

{
printf("enter the rotation angle\n");
scanf("%f",&theta);
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(500,500);
glutInitWindowPosition(0,0);
glutCreateWindow("house rotation");
glutDisplayFunc(display);
myinit();
glutMainLoop();
}

Output:

gcc -o fn fn.c -lGL -lGLU -lglut -lm

Page 9
4. Program to draw a color cube and spin it using openGL transformation matrices.

Objective : In this program the students will learn to draw a color cube and spin it using
OpenGL functions.

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

GLfloat vertices[ ]={ -1.0,-1.0,-1.0,

1.0,-1.0,-1.0,
1.0, 1.0,-1.0,
- 1.0, 1.0,-1.0,
- 1.0,-1.0, 1.0,
1.0,-1.0, 1.0,
1.0, 1.0, 1.0,
-1.0, 1.0, 1.0 };

GLfloat normals[ ]={ -1.0,-1.0,-1.0,

1.0,-1.0,-1.0,
1.0, 1.0,-1.0,
-1.0, 1.0,-1.0,
-1.0,-1.0, 1.0,
1.0,-1.0, 1.0,
1.0, 1.0, 1.0,
-1.0, 1.0, 1.0 };

GLfloat colors[ ]={ 0.0,0.0,0.0,

1.0,0.0,0.0,
1.0,1.0,0.0,
0.0,1.0,0.0,
0.0,0.0,1.0,
1.0,0.0,1.0,
1.0,1.0,1.0,
0.0,1.0,1.0};

GLubyte cubeIndices[]={0,3,2,1,
2,3,7,6,
0,4,7,3,
1,2,6,5,
4,5,6,7,
0,1,5,4 };

static GLfloat theta[]={0.0,0.0,0.0};

static GLint axis=2;

void display(void)

Page 10
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glRotatef(theta[0],1.0,0.0,0.0);
glRotatef(theta[1],0.0,1.0,0.0);
glRotatef(theta[2],0.0,0.0,1.0);
glDrawElements(GL_QUADS,24,GL_UNSIGNED_BYTE,cubeIndices);
glFlush();
glutSwapBuffers();
}

void mouse(int btn,int state,int x,int y)

{
if(btn==GLUT_LEFT_BUTTON && state==GLUT_DOWN)axis=0;
if(btn==GLUT_RIGHT_BUTTON && state==GLUT_DOWN) axis=1;
if(btn==GLUT_MIDDLE_BUTTON && state==GLUT_DOWN) axis=2;
}

void spincube()
{
theta[axis]+=2.0;
if(theta[axis]>360.0)
theta[axis]-=360.0;
glutPostRedisplay();
}

void myReshape(int w,int h)

{
glViewport(0,0,w,h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if(w<=h)

glOrtho(-2.0,2.0,-2.0*(GLfloat)h/(GLfloat)w,2.0*(GLfloat)h/(GLfloat)w,10.0,10.0);
else
glOrtho(-2.0*(GLfloat)w/(GLfloat)h,2.0*(GLfloat)w/(GLfloat)h,-2.0,2.0,-
10.0,10.0);
glMatrixMode(GL_MODELVIEW);
}

int main(int argc,char **argv)

{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);
glutInitWindowSize(500,500);
glutCreateWindow("color cuce");
glutReshapeFunc(myReshape);
glutDisplayFunc(display);
glutMouseFunc(mouse);

Page 11
 glutIdleFunc(spincube);
glEnable(GL_DEPTH_TEST);
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glVertexPointer(3,GL_FLOAT,0,vertices);
glColorPointer(3,GL_FLOAT,0,colors);
glNormalPointer(GL_FLOAT,0,normals);
glColor3f(1.0,1.0,1.0);
glutMainLoop();
}
Output

5. Program to create a cylinder and a parallelepiped by extruding a circle and a

quadrilateral respectively. Allow the user to specify the circle and the quadrilateral.

Objective: In this program the students will learn to create a cylinder and a parallelepiped
using OpenGL functions.

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

void draw_pixel(GLint cx,GLint cy)

{
glColor3f(1.0,0.0,0.0);
glBegin(GL_POINTS);
glVertex2f(cx,cy);
glEnd();
}

Page 12
void plot_pixel(GLint h,GLint k,GLint x,GLint y)
{
draw_pixel(x+h,y+k);
draw_pixel(-x+h,y+k);
draw_pixel(x+h,-y+k);
draw_pixel(-x+h,-y+k);
draw_pixel(y+h,x+k);
draw_pixel(-y+h,x+k);
draw_pixel(y+h,-x+k);
draw_pixel(-y+h,-x+k);
}

void circle_draw(GLint h,GLint k,GLint r)

{
GLint d=1-r,x=0,y=r;
while(y>x)
{
plot_pixel(h,k,x,y);
if(d<0) d+=2*x+3;
else
{
d+=2*(x-y)+5;
--y;
} ++x;
}
plot_pixel(h,k,x,y);
}

void cylinder_draw()
{
GLint xc=100,yc=100,r=50;
GLint i,n=50;
for(i=0;i<n;i+=3)
circle_draw(xc,yc+i,r);
}

void parallelopiped(int x1,int x2,int y1,int y2,int y3,int y4)

{
glColor3f(0.0,0.0,1.0);
glPointSize(2.0);
glBegin(GL_LINE_LOOP);
glVertex2f(x1,y1);
glVertex2f(x2,y3);
glVertex2f(x2,y4);
glVertex2f(x1,y2);
glEnd();
}

Page 13
void parallelopiped_draw()
{
int x1=200,x2=300,y1=100,y2=175,y3=100,y4=175;
GLint i,n=40;
for(i=0;i<n;i+=2)
parallelopiped(x1+i,x2+i,y1+i,y2+i,y3+i,y4+i);
}

void init(void)
{
glClearColor(1.0,1.0,1.0,1.0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(0.0,400.0,0.0,300.0);
}

void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0,0.0,0.0);
glPointSize(2.0);
cylinder_draw();
parallelopiped_draw();
glFlush();
}

int main(int argc,char *argv[])

{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(500,500);
glutInitWindowPosition(0,0);
glutCreateWindow("cylinder and parallelopiped");
glutDisplayFunc(display);
init();
glutMainLoop();
}

Output

Page 14
6. Program using openGL functions to draw a simple shaded scene consisting of a
teapot on a table. Define suitably the positions and properties of the light source along
with the properties of the surfaces of the solid object used in the scene.

Objective:
In this program the students will learn to draw teapot with table and surfaces using OpenGL
functions.

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

void wall(double thickness)

{
glPushMatrix();
glTranslated(0.5,0.5*thickness,0.5);
glScaled(1.0,thickness,1.0);
glutSolidCube(1.0);
glPopMatrix();
}

void tableleg(double thick,double len)

{
glPushMatrix();
glTranslated(0,len/2,0);

Page 15
 glScaled(thick,len,thick);
glutSolidCube(1.0);
glPopMatrix();
}

void table(double topw,double topt,double legt,double legl)

{
glPushMatrix();
glTranslated(0,legl,0);
glScaled(topw,topt,topw);
glutSolidCube(1.0);
glPopMatrix();

double dist=0.95*topw/2.0-legt/2.0;

glPushMatrix();

glTranslated(dist,0,dist);
tableleg(legt,legl);

glTranslated(0,0,-2*dist);
tableleg(legt,legl);

glTranslated(-2*dist,0,2*dist);
tableleg(legt,legl);

glTranslated(0,0,-2*dist);
tableleg(legt,legl);
glPopMatrix();
}

void displaysolid(void)
{
GLfloat mat_ambient[]={0.7f,0.7f,0.7f,1.0f};
GLfloat mat_diffuse[]={0.5f,0.5f,0.5f,1.0f};
GLfloat mat_specular[]={1.0f,1.0f,1.0f,1.0f};
GLfloat mat_shininess[]={50.0f};

glMaterialfv(GL_FRONT,GL_AMBIENT,mat_ambient);
glMaterialfv(GL_FRONT,GL_DIFFUSE,mat_diffuse);
glMaterialfv(GL_FRONT,GL_SPECULAR,mat_specular);
glMaterialfv(GL_FRONT,GL_SHININESS,mat_shininess);

GLfloat lightint[]={0.7f,0.7f,0.7f,1.0f};
GLfloat lightpos[]={2.0f,6.0f,3.0f,0.0f};

Page 16
 glLightfv(GL_LIGHT0,GL_POSITION,lightpos);
glLightfv(GL_LIGHT0,GL_DIFFUSE,lightint);

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
double winht=1.0;
glOrtho(-winht*64/48.0,winht*64/48.0,-winht,winht,0.1,100.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(2.3,1.3,2.0,0.0,0.25,0.0,0.0,1.0,0.0);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

glPushMatrix();
glRotated(90.0,0.0,0.0,1.0);
wall(0.02);
glPopMatrix();
wall(0.02);
glPushMatrix();
glRotated(-90.0,1.0,0.0,0.0);
wall(0.02);
glPopMatrix();

glPushMatrix();
glTranslated(0.4,0,0.4);
table(0.6,0.02,0.02,0.3);
glPopMatrix();

glPushMatrix();
glTranslated(0.6,0.38,0.5);
glRotated(30,0,1,0);
glutSolidTeapot(0.08);
glPopMatrix();

glFlush();

int main(int argc,char**argv)

{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB|GLUT_DEPTH);
glutInitWindowSize(500,500);
glutInitWindowPosition(0,0);
glutCreateWindow("teapot");
glutDisplayFunc(displaysolid);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);

Page 17
 glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
glClearColor(0.1,0.1,0.1,0.0);
glViewport(0,0,640,480);
glutMainLoop();
}

Output

7. Program to fill any given polygon using scan-line area filling algorithm. (Use
appropriate data structures)

Objective:
In this program the students will learn to apply scan-line area filling algorithm to fill a
polygon using OpenGL functions.

// Scan-Line algorithm for filling a polygon

#include <stdlib.h>
#include <stdio.h>
#include <GL/glut.h>
float x1,x2,x3,x4,y1,y2,y3,y4;
void edgedetect(float x1,float y1,float x2,float y2,int *le,int *re)
{
float mx,x,temp;
int i;
if((y2-y1)<0)
{
temp=y1;y1=y2;y2=temp;
temp=x1;x1=x2;x2=temp;
}
if((y2-y1)!=0)
mx=(x2-x1)/(y2-y1);

Page 18
 else
mx=x2-x1;
x=x1;
for(i=y1;i<=y2;i++)
{
if(x<(float)le[i])
le[i]=(int)x;
if(x>(float)re[i])
re[i]=(int)x;
x+=mx;
}
}
void draw_pixel(int x,int y)
{
glColor3f(1.0,1.0,0.0);
glBegin(GL_POINTS);
glVertex2i(x,y);
glEnd();
}
void scanfill(float x1,float y1,float x2,float y2,float x3,float y3,float x4,float y4)
{
int le[500],re[500];
int i,y;
for(i=0;i<500;i++)
{
le[i]=500;
re[i]=0;
}
edgedetect(x1,y1,x2,y2,le,re);
edgedetect(x2,y2,x3,y3,le,re);
edgedetect(x3,y3,x4,y4,le,re);
edgedetect(x4,y4,x1,y1,le,re);
for(y=0;y<500;y++)
{
if(le[y]<=re[y])
for(i=(int)le[y];i<(int)re[y];i++)
draw_pixel(i,y);

}
void display()
{
x1=200.0;y1=200.0;x2=100.0;y2=300.0;x3=200.0;y3=400.0;x4=300.0;y4=300.0;

glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.0, 0.0, 1.0);
glBegin(GL_LINE_LOOP);
glVertex2f(x1,y1);
glVertex2f(x2,y2);

Page 19
 glVertex2f(x3,y3);
glVertex2f(x4,y4);
glEnd();
scanfill(x1,y1,x2,y2,x3,y3,x4,y4);

glFlush();
}

void myinit()
{
glClearColor(1.0,1.0,1.0,1.0);
glColor3f(1.0,0.0,0.0);
glPointSize(1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0,499.0,0.0,499.0);
}

int main(int argc, char** argv)

{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(500,500);
glutInitWindowPosition(0,0);
glutCreateWindow("Filling a Polygon using Scan-line Algorithm");
glutDisplayFunc(display);
myinit();
glutMainLoop();
}

Output:

Page 20
10. Program to display a set of values {fij} as a rectangular mesh .

Objective:
In this program the students will learn to create rectangular mesh using OpenGL functions.

#include <stdlib.h>
#include <GL/glut.h>
#define maxx 20
#define maxy 25
#define dx 15
#define dy 10

GLfloat x[maxx]={0.0},y[maxy]={0.0};
GLfloat x0=50.0,y0=50.0;
GLint i,j;

void myinit()
{
glClearColor(1.0,1.0,1.0,1.0);
glColor3f(1.0,0.0,0.0);
glPointSize(5.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0,500.0,0.0,500.0);
glutPostRedisplay();
}

void display(void)

Page 21
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
for(i=0;i<maxx;i++)
x[i]=x0+i*dx;
for(j=0;j<maxy;j++)
y[j]=y0+j*dy;
for(i=0;i<maxx-1;i++)
for(j=0;j<maxy-1;j++)
{
glBegin(GL_LINE_LOOP);
glVertex2f(x[i],y[j]);
glVertex2f(x[i],y[j+1]);
glVertex2f(x[i+1],y[j+1]);
glVertex2f(x[i+1],y[j]);
glEnd();
glFlush();
}
glFlush();
}
int main(int argc,char **argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB|GLUT_DEPTH);
glutInitWindowSize(500,500);
glutCreateWindow("mesh");
glutDisplayFunc(display);
myinit();
glutMainLoop();
}
Output

Page 22
9. To dip the line PQ against the window coordinates (0,0) and (10,10). P=(-8,2) and
Q=(2,14) using Liang Barsky line clipping algorithm.

Objective : In this program the students will learn to implement Liang-Barsky Line Clipping
Algorithm with Window to viewport Mapping with OPENGL API

Program

#include <stdio.h>
#include <GL/glut.h>
#define true 1
#define false 0

double xmin=50,ymin=50, xmax=100,ymax=100; // Window boundaries

double xvmin=200,yvmin=200,xvmax=300,yvmax=300; // Viewport boundaries
//int x1, x2, y1, y2;

int cliptest(double p, double q, double *t1, double *t2)

{
double t;
if(p) t=q/p; // to check whether p
if(p < 0.0) // potentially entry point, update te
{
if( t > *t1) *t1=t;
if( t > *t2) return(false); // line portion is outside
}
else
if(p > 0.0) // Potentially leaving point, update tl
{
if( t < *t2) *t2=t;
if( t < *t1) return(false); // line portion is outside
}
else
if(p == 0.0)
{
if( q < 0.0) return(false); // line parallel to edge but outside
}
return(true);
}

void LiangBarskyLineClipAndDraw (double x0, double y0,double x1, double y1)

{
double dx=x1-x0, dy=y1-y0, te=0.0, tl=1.0;
if(cliptest(-dx,x0-xmin,&te,&tl)) // inside test wrt left edge
if(cliptest(dx,xmax-x0,&te,&tl)) // inside test wrt right edge

Page 23
 if(cliptest(-dy,y0-ymin,&te,&tl)) // inside test wrt bottom edge
if(cliptest(dy,ymax-y0,&te,&tl)) // inside test wrt top edge
{
if( tl < 1.0 )
{
x1 = x0 + tl*dx;
y1 = y0 + tl*dy;
}
if( te > 0.0 )
{ x0 = x0 + te*dx;
y0 = y0 + te*dy;
}

// Window to viewport mappings

double sx=(xvmax-xvmin)/(xmax-xmin); // Scale parameters
double sy=(yvmax-yvmin)/(ymax-ymin);
double vx0=xvmin+(x0-xmin)*sx;
double vy0=yvmin+(y0-ymin)*sy;
double vx1=xvmin+(x1-xmin)*sx;
double vy1=yvmin+(y1-ymin)*sy;
//draw a red colored viewport
glColor3f(1.0, 0.0, 0.0);
glBegin(GL_LINE_LOOP);
glVertex2f(xvmin, yvmin);
glVertex2f(xvmax, yvmin);
glVertex2f(xvmax, yvmax);
glVertex2f(xvmin, yvmax);
glEnd();
glColor3f(0.0,0.0,1.0); // draw blue colored clipped line
glBegin(GL_LINES);
glVertex2d (vx0, vy0);
glVertex2d (vx1, vy1);
glEnd();
}
}// end of line clipping
void display()
{
double x0=60,y0=20,x1=80,y1=120;
glClear(GL_COLOR_BUFFER_BIT);
//draw the line with red color
glColor3f(1.0,0.0,0.0);
glBegin(GL_LINES);
glVertex2d (x0, y0);
glVertex2d (x1, y1);
glEnd();

//draw a blue colored window

glColor3f(0.0, 0.0, 1.0);

glBegin(GL_LINE_LOOP);

Page 24
 glVertex2f(xmin, ymin);
glVertex2f(xmax, ymin);
glVertex2f(xmax, ymax);
glVertex2f(xmin, ymax);
glEnd();
LiangBarskyLineClipAndDraw(x0,y0,x1,y1);
glFlush();
}
void myinit()
{
glClearColor(1.0,1.0,1.0,1.0);
glColor3f(1.0,0.0,0.0);
glPointSize(1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0,499.0,0.0,499.0);
}
int main(int argc, char** argv)
{
//printf("Enter End points:");
//scanf("%d%d%d%d", &x1,&x2,&y1,&y2);

glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(500,500);
glutInitWindowPosition(0,0);
glutCreateWindow("Liang Barsky Line Clipping Algorithm");
glutDisplayFunc(display);
myinit();
glutMainLoop();
}

Output

Page 25
10. To clip the line segment A(-4,2) and B(-1,7) in a window defined by left bottom
corner at (-3,1) and upper right corner at (2,6). Find the visible portion of the line
segment using Cohen Sutherland line clipping algorithm.

Objective: In this program the students will learn to implement Cohen-Sutherland Line
Clipping Algorithm with Window to viewport Mapping with OpenGL API.

#include <stdio.h>
#include <GL/glut.h>
#define outcode int
#define true 1
#define false 0

double xmin=50,ymin=50, xmax=100,ymax=100; // Window boundaries

double xvmin=200,yvmin=200,xvmax=300,yvmax=300; // Viewport boundaries
//int x1, x2, y1, y2;
//bit codes for the right, left, top, & bottom
const int RIGHT = 8;
const int LEFT = 2;
const int TOP = 4;
const int BOTTOM = 1;

//used to compute bit codes of a point

outcode ComputeOutCode (double x, double y);

//Cohen-Sutherland clipping algorithm clips a line from

//P0 = (x0, y0) to P1 = (x1, y1) against a rectangle with
//diagonal from (xmin, ymin) to (xmax, ymax).
void CohenSutherlandLineClipAndDraw (double x0, double y0,double x1, double y1)
{
//Outcodes for P0, P1, and whatever point lies outside the clip rectangle
outcode outcode0, outcode1, outcodeOut;
Page 26
bool accept = false, done = false;

//compute outcodes
outcode0 = ComputeOutCode (x0, y0);
outcode1 = ComputeOutCode (x1, y1);

do{
if (!(outcode0 | outcode1)) //logical or is 0 Trivially accept & exit
{
accept = true;
done = true;
}
else if (outcode0 & outcode1) //logical and is not 0. Trivially reject and exit
done = true;
else
{
//failed both tests, so calculate the line segment to clip
//from an outside point to an intersection with clip edge
double x, y;

//At least one endpoint is outside the clip rectangle; pick it.
outcodeOut = outcode0? outcode0: outcode1;

//Now find the intersection point;

//use formulas y = y0 + slope * (x - x0), x = x0 + (1/slope)* (y - y0)
if (outcodeOut & TOP) //point is above the clip rectangle
{
x = x0 + (x1 - x0) * (ymax - y0)/(y1 - y0);
y = ymax;
}
else if (outcodeOut & BOTTOM) //point is below the clip rectangle
{
x = x0 + (x1 - x0) * (ymin - y0)/(y1 - y0);
y = ymin;
}
else if (outcodeOut & RIGHT) //point is to the right of clip rectangle
{
y = y0 + (y1 - y0) * (xmax - x0)/(x1 - x0);
x = xmax;
}
else //point is to the left of clip rectangle
{
y = y0 + (y1 - y0) * (xmin - x0)/(x1 - x0);
x = xmin;
}

//Now we move outside point to intersection point to clip

//and get ready for next pass.
if (outcodeOut == outcode0)
{

Page 27
 x0 = x;
y0 = y;
outcode0 = ComputeOutCode (x0, y0);
}
else
{
x1 = x;
y1 = y;
outcode1 = ComputeOutCode (x1, y1);
}
}
}while (!done);

if (accept)
{ // Window to viewport mappings
double sx=(xvmax-xvmin)/(xmax-xmin); // Scale parameters
double sy=(yvmax-yvmin)/(ymax-ymin);
double vx0=xvmin+(x0-xmin)*sx;
double vy0=yvmin+(y0-ymin)*sy;
double vx1=xvmin+(x1-xmin)*sx;
double vy1=yvmin+(y1-ymin)*sy;
//draw a red colored viewport
glColor3f(1.0, 0.0, 0.0);
glBegin(GL_LINE_LOOP);
glVertex2f(xvmin, yvmin);
glVertex2f(xvmax, yvmin);
glVertex2f(xvmax, yvmax);
glVertex2f(xvmin, yvmax);
glEnd();
glColor3f(0.0,0.0,1.0); // draw blue colored clipped line
glBegin(GL_LINES);
glVertex2d (vx0, vy0);
glVertex2d (vx1, vy1);
glEnd();
}
}

//Compute the bit code for a point (x, y) using the clip rectangle
//bounded diagonally by (xmin, ymin), and (xmax, ymax)
outcode ComputeOutCode (double x, double y)
{
outcode code = 0;
if (y > ymax) //above the clip window
code |= TOP;
else if (y < ymin) //below the clip window
code |= BOTTOM;
if (x > xmax) //to the right of clip window
code |= RIGHT;
else if (x < xmin) //to the left of clip window
code |= LEFT;

Page 28
 return code;
}

void display()
{
double x0=120,y0=10,x1=40,y1=130;
glClear(GL_COLOR_BUFFER_BIT);
//draw the line with red color
glColor3f(1.0,0.0,0.0);
//bres(120,20,340,250);
glBegin(GL_LINES);
glVertex2d (x0, y0);
glVertex2d (x1, y1);
glVertex2d (60,20);
glVertex2d (80,120);
glEnd();

//draw a blue colored window

glColor3f(0.0, 0.0, 1.0);

glBegin(GL_LINE_LOOP);
glVertex2f(xmin, ymin);
glVertex2f(xmax, ymin);
glVertex2f(xmax, ymax);
glVertex2f(xmin, ymax);
glEnd();
CohenSutherlandLineClipAndDraw(x0,y0,x1,y1);
CohenSutherlandLineClipAndDraw(60,20,80,120);
glFlush();
}
void myinit()
{
glClearColor(1.0,1.0,1.0,1.0);
glColor3f(1.0,0.0,0.0);
glPointSize(1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0,499.0,0.0,499.0);
}
int main(int argc, char** argv)
{

//printf("Enter End points:");

//scanf("%d%d%d%d", &x1,&x2,&y1,&y2);

glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(500,500);
glutInitWindowPosition(0,0);
glutCreateWindow("Cohen Suderland Line Clipping Algorithm");

Page 29
 glutDisplayFunc(display);
myinit();
glutMainLoop();
}

Output:

Page 30