1. Course code:10CS65 | Computer Graphics and Visualization
Unit-2
The OpenGL
Engineered for Tomorrow
Prepared by : Ms Sandhya, Ms Preeti & Ms Hymavathi
Department : Computer Science and Engineering
Date : dd.mm.yyyy

2. UNIT - 2 THE OPENGL The OpenGL API Primitives and attributes Color
Viewing
Control functions
The Gasket program
Polygons and recursion
The three-dimensional gasket
Plotting implicit functions.

3. OpenGL API Graphics package as a BLACK BOX
Functionality can be grouped to:
primitive functions – low level primitives (points, pixels etc.)
primitives API – what should be displayed attribute functions are – how should be displayed –lines, points, polygons etc.
Synthetic camera must describe how to create an image – viewing functions (camera properties – lens, viewing field, several cameras, stereoscopic views etc.)

4. OpenGL API
geometric transformation – scaling, rotation, translation, sheering etc. and use of transformation matrix. This forms the main advantage as the geometric engine can be used for substantial speed up.
input functions – allow interaction with graphics primitives or objects; functions for communication with a keyboard, mouse, data tablets etc.
control functions – initialization, errors handling etc. in multiprocessor multi-window & network environment
Query functions – helps query information about the properties of the particular implementation.

5. OpenGL Interface
OpenGL function names begin with gl and are stored in library referred as GL
Libraries:
GLU - graphics utility library – uses only GL primitives but contains code for common objects like spheres etc. – available in all OpenGL implementations
GLUT – GL Utility Toolkit / provides minimum functionality to be expected from any modern windowing system
others libraries are called from OpenGL libraries – but indirectly, hidden from the user.

6. OpenGL Interface
Picture shows the organization of the libraries for the X-Windows, similarly for Microsoft Windows
Strings like GL_FILL, GL_POINTS are defined in header ( .h) files – in most implementation #include <GL/glut.h> or #include <glut.h> includes glut.h, gl.h, glu.h

7. OpenGL Primitives & Attributes
should be minimal & orthogonal (capability that cannot be obtained from others)
more advanced to offer complex functions to a user – GLU
line segments and polylines can form the edges of objects
glBegin(type)
glVertex*(...);
glEnd ( );

8. OpenGL - Polygons Polygons have borders and interior
Can be displayed rapidly and approximate curved surfaces
Must be simple, convex and flat
Simple and non-simple polygon
Filled objects
Methods of displaying polygons

9. OpenGL - Polygons
Convex polygon – all points on the line segment between any two points inside of the object, are inside of the polygon
Flat polygon – polygon can lie on a plane in 3D in general
Tests on planarity, simplicity, flatness are not performed
Convexity in 2D
Convexity in 3D

10. OpenGL – Polygons Types
several OpenGL types were defined GL_*
polygon edge itself has no width
if polygon edges are to be drawn and polygon filled – it must be drawn twice with different modes

11. OpenGL – Text
Graphical output in applications requires text output
Fonts – Times, Helvetica, Computer Modern etc.
Forms – stroke vs. raster text
stroke – constructed as other graphics primitives – points etc. – the standard PostScript fonts defined by polynomial curves – easy to enlarge
raster – fast; using bit-block-transfer (bitblt) operations

12. OpenGL – Curved Objects
Curved primitives (like circles, spheres, curves and surfaces etc.) are not directly supported – must be approximated by a mesh polygons – a tessellation – at the rendering stage or within the user program
GLU can be used to approximate common curved surfaces
Advanced OpenGL functions can be used to work with parametric curves and surfaces

13. OpenGL – Attributes Distinction between
what the type of a primitive is
how the primitive is displayed
A red solid line and green dashed line are the the same geometric type, but displayed differently due to attributes

14. OpenGL – Color
Color is one of the most interesting aspects of both human perception and computer graphics
Light is a part of electromagnetic spectrum 350 – 780 nm
Color C = rR + gG + bB
r,g,b are tristimulus values
assumption of three-color theory if two colors produce the same tristimulus values then they are visually indistinguishable

15. OpenGL – Color Color space can be represented as RGB cube
Gray levels are represented by the Black-White line segment

16. OpenGL – Color Additive vs. subtractive color system
RGB vs. CMY (K) color systems
Range of colors that can be produced on the given system is called color gamut

