GOVERNMENT ENGINEERING COLLEGE

RAICHUR-584134

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

LABORATORY MANUAL

SUBJECT: COMPUTER GRAPHIC LABORATORY

SUB CODE: 18CSL57

SEMESTER: VI

2018 CBCS Scheme

1. Implement Brenham’s line drawing algorithm for all types
of slope.

#include<GL/glut.h>
#include<stdio.h>
int x1, y1, x2, y2;
void draw_pixel(int x, int y)
{
glColor3f(1.0,0.0,0.0);
glBegin(GL_POINTS);
glVertex2i(x, y);
glEnd();
}
void bresenhams_line_draw(int x1, int y1, int x2, int y2)
{
float dx = x2 - x1;
float dy = y2 - y1;
float m = dy/dx;
if(m < 1)
{
int decision_parameter = 2*dy - dx;
int x = x1; // initial x
int y = y1; // initial y
if(dx < 0) // decide the first point and second point
{
x = x2;
y = y2;
x2 = x1;
}
draw_pixel(x, y); // plot a point
while(x < x2) // from 1st point to 2nd point
{
if(decision_parameter >= 0)
{
x = x+1;
y = y+1;
decision_parameter=decision_parameter + 2*dy - 2*dx * (y+1 - y);
}
else
{
x = x+1;
y = y;
decision_parameter = decision_parameter + 2*dy - 2*dx * (y- y);
}
draw_pixel(x, y);
}
}
else if(m > 1)
{
int decision_parameter = 2*dx - dy;

int x = x1; // initial x

int y = y1; // initial y
if(dy < 0)
{
x = x2;
y = y2;
y2 = y1;
}
draw_pixel(x, y);
while(y < y2)
{
if(decision_parameter >= 0)
{

x = x+1;
y = y+1;
decision_parameter=decision_parameter + 2*dx - 2*dy * (x+1 - x);
}
else
{
y = y+1;
x = x;
decision_parameter = decision_parameter + 2*dx - 2*dy * (x- x);
}
draw_pixel(x, y);
}
}
else if (m == 1)
{
int x = x1;
int y = y1;
draw_pixel(x, y);
while(x < x2)
{
x = x+1;
y = y+1;
draw_pixel(x, y);
}
}
}
void init()
{
glClearColor(1,1,1,1);
gluOrtho2D(0.0, 500.0, 0.0, 500.0); // left ->0, right ->500, bottom ->0,
top ->500
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
bresenhams_line_draw(x1, y1, x2, y2);
glFlush();
}

int main(int argc, char **argv)

{
printf( "Enter Start Points (x1,y1)\n");
scanf("%d %d", &x1, &y1); // 1st point from user
printf( "Enter End Points (x2,y2)\n");
scanf("%d %d", &x2, &y2); // 2nd point from user
glutInit(&argc, argv); // initialize graphics system
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); // single buffered mode
with RGB colour variants
glutInitWindowSize(500, 500); // 500 by 500 window size
glutInitWindowPosition(220, 200); // where do you wanna see
your window
glutCreateWindow("Bresenham's Line Drawing - FVBIE"); // the title of your
window
init(); // initialize the canvas
 glutDisplayFunc(display); // call display function
glutMainLoop(); // run forever
}

