H331: Computer Graphics

Philip Dutré

Department of Computer Science

Wednesday, February 25

Today

Graphics programming

Book: Chapters 3, 4, 10

Announcements

Practicum 1 available– http://www.cs.kuleuven.ac.be/~graphics/H331/

Practicum 1 & 2: 7 points / 20– Best: 4– 2nd best: 3

Announcements SIGGRAPH Los Angeles August 8-12 http://www.siggraph.org/s2004/ Student volunteers! (Deadline:

February 25)

3D 2D

How to transform the 3D world to a 2D image?

3 aspects:– Objects: exist in space, independent of viewer– Viewer: camera, human, ….– Lights: shading, shadows, …

3D 2D

Objects (points, lines, polygons)Described by verticesLights (e-m spectrum)

(350-780 nm)

Viewer = camera

Pinhole camera

dz

yy

dz

xx

dz

p

p

p

/

/

Synthetic CameraProjection plane in front of center-of-projection:

dz

yy

dz

xx

dz

p

p

p

/

/

Synthetic CameraClipping: looking through a window

3D APIs

Synthetic camera is basis of 3D API– OpenGL, PHIGS, Direct 3D, VRML,

JAVA-3D, GKS, … We need to functions to specify:

– Objects: vertices that describe points, lines, polygons

– Camera: position, orientation, width, height– Light sources: position, color– Materials: reflection characteristics

3D APIs

glBegin(GL_POLYGON)glVertex3f(0.0, 0.0, 0.0);glVertex3f(0.0, 1.0, 0.0);glVertex3f(0.0, 0.0, 0.1);

glEnd();

…

gluLookAt(posx, posy, posz, atx, aty, atz, …);glPerspective(view_angle, …);

3D APIs

3D API performs modeling + rendering But … modeling can also be done ‘off-line’

– Write model to file

– Read file in 3D API and transform to 3D API modeling commands

RenderMan (Pixar)– Prepares off-line model for rendering

– Rendering takes ‘converted’ model

Graphics hardware

3D ‘world’ coordinates 2D ‘screen’ coordinates

Graphics hardware

3D vertex 2D pixel

Transform to camera coordinate system

Clip away things we don’t see in the camera window

3D coordinates 2D coordinates

Transform to pixels in the frame buffer

How to draw things?

Given: window on the screen Graphics API (e.g. OpenGL) has something

of the form:plotPixel(int x, int y)

How to draw things? plotPixel(289,190) plotPixel(320,128) plotPixel(239,67) plotPixel(194,101) plotPixel(129,83) plotPixel(75,73) plotPixel(74,74) plotPixel(20,10)

window

How to draw things?

window

screen

x

y

plotPixel(x,y)

X

Y

Why is this impractical?

Coordinates are expressed in screen space, but objects live in (3D) world space

Resizing window implies we have to change coordinates of objects to be drawn

We want to make a separation between:– values to describe geometrical objects– values needed to draw these objects on the

screen

How to draw things?

Specify points to OpenGL

glVertex*( … )

glVertex2i( … ) glVertex3i( … )glVertex2f( … ) glVErtex3f( … )

glBegin(GL_LINES);glVertex2f(x1, y1);glVertex2f(x2, y2);

glEnd();

glBegin(GL_POINTS);glVertex2f(x1, y1);glVertex2f(x2, y2);

glEnd();

How to draw things?

For (k=0; k<500; k++) {…// compute point kx = …;y = …;glBegin(GL_POINTS);glVertex2f(x, y);glEnd();

}

glFlush();

More about OpenGL…

OpenGl = set of libraries

More about OpenGL…

OpenGl supports geometric primitives and raster primitives

Geometric Primitives in OpenGL

Geometric primitives are defined by vertices– GL_POINTS– GL_LINES– GL_LINE_STRIP, GL_LINE_LOOP

Geometric Primitives in OpenGL

Closed loops = polygons Polygons: describe surfaces

Geometric Primitives in OpenGL

GL_POLYGON, GL_QUADS, …

Viewing in OpenGL

Scene is independent of camera gluOrtho2D(left, tight, bottom, top)

3D primitives

void triangle(point3 a, point3 b, point3 c) {glBegin(GL_POLYGON)

glVertex3fv(a);glVertex3fv(b);glVertex3fv(c);

glEnd();}

void tetrahedron () {glColor3f(1.0,0.0,0.0);triangle(v[0], v[1], v[2]);…

}