17. OpenGL – RGB Color Additive RGB primary color system is used
8 bits/pixel for each channel R,G,B 224 possible colors
1024 x 1024 output resolution
3MB RAM for graphics purposes
RGBA system (Alpha channel) – for transparency/opacity
glColor3f(1.0, 0.0, 0.0)
glClearColor(1.0, 1.0, 1.0, 1.0) – screen solid and white

18. OpenGL – RGB Color – Indexed Color
Color palette enables to change in the whole image
Limit of the frame buffer to k bits per pixel
2k –1 colors can be displayed from a palette of 23m of colors table of 2k x 3m is to be specified
for k=m=8 – a common configuration – 256 colors out of 16M. 256 entries constitute the user’s color palette

19. OpenGL – RGB Color – Indexed Color
In color-index mode – present color is selected by glIndexi(element) – selects particular color out of the table
System can have just one common table or multiple tables for different windows – GLUT allows that
glutSetColor(int color, GLfloat red, GLfloat blue, GLfloat green)
- we will work directly with RGB colors (not indexed) in the next

20. Setting of Color Attributes
For the Sierpinski gasket program we need to set:
clear color glClearColor(1.0, 1.0, 1.0, 1.0);
rendering color for points – set to RED glColor3f(1.0, 0.0, 0.0);
set point size – let us use 2 pixels size glPointSize(2.0); /* size is in pixels not in [mm] */
These attributes will be valid for all the time if not changed explicitly.

21. Viewing
In the synthetic camera concept the object specification is completely independent from
the camera specification
lights properties and positions used
material properties as well
We used some default settings for those expecting that objects are placed “in the right position”, sufficiently far from the camera etc.
We will concentrate on
2D viewing,
orthographic projection,
matrix mode application

22. 2D Viewing Clipping rectangle or viewing rectangle Objects
Objects before and after 2D clipping
Clipping rectangle or viewing rectangle
Objects
outside are clipped out and are not displayed
partially inside – only parts inside are displayed

23. 2D Viewing – Orthographic View
Viewing rectangle is at z = 0 with corners (-1.0,-1.0) & (1.0, 1.0)
Implicit viewing volume in OpenGL is 2 x 2 x 2 cube – center in the origin

24. 2D Viewing – Orthographic View
void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far)
void gluOrtho2D(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top) /* near=-1, far=1*/

25. 2D Viewing - Matrix Mode
Pipeline of the graphics system utilizes matrices multiplications for geometric transformations.
Two the most important matrices:
model-view
projection
Setting matrix mode ( it is the status definition of the system):
glMatrixMode(GL_PROJECTION); /* change to PROJECTION status */
glLoadIdentity( ); /* sets the matrix to the IDENTITY matrix */
gluOrtho2D(0.0, 500.0, 0.0, 500.0); /* sets window to 500 x 500 image */
glMatrixMode(GL_MODELVIEW); /* return back to the MODEL-VIEW state – highly recommended */

26. Control Functions
Minimal interaction between the program and the particular OS must be used (X-Windows - UNIX, Windows)
GLUT library provides minimal & simple interface between API and particular OS (full functionality for interaction between a program and OS is not a part of this course)
Programs using GLUT interface should run under multiple window system.

27. Interaction with the Window System
Window or screen window – rectangular area of a display
Window system – refers to X-Windows or MS Windows
The origin – not always lower-left corner – OpenGL style (some have orientation: top to bottom, left to right as TV sets or position information returned from input devices like mouse)
glutInit(int *argcp, char *argv) – enables to pass command-line arguments as in the standard C main function
glutCreateWindow(char *title) – creates a window with the name specified in the string title with default values (size, position etc.)

28. Interaction with the Window System
BEFORE creating the window GLUT functions can be used to specify properties:
glutDisplayMode(GLUT_RGB|GLUT_DEPTH|GLUT_DOUBLE);
/* parameters or-ed and stored in the argument to glutInitDisplayMode */
glutWindowSize(480, 640);
glutWindowPosition(0 , 0);
specifies the windows 480 x 640 in the top-left corner of the display
GLUT_RGB x GLUT_INDEX – type of color system to be used
GLUT_DEPTH – a depth buffer for hidden-line removal
GLUT_DOUBLE x GLUT_SINGLE – double x single buffering
Implicit options: RGB color, no hidden-line removal, single buffer

