ch02

CAP 4703

Computer Graphic
Methods

Prof. Roy Levow

Lecture 2

2
-
Dimensional Drawing

with OpenGL


Two
-
dimensional objects are a
special case of three
-
dimensional
figures


The drawing is limited (by the
programmer) to a plane


Viewing is normally an orthogonal
view, perpendicular to the drawing
plane

Sierpinski Gasket


A simple but interesting example


Start with any triangle

1.
Pick an internal point at random

2.
Pick a vertex at random

3.
Find the midpoint between 1 and 2

4.
Display this point

5.
Replace initial point with this one

6.
Repeat from step 2


Sierpinski Gasket Construction


OpenGL Program for

Sierpinski Gasket

main()

{


initialize_the_system();


for (some_number_of_points)


{



pt = generate_a_point();



display_the_point(pt);


}


cleanup();


return 0;

}

Points or Vertices


Points are represented by vectors
with an entry for each coordinate



p = (x, y, z) in 3 dimensions



p = (x, y, 0) gives 2 dimensions by
always setting z to 0


OpenGL allows up to 4 dimensions


Internal representation is always the
same

OpenGL Vertices


Vertex creating functions have
general name



glVertex*



The suffix is 2 or 3 characters

–
Number of dimensions: 2, 3, or 4

–
Data type: i = integer, f = float,

d = double

–
Optional v if pointer


Underlying Representation


OpenGL data types are defined in
header file


#define GLfloat float

so a header might look like


glVertex2i(GLint xi, GLint yi)

or


glVertex3f(GLfloat xf, GLfloat yf,





GLfloat zf)

Representation (cont.)


For the vector form


GLfloat vertex[3];

and then use


glVertex3fv(vertex);

Defining Geometric Objects


Objects are defined by collections of
point constructors bounded by calls
to glBegin and glEnd


A line is defined by


glBegin(GL_LINES);



glVertex2f(x1, y1);



glVertex2f(x2, y2);


glEnd();

OpenGL Code for


Sierpinski Gasket


See p. 41 of text



Code leaves many open questions
by using default values

1.
colors

2.
image position

3.
size

4.
clipping?

5.
persistence


A Resulting Image


Coordinate System


Early systems depended on specific
device mapping


Device
-
independent graphics broke
link


Use application or problem
coordinate system to define image


Use device coordinates, raster
coordinates, screen coordinates for
device

Coordinates


Application coordinates can be
integer or real and multi
-
dimensional


Screen or raster coordinates are
always integer and essentially 2
-
dimensional


Graphics program maps application
coordinates onto device coordinates

App to Device Mapping


Classes for OpenGL Functions

1.
Primitives
–

draw points, line
segments, polygons, text, curves,
surfaces

2.
Attributes
–

specify display
characteristics of objects: color, fill,
line width, font

3.
Viewing
–

determine aspects of
view: position and angle of camera,
view port size, …

Function Classes (cont)

4.
Transformations
–

change
appearance or characteristics of
objects: rotate, scale, translate

5.
Input
–

handle keyboard, mouse,
etc.

6.
Control
–

communicate with
window system

7.
Inquiry
–

get display information:
size, raster value, …


OpenGL Interface


Graphics Utility Interface (GLU)

–
Creates common objects like spheres


GL Utility Toolkit (GLUT)

–
Provides generic interface to window
system


GLX for Unix/Linux and


wgl for Microsoft Windows

–
provide low
-
level glue to window system

Library Organization


Using Libraries


Header files

–
#include <GL/glut.h>

–
#include <GL/gl.h>

–
#include <GL/glu.h>


On some systems the GL/ is not used

Primitives


OpenGL supports both geometric
primitives and raster primitives

Geometric Primitives


Points = GL_POINTS

–
vertex displayed with size >= 1 pixel


Line segments = GL_LINES

–
defined by pairs of vertices as endpoints
of segments


Polygons = GL_LINE_STRIPE or
GL_LINE_LOOP

–
Loop is closed, stripe is not


Primitive Examples


Properties of Polygons


Defined by line loop border


Simple if no edges cross


Convex if every line

segment connecting pair

of points on

boundary or

inside lies

completely

inside

Polygon Types in OpenGL


Polygons are either filled regions
(default) or boundaries


Set with glPolygonMode


To get polygon with boundary must
draw twice, once as filled and once
as boundary or line loop

Special Polygons


GL_TRIANGLES, GL_QUADS

–
Groups of 3 or 4 points are grouped as
triangles or quadrilaterals

Special Polygons


GL_TRIANGLE_STRIPE,
GL_QUAD_STRIPE,
GL_TRIANGEL_FAN

–
Contiguous stripe or fan of triangles or
quadrilaterals

Drawing a Sphere


Draw great circles


Fill between latitudes

with quad strips


Fill caps with

triangle fans


Code on p.52

Text


May be raster
–

from bit map

–
Fast

–
Does not scale well

–
Poor in rotation other than 90
o


