# ch02

Software and s/w Development

Dec 13, 2013 (4 years and 3 months ago)

100 views

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

A simple but interesting example

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

OpenGL Program for

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

#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

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

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

#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

Groups of 3 or 4 points are grouped as

Special Polygons

GL_TRIANGLE_STRIPE,
GL_TRIANGEL_FAN

Contiguous stripe or fan of triangles or

Drawing a Sphere

Draw great circles

Fill between latitudes

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.

-
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

..
\
code
\

2
-
d

..
\
code
\

3
-
d with colors

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();

}