OUTPUT:
2. Create and rotate a triangle about the origin and a fixed
point.
#include<GL/glut.h>
#include<stdio.h>
int x,y;
int where_to_rotate=0; // don't rotate initially
float rotate_angle=0; // initial angle
float translate_x=0,translate_y=0; // initial translation
void draw_pixel(float x1, float y1)
{
glPointSize(5);
glBegin(GL_POINTS);
glVertex2f(x1,y1); // plot a single point
glEnd();
}
void triangle(int x, int y)
{
glColor3f(1,0,0);
glBegin(GL_POLYGON); // drawing a Triangle
glVertex2f(x,y);
glVertex2f(x+400,y+300);
glVertex2f(x+300,y+0);
glEnd();
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glLoadIdentity();
glColor3f(1,1,1); // mark origin point as white dot
draw_pixel(0,0); // plot origin - white colour
if (where_to_rotate == 1) //Rotate Around origin
{
translate_x = 0; // no translation for rotation around origin
translate_y = 0;
rotate_angle += 1; // the amount of rotation angle
}
if (where_to_rotate == 2) //Rotate Around Fixed Point
{
translate_x = x; // SET the translation to wherever the customer says
translate_y = y;
rotate_angle += 1; // the amount of rotation angle
glColor3f(0,0,1); // mark the customer coordinate as blue dot
draw_pixel(x,y); // plot the customer coordinate - blue colour
}
glTranslatef(translate_x, translate_y, 0); // ACTUAL translation +ve
glRotatef(rotate_angle, 0, 0, 1); // rotate
glTranslatef(-translate_x, -translate_y, 0); // ACTUAL translation -ve
triangle(translate_x,translate_y); // what to rotate? - TRIANGLE
glutPostRedisplay(); // call display function again and again
glutSwapBuffers(); // show the output
}
void init()
{
glClearColor(0,0,0,1); //setting to black
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(-800, 800, -800, 800);
glMatrixMode(GL_MODELVIEW);
}
void rotateMenu (int option)
{
if(option==1)
where_to_rotate=1; // rotate around origin
if(option==2)
where_to_rotate=2; // rotate around customer's coordinates
if(option==3)

where_to_rotate=3; // stop rotation

}
int main(int argc, char **argv)
{
printf( "Enter Fixed Points (x,y) for Rotation: \n");
scanf("%d %d", &x, &y); // getting the user's coordinates to rotate
glutInit(&argc, argv); // initialize the graphics system
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB); // SINGLE also works
glutInitWindowSize(800, 800); // 800 by 800 size..you can change it
glutInitWindowPosition(0, 0); // where do you wanna see your window
glutCreateWindow("Create and Rotate Triangle"); // title
init(); // initialize the canvas
glutDisplayFunc(display); // call display function
glutCreateMenu(rotateMenu); // menu items
glutAddMenuEntry("Rotate around ORIGIN",1);
glutAddMenuEntry("Rotate around FIXED POINT",2);
glutAddMenuEntry("Stop Rotation",3);
glutAttachMenu(GLUT_RIGHT_BUTTON);
glutMainLoop(); // run forever
}

OUTPUT:
3. Draw a colour cube and spin it using OpenGL transformation
matrices.
#include<stdlib.h>
#include<GL/glut.h>
GLfloat vertices[]= {-1, -1, -1,
1, -1, -1,
1, 1, -1,
-1, 1, -1,
-1, -1, 1,
1, -1, 1,
1, 1, 1,
-1, 1, 1
};
GLfloat colors[]= {0, 0, 0,
1, 0, 0,
1, 1, 0,
0, 1, 0,
0, 0, 1,
1, 0, 1,
1, 1, 1,
0, 1, 1
};
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};
static GLint axis=2;
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glRotatef(theta[0], 1, 0, 0);
glRotatef(theta[1], 0, 1, 0);
glRotatef(theta[2], 0, 0, 1);
glDrawElements(GL_QUADS,24,GL_UNSIGNED_BYTE,cubeIndices);
glutSwapBuffers();
}
void spinCube()
{
theta[axis] += 2;
if(theta[axis] > 360)
theta[axis] -= 360;
glutPostRedisplay();
}
void mouse(int btn, int state, int x, int y)
{
if(btn==GLUT_LEFT_BUTTON && state==GLUT_DOWN)
axis=0;
if(btn==GLUT_MIDDLE_BUTTON && state==GLUT_DOWN)
axis=1;
if(btn==GLUT_RIGHT_BUTTON && state==GLUT_DOWN)
axis=2;
}
void myReshape(int w, int h)
{
 glViewport(0,0,w,h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if(w<=h)
glOrtho(-2, 2, -2*(GLfloat)h/(GLfloat)w, 2*(GLfloat)h/(GLfloat)w, -10, 10);
else
glOrtho(-2*(GLfloat)w/(GLfloat)h, 2*(GLfloat)w/(GLfloat)h, -2, 2, -10, 10);
glMatrixMode(GL_MODELVIEW);
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);
glutInitWindowSize(500, 500);
glutCreateWindow("Spin a color cube");
glutReshapeFunc(myReshape);
glutDisplayFunc(display);
glutIdleFunc(spinCube);
glutMouseFunc(mouse);
glEnable(GL_DEPTH_TEST);
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, vertices);
glColorPointer(3, GL_FLOAT, 0, colors);
glColor3f(1, 1, 1);
glutMainLoop();
}

OUTPUT:
4. Draw a color cube and allow the user to move the camera suitably
to experiment with perspective viewing.