Vector
–

from drawn curves

–
Slow to draw

–
Scales, rotates, etc. well


Raster text

Color


The physiology of vision leads to 3
-
color theory


Any color can be produced by a
combination of red, green, and blue
at intensities that produce the same
response in the cones as the true
color


Colors in OpenGL


Colors are stored using 4 attributes,
RGBA


A = Alpha channel

–
Controls opacity or transparency


Color values can be integers in range
from 0 to max component value

–
0
–

255 for 24
-
bit color


Real numbers between 0.0 and 1.0

Colors in OpenGL (cont)


Colors are set with glColor* functions

–
* is two characters, nt


n = 3 or 4 color values


t = date type: i, f, etc.

Clearing Frame Buffer


To get predictable results a program
must first clear the frame buffer


glClearColor(1.0, 1.0, 1.0, 1.0)

–
sets color to white

Indexed Color


OpenGL also supports indexed color

–
Saves space when only a limited
number of distince colors are used


Indexed Color (cont)


Set color in table with



glutSetColor(int color, GLfloat red,





GLfloat blue, GLfloat green)


Access color in table with



glIndexi(element)

Viewing


Based on synthetic camera model


If nothing is specified, there are
default viewing parameters

–
Rarely used

–
Would force us to fit model world to
camera


Prefer flexibility of setting viewing
parameters

Two
-
Dimensional Viewing


Selected rectangle from 2
-
dimensional world is displayed


Called viewing rectangle or clipping
rectangle

Viewing Volume


2
-
dimensional viewing is special case
of 3
-
dimensional viewing

–
viewing volume


Default is


2 x 2 x 2


cube centered


at

(0,0,0)


Orthographic Projection


Projects point (x,y,z) onto (x,y,0)


View is perpendicular to plane x=0


Set viewing rectagle with


void glOrtho(GLdouble left,




GLdouble right,




GLdouble bottom,





GLdouble top)

Matrix Modes


Graphic pipelines perform matrix
transformations on images at each
stage


Most important matrices are

–
model
-
view

–
projection


State includes both

Manipulating Mode Matrices


Matrix mode operations operate on
matrix for currently selected mode

–
Model
-
view is default


Mode is set with

glMatrixMode(mode)

mode = GL_PROJECTION,
GL_MODELVIEW, etc.


Always return to model
-
view to
insure consistency

Control Functions


Depend on particular window system


GLUT provides standard set of basic
operations

–
We will consider only these

Window Control


Operations only on display window
for the program


Initialization
–

glutInit


Creation
–

glutCreateWindow


Display mode
–

glutInitDisplayMode

–
RGB or indexed

–
hidden
-
surface removal

–
singer or double buffering

Example Code


glutInit(&argc, argv);

glutInitDisplayMode(GLUT_DOUBLE
| GLUT_RGB | GLUT_DEPTH);

glutInitWindowSize(480, 480);

glutWindowPosition(0, 0);

glutCreateWindow(“sample");


Aspect Ratio and Viewports


Ratio of width to length is aspect
ratio


If aspect ratio of viewing rectangle
and window differ, image will be
stretched and distorted


Viewport defines region of screen in
which to display image

–
Can eliminate distortion

Distortion


Viewport


Set viewport with

void glViewport(GLint x, GLint y,





GLsizei w, GLsizei h)

GLUT Main Loop


If we simply run an OpenGL program
it will display the image and exit

–
may not allow time to see it

–
could sleep program to keep window
open but this is limited solution


GLUT provides controls to avoid this


Keep program running waiting for
event


void glutMainLoop(void)


Glut Display


To display an image, code a function
to create the image and have GLUT
call it


image drawing function takes no
arguments and returns no result

–
Any parameters must be passed
through global variables

void glutDisplayFunc(void (*func)(void))

Simple Main Program


#include <GL/glut.h>

void main(int argc, char **argv)

{


glutInit(&argc, argv);


glutInitDisplayMode




(GLUT_SINGLE | GLUT_RGB);


glutInitWindowSize(500, 500);


glutWindowPosition(0, 0);

Simple Main Program (cont)



glutCreateWindow(“My Image");


glutDisplayFunc(display);


myinit();


glutMainLoop();

}


Program Structure


Key components

–
initialization

–
display callback function

–
main



Gasket Program

..
\
code
\
gasket.c

–

2
-
d

..
\
code
\
gasket2.c

–

3
-
d with colors

../code/gasket3.c

–

3
-
d with polygons


Hidden Surface Removal


Z
-
buffer algorithm


Z coordinate determines depth


Point nearer camera obscures one
with greater depth


Steps

–
Init with GLUT_DEPTH

–
glEnable(GL_DEPTH_TEST


can also disable

–
clear before redrawing

Sample HSR Program

void display()

{


glClear(GL_COLOR_BUFFER_BIT |



GL_DEPTH_BUFFER_BIT)


tetrahedron(n)


glFlush();

}