1 / 60

# H331: Computer Graphics - PowerPoint PPT Presentation

H331: Computer Graphics. Philip Dutré Department of Computer Science Wednesday, February 19. Today. Graphics programming Book: Chapters 3, 4, 10. Announcements. Pre-practicum available http://www.cs.kuleuven.ac.be/~graphics/H331/ SIGGRAPH student volunteers!

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

H331: Computer Graphics

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

#### Presentation Transcript

Philip Dutré

Department of Computer Science

Wednesday, February 19

• Graphics programming

• Book: Chapters 3, 4, 10

• Pre-practicum available

• http://www.cs.kuleuven.ac.be/~graphics/H331/

• SIGGRAPH student volunteers!

• SIGGRAPH San Diego July 27 – 31

• http://www.siggraph.org/s2003/

• Student volunteers! (Deadline: February 26)

3D  2D

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

• 3 aspects:

• Objects: exist in space, independent of viewer

• Viewer: camera, human, ….

3D  2D

Objects (points, lines, polygons)

Described by vertices

Lights (e-m spectrum)

(350-780 nm)

Viewer = camera

Projection plane in front of center-of-projection:

Clipping: looking through a window

• 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

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 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

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

• 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

• Little algorithm:

• Pick 3 points V0, V1, V2

• P0 = random point

• Pk = midpoint between Pk-1 and random(V0, V1, V2)

• Plot all Pk

• 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

y

X

x

How to draw things?

plotPixel(x,y)

screen

• 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

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

For (k=0; k<500; k++) {

// compute point k

x = …;

y = …;

glBegin(GL_POINTS);

glVertex2f(x, y);

glEnd();

}

glFlush();

• OpenGl = set of libraries

• OpenGl supports geometric primitives and raster primitives

• Geometric primitives are defined by vertices

• GL_POINTS

• GL_LINES

• GL_LINE_STRIP, GL_LINE_LOOP

• Closed loops = polygons

• Polygons: describe surfaces

• Scene is independent of camera

• gluOrtho2D(left, tight, bottom, top)

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

}

• Hidden surfaces?

• Z-buffer

• Keep depth for each pixel

• Initialize!

• glClear(GL_COLOR_BUFFER_BIT);

• glClear(GL_DEPTH_BUFFER_BIT);

• glFlush();

• 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

screen window

world window

viewport

Mapping: world window to viewport

Vt

Wt

Wb

Vb

Vl

Vr

Wl

Wr

Mapping: world window to viewport

Maintain proportions!

Vt

Wt

Wb

Vb

Vl

Vr

Wl

Wr

x

sx

Vl

Vr

Wl

Wr

• 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

• Pick size automatically

world window

Automatic setting to preserve aspect ratio & center

H

Aspect ratio R

W

R > W/H

Automatic setting to preserve aspect ratio & center

H

Aspect ratio R

W

R < W/H

• Lines outside of world window are not to be drawn.

• Graphics API clips them automatically.

• But clipping is a general tool in graphics!

A

B

clipSegment(…):

• Return 1 if line within window

• Return 0 if line outside window

• If line partially inside, partially outside: clip and return 1

C

E

D

• Trivial accept/reject test!

Trivial reject

Trivial accept

• 4 bits:

TTFF

Left of window?

Above window?

Right of window?

Below window?

• Trivial accept: both endpoints are FFFF

• Trivial reject: both endpoints have T in the same position

TTFF

FTFF

FTTF

TFFF

FFFF

FFTF

TFFT

FFFT

FFTT

• If segment is neither trivial accept or reject:

• Clip against edges of window in turn

Trivial accept

• 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)

• What is an image?

• Array of pixels

• How to convert lines and polygons to pixels?

• Continuous to discrete

• Scan conversion

• Early displays were vector displays

• Electron beam traces lines

• Image is sequence of endpoints

• Wireframes, no solid fills

• 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

• 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

Framebuffer

(double buffer)

display

Video controller

Graphics software (rasterizer)

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

• Given: endpoints of a line

• What pixels to draw?

• find the pixels closest to the ideal line

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

• if m1 : x  y.

y = y1;

for (i = x1; i<=x2; i++) {

plotPixel(i, round(y));

y += m;

}

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

• Bresenham’s algorithm: only integer arithmetic

• Standard for most HW+SW rasterizers

• What’s the next pixel?

• Decision variabled = a – bif (d>0) …else …

• Or d = Dx(a-b)

• dk+1 = dk – 2Dy ordk+1 = dk – 2(Dy-Dx)