#include <stdlib.h>
#include <GL/glut.h>
GLfloat vertices[][3] = { {-1,-1,-1},
{1,-1,-1},
{1,1,-1},
{-1,1,-1},
{-1,-1,1},
{1,-1,1},
{1,1,1},
{-1,1,1}
};
GLfloat colors[][3] = { {1,0,0},
{1,1,0},
{0,1,0},
{0,0,1},
{1,0,1},
{1,1,1},
{0,1,1},
{0.5,0.5,0.5}
};
GLfloat theta[] = {0.0,0.0,0.0};
GLint axis = 2;
GLdouble viewer[]= {0.0, 0.0, 5.0}; // initial viewer location //
void polygon(int a, int b, int c, int d)
{
glBegin(GL_POLYGON);
glColor3fv(colors[a]);
glVertex3fv(vertices[a]);
glColor3fv(colors[b]);
glVertex3fv(vertices[b]);
glColor3fv(colors[c]);
glVertex3fv(vertices[c]);
glColor3fv(colors[d]);
glVertex3fv(vertices[d]);
glEnd();
}
void colorcube(void)
{
polygon(0,3,2,1);
polygon(0,4,7,3);
polygon(5,4,0,1);
polygon(2,3,7,6);
polygon(1,2,6,5);
polygon(4,5,6,7);
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
gluLookAt(viewer[0],viewer[1],viewer[2], 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
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);
colorcube();
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_MIDDLE_BUTTON && state == GLUT_DOWN) axis = 1;
if(btn==GLUT_RIGHT_BUTTON && state == GLUT_DOWN) axis = 2;
theta[axis] += 2.0;
if( theta[axis] > 360.0 ) theta[axis] -= 360.0;
display();
}
void keys(unsigned char key, int x, int y)
{
if(key == 'x') viewer[0]-= 1.0;
if(key == 'X') viewer[0]+= 1.0;
if(key == 'y') viewer[1]-= 1.0;
if(key == 'Y') viewer[1]+= 1.0;
if(key == 'z') viewer[2]-= 1.0;
if(key == 'Z') viewer[2]+= 1.0;
display();
}
void myReshape(int w, int h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if(w<=h)
glFrustum(-2.0, 2.0, -2.0 * (GLfloat) h/ (GLfloat) w, 2.0* (GLfloat) h / (GLfloat)
w,2.0, 20.0);
else
glFrustum(-2.0, 2.0, -2.0 * (GLfloat) w/ (GLfloat) h, 2.0* (GLfloat) w / (GLfloat)
h, 2.0, 20.0);
glMatrixMode(GL_MODELVIEW);
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(500, 500);
glutCreateWindow("Colorcube Viewer");
glutReshapeFunc(myReshape);
 glutDisplayFunc(display);
glutMouseFunc(mouse);
glutKeyboardFunc(keys);
glEnable(GL_DEPTH_TEST);
glutMainLoop();
}

OUTPUT:

5. Clip a lines using Cohen-Sutherland algorithm.