29. Aspect Ratio and Viewports
Aspect ratio – the ratio of the rectangle’s width and height
If different in glOrtho and glutInitWindowSize – undesirable side effects
Caused by the independence of object, viewing parameters and workstation window specifications
Concept of a VIEWPORT

30. Aspect Ratio and Viewports
void glViewport(GLint x, GLint y, GLsizei w, GLsizei h)
The viewport is part of the state – when changed between rendering objects or redisplay – different window-viewport transformations used to make the scene.

31. Functions main, display & myinit
Program = simple initialization code + sequence with OpenGL
Problems:
generic to all graphics systems
interaction with underlying window system
in immediate-mode graphics a primitive is rendered to the screen immediately. The application ends and the screen is cleaned before anything can be seen - solution sleep(enough_time) better solution void glutMainLoop( void ); execution causes the program to begin an event-processing loop – until program is not terminated through the “kill” key

32. Functions main, display & myinit
Graphics are sent to the scene through a function called the display callback that is specified through the GLUT function as
void glutDisplayFunction (void (*func)(void))
func is the function name that will be called whenever the windowing system determines that the OpenGL windows needs to be redisplayed (created, moved, resized, made visible etc.)
This function is called also when the window is created
For non-interactive use the code can be specified in this function

33. Functions main, display & myinit
#include <GL/glut.h> /* compiler should include gl.h & glu.h */ void main (int argc, char **argv) /* the main function */ { glutInit(&argc,argv); glutDisplayMode(GLUT_SINGLE | GLUT_RGB); glutInitWindowSize (500,500); glutInitWindowPosition(0,0); glutCreateWindow(“simple OpenGL example”); glutDisplayFunc(display); myinit( ); glutMainLoop( ); } /* should work for all non-interactive programs */

34. The Gasket Program
void myinit (void) { /* attributes */ glClearColor(1.0, 1.0, 1.0, 1.0); /* white background */ glColor3f(1.0, 0.0, 0.0); /* draw in red */ /* set up viewing */ glMatrixMode(GL_PROJECTION); gluLoadIdentity ( ); gluOrtho2D(0.0, 500.0,0.0, 500.0); glMatrixMode(GL_MODELVIEW); }

