ch02

parakeetincurableΛογισμικό & κατασκευή λογ/κού

13 Δεκ 2013 (πριν από 3 χρόνια και 5 μήνες)

73 εμφανίσεις

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

}