#include <stdio.h>
#include <GL/glut.h>
double xmin = 50, ymin = 50, xmax = 100, ymax = 100; //window
coordinates
double xvmin = 200, yvmin = 200, xvmax = 300, yvmax = 300; //viewport
coordinates
const int LEFT = 1; // code words for LEFT, RIGHT, BOTTOM &TOP.
const int RIGHT = 2;
const int BOTTOM = 4;
const int TOP = 8;
int ComputeOutCode (double x, double y)
{
 int 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;
return code;
}
void CohenSutherland(double x0, double y0,double x1, double y1)
{
int outcode0, outcode1, outcodeOut;
bool accept = false, done = false;
outcode0 = ComputeOutCode (x0, y0); //calculate the region of 1st point
outcode1 = ComputeOutCode (x1, y1); //calculate the region of 2nd point
do
{
if (!(outcode0 | outcode1))
{
accept = true;
done = true;
}
else if (outcode0 & outcode1)
done = true;
else
{
double x, y;
double m = (y1 - y0)/(x1 - x0);
outcodeOut = outcode0? outcode0: outcode1;
if (outcodeOut & TOP)
{
x = x0 + (1/m) * (ymax - y0);
y = ymax;
}
else if (outcodeOut & BOTTOM)
{
x = x0 + (1/m) * (ymin - y0);
y = ymin;
}
else if (outcodeOut & RIGHT)
{
y = y0 + m * (xmax - x0);
x = xmax;
}
else
{
y = y0 + m * (xmin - x0);
x = xmin;
}
/* Intersection calculations over */
if (outcodeOut == outcode0)
{
 x0 = x;
y0 = y;
outcode0 = ComputeOutCode (x0, y0);
}
else
{
x1 = x;
y1 = y;
outcode1 = ComputeOutCode (x1, y1);
}
}
}
while (!done);
if (accept)
{
double sx = (xvmax - xvmin) / (xmax - xmin);
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;
glBegin(GL_LINE_LOOP);
glVertex2f(xvmin, yvmin);
glVertex2f(xvmax, yvmin);
glVertex2f(xvmax, yvmax);
glVertex2f(xvmin, yvmax);
glEnd();
glBegin(GL_LINES);
glVertex2d (vx0, vy0);
glVertex2d (vx1, vy1);
glEnd();
}
}
void display()
{
double x0 = 60, y0 = 20, x1 = 80, y1 = 120;
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1, 1, 1);//white
glBegin(GL_LINES);
glVertex2d (x0, y0);
glVertex2d (x1, y1);
glEnd();
glBegin(GL_LINE_LOOP);
glVertex2f(xmin, ymin);
glVertex2f(xmax, ymin);
glVertex2f(xmax, ymax);
glVertex2f(xmin, ymax);
glEnd();
CohenSutherland(x0, y0, x1, y1);
glFlush();
}
void myinit()
{
glClearColor(0, 0, 0, 1);//black
 gluOrtho2D(0, 500, 0, 500);
}
int main(int argc, char **argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(500, 500);
glutInitWindowPosition(0, 0);
glutCreateWindow("Cohen Sutherland Line Clipping Algorithm");
myinit();
glutDisplayFunc(display);
glutMainLoop();
}

OUTPUT:

6. To draw a simple shaded scene consisting of a tea pot on a table.

Define suitably the position and properties of the light source along
with the properties of the surfaces of the solid object used in the
scene.
#include<GL/glut.h>
void teapot(GLfloat x,GLfloat y,GLfloat z)
{
glPushMatrix();
glTranslatef(x, y, z);
glutSolidTeapot(0.1);
 glPopMatrix();
}
void tableTop(GLfloat x, GLfloat y, GLfloat z)
{
glPushMatrix();
glTranslatef(x, y, z);
glScalef(0.6, 0.02, 0.5);
glutSolidCube(1);
glPopMatrix();
}
void tableLeg(GLfloat x, GLfloat y, GLfloat z)
{
glPushMatrix();
glTranslatef(x, y, z);
glScalef(0.02, 0.3, 0.02);
glutSolidCube(1);
glPopMatrix();
}
void wall(GLfloat x, GLfloat y, GLfloat z)
{
glPushMatrix();
glTranslatef(x, y, z);
glScalef(1, 1, 0.02);
glutSolidCube(1);
glPopMatrix();
}
void light()
{
GLfloat mat_ambient[] = {1, 1, 1, 1};
GLfloat mat_diffuse[] = {0.5, 0.5, 0.5, 1};
GLfloat mat_specular[] = {1, 1, 1, 1};
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 light_position[] = {2, 6, 3, 1};
GLfloat light_intensity[] = {0.7, 0.7, 0.7, 1};
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_intensity);
}
void display()
{
GLfloat teapotP = -0.07, tabletopP = -0.15, tablelegP = 0.2, wallP = 0.5;
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
gluLookAt(-2, 2, 5, 0, 0, 0, 0, 1, 0);
light(); //Adding light source to your project
teapot(0, teapotP, 0); //Create teapot
tableTop(0, tabletopP, 0); //Create table’s top
tableLeg(tablelegP, -0.3, tablelegP); //Create 1st leg
tableLeg(-tablelegP, -0.3, tablelegP); //Create 2nd leg
tableLeg(-tablelegP, -0.3, -tablelegP); //Create 3rd leg
tableLeg(tablelegP, -0.3, -tablelegP); //Create 4th leg
 wall(0, 0, -wallP); //Create 1st wall
glRotatef(90, 1, 0, 0);
wall(0, 0, wallP); //Create 2nd wall
glRotatef(90, 0, 1, 0);
wall(0, 0, wallP); //Create 3rd wall
glFlush();
}
void myinit()
{
glClearColor(0, 0, 0, 1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-1, 1, -1, 1, -1, 10);
glMatrixMode(GL_MODELVIEW);
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB|GLUT_DEPTH);
glutInitWindowSize(500, 500);
glutInitWindowPosition(0, 0);
glutCreateWindow("Teapot on a table");
myinit();
glutDisplayFunc(display);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glShadeModel(GL_SMOOTH);
glEnable(GL_NORMALIZE);
glEnable(GL_DEPTH_TEST);
glutMainLoop();
}