3D primitives

Hidden surfaces? Z-buffer

– Keep depth for each pixel

Initialize!– glClear(GL_COLOR_BUFFER_BIT);– glClear(GL_DEPTH_BUFFER_BIT);– …– glFlush();

World window & viewport

World window:specifies what part of the world should be drawn

Viewport:rectangular area in the screen window in which we will draw

World window & viewport

window

viewport

screen window

world window

Mapping: world window to viewport

window

Wl Wr

Wb

Wt

Vl Vr

Vb

Vt

Mapping: world window to viewport

window

Wl Wr

Wb

Wt

Vl Vr

Vb

Vt

Maintain proportions!

Mapping: world window to viewport

Wl Wr Vl Vr

x sx

)( WlWlWr

VlVrVlx

WlWr

VlVrsx

)( WbWbWt

VbVtVby

WbWt

VbVtsy

Mapping: world window to viewport

If x = Wl, then sx = Vl If x = Wr, then sx = Vr If x = f*(Wr-Wl), then sx = f*(Vr-Vl) If x < Wl, then sx < Vl If x > Wr, then sx > Vr

… also for y and sy

World window

Pick size automatically

world window

Automatic setting to preserve aspect ratio & center

window

W

H

Aspect ratio R

R > W/H

Automatic setting to preserve aspect ratio & center

window

Aspect ratio R

R < W/H

W

H

Clipping

Lines outside of world window are not to be drawn.

Graphics API clips them automatically.

But clipping is a general tool in graphics!

Clipping

Clipping

clipSegment(…): Return 1 if line within

window Return 0 if line outside

window If line partially inside,

partially outside: clip and return 1

A B

C

DE

Cohen-Sutherland clipping

Trivial accept/reject test!

Trivial rejectTrivial accept

Cohen-Sutherland region outcodes

4 bits:

TTFF

Left of window?Above window?Right of window?Below window?

Cohen-Sutherland region outcodes

Trivial accept: both endpoints are FFFF

Trivial reject: both endpoints have T in the same position

FFFF

TTFF

TFFF

FTTFFTFF

TFFT FFTT

FFTF

FFFT

Cohen-Sutherland: chopping

If segment is neither trivial accept or reject:– Clip against edges of window in turn

Cohen-Sutherland: chopping

Trivial accept

Cohen-Sutherland line clipper

int clipSegment (point p1, point p2)Do {

If (trivial accept) return (1)

If (trivial reject) return (0)

If (p1 is outside)if (p1 is left) chop left

else if (p1 is right) chop right

…

If (p2 is outside)…

} while (1)

Raster Graphics

What is an image?– Array of pixels

How to convert lines and polygons to pixels?– Continuous to discrete– Scan conversion

Displays

Early displays were vector displays– Electron beam traces lines– Image is sequence of endpoints– Wireframes, no solid fills

Displays

Raster displays– Electron beam traces regular pattern– Image is 2D array of pixels– Fast, but discretisation errors

Every pixel has b bits for color– B&W: 1 bit– Basic colors: 8, 15, 16, 24 bits– High-end: 96 bits

Displays

Displays and Framebuffers

Raster image is stored in memory as a 2D array of pixels = framebuffer

The color of each pixel determines the intensity of the beam

Video hardware scans framebuffer at 60Hz– Changes in framebuffer show on screen =>

double buffering– Switch buffers when one buffer is finished

Displays and Framebuffers

Video controller

Framebuffer(double buffer) display

Graphics software (rasterizer)

Rasterizer: Example

How to rasterize a line, once its 2D screen coordinates are known?

Given: endpoints of a line What pixels to draw?

Scan converting lines

Scan converting lines

find the pixels closest to the ideal line

assume slope m 1: illuminate one pixel per column, work incrementally

if m1 : x y.

hxmy

xx

yy

x

ym

ii

12

12

Scan converting linesy = y1;for (i = x1; i<=x2; i++) {

plotPixel(i, round(y));y += m;

}

Scan converting lines

Inefficient: compute round(y) for each integer x and floating point addition

Bresenham’s algorithm: only integer arithmetic

Standard for most HW+SW rasterizers

Scan converting lines

What’s the next pixel? Decision variable

d = a – bif (d>0) …else …

Or d = x(a-b)

Scan converting lines

dk+1 = dk – 2y or

dk+1 = dk – 2(y-x)