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();
}
Enter the password to open this PDF file:
File name:
-
File size:
-
Title:
-
Author:
-
Subject:
-
Keywords:
-
Creation Date:
-
Modification Date:
-
Creator:
-
PDF Producer:
-
PDF Version:
-
Page Count:
-
Preparing document for printing…
0%
Σχόλια 0
Συνδεθείτε για να κοινοποιήσετε σχόλιο