OUTPUT:
7. Design, develop and implement recursively subdivide a
tetrahedron to form 3D sierpinski gasket. The number of recursive
steps is to be specified by the user.

#include<stdlib.h>
#include<stdio.h>
#include<GL/glut.h>
typedef float point[3];
point v[]= {{0, 0, 1}, {0, 1, 0}, {-1, -0.5, 0}, {1, -0.5, 0}};
int n;
void triangle(point a,point b,point c)
{
glBegin(GL_POLYGON);
glVertex3fv(a);
glVertex3fv(b);
glVertex3fv(c);
glEnd();
}
void divide_triangle(point a,point b,point c,int n)
{
point v1,v2,v3;
int j;
if(n>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] = (c[j]+b[j])/2;
divide_triangle(a,v1,v2,n-1);
glFlush();
divide_triangle(c,v2,v3,n-1);
glFlush();
divide_triangle(b,v3,v1,n-1);
glFlush();
}
else(triangle(a,b,c));
}
void tetrahedron(int n)
{
glColor3f(1, 0, 0);
divide_triangle(v[0], v[1], v[2], n);
glColor3f(0, 1, 0);
divide_triangle(v[3], v[2], v[1], n);
glColor3f(0, 0, 1);
divide_triangle(v[0], v[3], v[1], n);
glColor3f(0, 0, 0);
divide_triangle(v[0], v[2], v[3], n);
}
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, 2, -2*(GLfloat)h/(GLfloat)w, 2*(GLfloat)h/(GLfloat)w, -10, 10);
else
glOrtho(-2*(GLfloat)w/(GLfloat)h, 2*(GLfloat)w/(GLfloat)h, -2, 2, -10, 10);
glMatrixMode(GL_MODELVIEW);
glutPostRedisplay();
}
int main(int argc,char ** argv)
{
printf("No of Recursive steps/Division: ");
scanf("%d",&n);
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB|GLUT_DEPTH);
glutCreateWindow(" 3D Sierpinski gasket");
glutReshapeFunc(myReshape);
glutDisplayFunc(display);
 glEnable(GL_DEPTH_TEST);
glClearColor(1, 1, 1, 0);
glutMainLoop();
return 0;
}

OUTPUT:

8. Develop a menu driven program to animate a flag using Bezier

Curve algorithm.
//8. Develop a menu driven program to animate a flag using Bezier curve
algorithm.