35. Functions main, display & myinit
void display(void) { typedef GLfloat point2 [2]; /* defines a point as 2D array */ point2 vertices[3]= { {0.0,0.0}, { }, {500.0,0.0}}; /*triangle*/ int i, j, k; int rand( ); {* standard random number generator */ point2 p = {75.0, 50.0}; /* set to any initial point */ glClear(GL_COLOR_BUFFER_BIT); /* clear the window */ for (k=0; k<5000; k++) { j = rand ( )%3; /* pick a random vertex from 0, 1, 2 */ /* compute a point halfway between vertex and old point */ p[0] = (p[0]+vertices[ j ][0])/2; p[1] = (p[1]+vertices[ j ][1])/2; /* display the new point */ glBegin(GL_points); glVertex2fv(p); glEnd( ); } glFlush(); /* points are to be displayed as soon as possible */

36. Polygons and Recursion
A similar approach – a triangle is split to triangles recursively
original triangle given by the array point2 v[3];
void triangle (point2 a, point2 b, point2 c)
{ glBegin(GL_TRIANGLES);
glVertex2fv(a); glVertex2fv(b); glVertex2fv(c);
glEnd( ); }
mid-points computations
for (j=0; j<2; j++) m[0][j]=(v[0][j]+ v[1][j])/2.0;
for (j=0; j<2; j++) m[1][j]=(v[0][j]+ v[2][j])/2.0;
for (j=0; j<2; j++) m[2][j]=(v[1][j]+ v[2][j])/2.0;

37. Sierpinski Gasket Program - triangles
Modification for recursive triangles void divide_triangle(point2 a, point2 b, point2 c, int k) { point2 ab, ac, bc; int j; if ( k>0) { /* compute midpoints */ for (j=0; j<2; j++) ab[j]=(a[j]+ b[j])/2.0; for (j=0; j<2; j++) ac[j]=(a[j]+ c[j])/2.0; for (j=0; j<2; j++) bc[j]=(b[j]+ c[j])/2.0; /* subdivide all but inner triangle */ divide_triangle(a, ab, ac, k-1); divide_triangle(c, ac, bc, k-1); divide_triangle(b, bc, ab, k-1); } else triangle(a,b,c); /*draw a triangle at end of recursion */ }

38. Sierpinski Gasket Program - triangles
void display(void) { glClear(GL_COLOR_BUFFER_BIT); divide_triangle(v[0], v[1], v[2], n); /* n determines No of subdivision steps */ glFlush( ); } Note: there is no convenient way to pass variables to OpenGL functions and callback other than through global parameters

39. 3D Sierpinski Gasket Program
Now we expand 2D to 3D case
data type definition: typedef GLfloat point3[3];
int n; /* global variable */
tetrahedron specifications: point3 vertices[4] = { {0.0,0.0,0.0}, {250.0,500.0,100.0}, {500.0,250.0,250.0}, {250.0,100.0,250.0}}; point3 p= {250.0,50.0,250.0};
function glPoints3fv is used to define points
different colors used for points to distinguish them
drawing polygons – visibility should be solved

40. 3D Sierpinski Gasket Program
void triangle (point3 a, point3 b, point3 c) { point3 norm; cross(a, b, c, norm); /* computes the normal vector of the triangle */ glBegin(GL_POLYGON); glNormal3fv(a); glVertex3fv(a); glVertex3fv(b); glVertex3fv(c); glEnd( ); } /* normal computation - using cross product */

41. 3D Sierpinski Gasket Program
void divide_triangle(point3 a, point3 b, point3 c, int k); { point3 v1, v2, v3; int j; if ( k>0) { /* compute midpoints */ for (j=0; j<3; j++) v1[ j]=(a[ j]+ b[ j])/2.0; for (j=0; j<3; j++) v2[ j]=(a[ j]+ c[ j])/2.0; for (j=0; j<3; j++) v3[ j]=(b[ j]+ c[ j])/2.0; divide_triangle(a, v1, v2, k-1); divide_triangle(c, v2, v3, k-1); divide_triangle(b, v3, v1, k-1); } else triangle(a,b,c); /*draw a triangle at end of recursion */ }

42. 3D Sierpinski Gasket Program
void tetrahedron (int m); { /* apply triangle subdivision to faces of tetrahedron */ glColor3f(1.0, 0.0, 0.0); divide_triangle (v[0], v[1], v[2], m); glColor3f(0.0, 1.0, 0.0); divide_triangle (v[3], v[2], v[1], m); glColor3f(0.0, 0.0, 1.0); divide_triangle (v[0], v[3], v[1], m); glColor3f(0.0, 0.0, 0.0); divide_triangle (v[0], v[2], v[3], m); }

43. 3D Sierpinski Gasket Program
void display ( ); { glClear(GL_COLOR_BUFFER_BIT | GLDEPTH_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, (GLfloat)h/(GLfloat)w, (GLfloat)h/(GLfloat)w, -10.0, 10.0); else glOrtho(-2.0,2.0, (GLfloat)w/(GLfloat)h, (GLfloat)w/(GLfloat)h, -10.0, 10.0); glMatrixMode(GL_MODELVIEW); glutPostRedisplay ( );

44. 3D Sierpinski Gasket Program
void main ( int argc, char **argv); { n = atoi(argv[1]); /* parameter on the command line */ /* n is a global variable */ glutInit ( int argc, char **argv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH); glutInitWindowSize (500,500); glutCreateWindow (“3D Gasket”); glutReshapeFunc(myReshape); glutDisplayFunc(display); glEnable(GL_DEPTH_TEST); glClearColor (1.0, 1.0, 1.0, 1.0); glutMainLoop( ); }

45. 3D Sierpinski Gasket Program
Triangles are drawn in order of generation (given by the algorithm) not according to their geometric position
Hidden surface removal is enabled by setting
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
and enable that by (using z-buffer algorithm)
glEnable(GL_DEPTH_TEST);

46. Conclusion
The structure of the OpenGL API and interaction with OS have been explained
you learnt how to write non-interactive complex OpenGL programs using non-trivial features, especially how to:
redraw the windows if any change
use window-viewport transformation
handle orthographic projection
use OpenGL in recursive environment
draw primitives that are filled and
solve the visibility of objects
Some features will be explored in the following parts in detail