#include<GL/glut.h>
#include<stdio.h>
#include<math.h>
#define PI 3.1416
float theta = 0;
struct point
{
GLfloat x, y, z;
};
int factorial(int n)
{
if (n<=1)
return(1);
 else
n=n*factorial(n-1);
return n;
}
void computeNcR(int n, int *hold_ncr_values)
{
int r;
for(r=0; r<=n; r++) //start from nC0, then nC1, nC2, nC3 till nCn
{
hold_ncr_values[r] = factorial(n) / (factorial(n-r) * factorial(r));
}
}
void computeBezierPoints(float t, point *actual_bezier_point, int
number_of_control_points, point *control_points_array, int *hold_ncr_values)
{
int i, n = number_of_control_points-1;
float bernstein_polynomial;
actual_bezier_point -> x = 0;
actual_bezier_point -> y = 0;
actual_bezier_point -> z = 0;
for(i=0; i < number_of_control_points; i++)
{
bernstein_polynomial = hold_ncr_values[i] * pow(t, i) * pow( 1-t, n-i);
actual_bezier_point -> x += bernstein_polynomial * control_points_array[i].x;
actual_bezier_point -> y += bernstein_polynomial * control_points_array[i].y;
actual_bezier_point -> z += bernstein_polynomial * control_points_array[i].z;
}
}
void bezier(point *control_points_array, int number_of_control_points, int
number_of_bezier_points)
{
point actual_bezier_point;
float t;
int *hold_ncr_values, i;
hold_ncr_values = new int[number_of_control_points]; // to hold the nCr
values
computeNcR(number_of_control_points-1, hold_ncr_values); // call nCr
function to calculate nCr values
glBegin(GL_LINE_STRIP);
for(i=0; i<=number_of_bezier_points; i++)
{
t=float(i)/float(number_of_bezier_points);
computeBezierPoints(t, &actual_bezier_point, number_of_control_points,
control_points_array, hold_ncr_values);
glVertex2f(actual_bezier_point.x, actual_bezier_point.y);
}
glEnd();
delete[] hold_ncr_values;
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
int number_of_control_points = 4, number_of_bezier_points = 20;
point control_points_array[4] = {{100, 400, 0}, {150, 450, 0}, {250, 350, 0},{300,
400, 0}};
control_points_array[1].x += 50*sin(theta * PI/180.0);
control_points_array[1].y += 25*sin(theta * PI/180.0);
control_points_array[2].x -= 50*sin((theta+30) * PI/180.0);
control_points_array[2].y -= 50*sin((theta+30) * PI/180.0);
control_points_array[3].x -= 25*sin((theta-30) * PI/180.0);
control_points_array[3].y += sin((theta-30) * PI/180.0);
theta += 2;
glPushMatrix();
glPointSize(5);
glColor3f(1, 0.4, 0.2); //Indian flag: Saffron color code
for(int i=0; i<50; i++)
{
glTranslatef(0, -0.8, 0 );
bezier(control_points_array, number_of_control_points,
number_of_bezier_points);
}
glColor3f(1, 1, 1); //Indian flag: white color code
for(int i=0; i<50; i++)
{
glTranslatef(0, -0.8, 0);
bezier(control_points_array, number_of_control_points,
number_of_bezier_points);
}
glColor3f(0, 1, 0); //Indian flag: green color code
for(int i=0; i<50; i++)
{
glTranslatef(0, -0.8, 0);
bezier(control_points_array, number_of_control_points,
number_of_bezier_points);
}
glPopMatrix();
glLineWidth(5);
glColor3f(0.7, 0.5,0.3); //pole colour
glBegin(GL_LINES);
glVertex2f(100,400);
glVertex2f(100,40);
glEnd();
glutPostRedisplay();
glutSwapBuffers();
}
void init()
{
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0,500,0,500);
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowPosition(0, 0);
glutInitWindowSize(500,500);
glutCreateWindow("Bezier Curve - updated");
 init();
glutDisplayFunc(display);
glutMainLoop();
}

OUTPUT:

9. Develop a menu driven program to fill the polygon using scan line
algorithm.
// 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; // our polygon has 4 lines - so 8 coordinates
void edgedetect(float x1, float y1, float x2, float y2, int *left_edge, int
*right_edge)
{
float x_slope, x, temp;
int i;
if ((y2-y1)<0) // decide where to start
{
temp = y1;
y1 = y2;
 y2 = temp;
temp = x1;
x1 = x2;
x2 = temp;
}
if ((y2-y1)!=0)
x_slope = (x2 - x1) / (y2 - y1);
else
x_slope = x2 - x1;
x = x1;
for (i = y1; i <= y2; i++)
{
if (x < left_edge[i])
left_edge[i] = x;
if (x > right_edge[i])
right_edge[i] = x;
x = x + x_slope;
}
}
void draw_pixel (int x, int y)
{
glColor3f (1, 1, 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 left_edge[500], right_edge[500];
int i, y;
for (i = 0; i <= 500; i++)
{
left_edge [i] = 500;
right_edge [i] = 0;
}
edgedetect (x1, y1, x2, y2, left_edge, right_edge);
edgedetect (x2, y2, x3, y3, left_edge, right_edge);
edgedetect (x3, y3, x4, y4, left_edge, right_edge);
edgedetect (x4, y4, x1, y1, left_edge, right_edge);
for (y = 0; y <= 500; y++)
{
if (left_edge[y] <= right_edge[y])
{
for (i = left_edge[y]; i <= right_edge[y]; i++)
{
draw_pixel (i, y);
glFlush ();
}
}
}
}
void display()
{
x1 = 200, y1 = 200;
 x2 = 100, y2 = 300;
x3 = 200, y3 = 400;
x4 = 300, y4 = 300;
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0, 0, 1);
glBegin (GL_LINE_LOOP);
glVertex2f (x1, y1);
glVertex2f (x2, y2);
glVertex2f (x3, y3);
glVertex2f (x4, y4);
glEnd ();
scanfill (x1, y1, x2, y2, x3, y3, x4, y4);
}
void init()
{
glClearColor (1, 1, 1, 1);
gluOrtho2D (0, 499, 0, 499);
}
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");
init ();
glutDisplayFunc (display);
glutMainLoop ();
}

OUTPUT: