1

Computer Graphics

2

Computer Graphics involves display, manipulation and storage of pictures and experimental data for proper visualization using a computer.

Typical graphics system comprises of a host computer with support of fast processor, large memory, frame buffer and

• Display devices (color monitors),• Input devices (mouse, keyboard, joystick, touch screen, trackball)• Output devices (LCD panels, laser printers, color printers. Plotters etc.)• Interfacing devices such as, video I/O,TV interface etc.

Introduction

3

4

5

6

Classification of Computer Graphics by Object and Picture Type of Object

2D3DPictorial representationLine drawingGray scale imageColor imageLine drawing (or wire-frame)Line drawing, with various affects Shaded, color image with variouseffectsInteractive Graphics

7

Computer Graphics is about animation (films)

Major driving force now

8

Games are very important in Computer Graphics

9

Medical Imaging is another driving force

Much financial support

Promotes linking of graphics with video, scans, etc.

10

Computer Aided Design too

11

Scientific Visualisation

To view below and above our visual range

12

History

13

Ivan Sutherland (1963) - SKETCHPAD

• pop-up menus

• constraint-based drawing

• hierarchical modeling

14

Display hardware• vector displays

– 1963 – modified oscilloscope

– 1974 – Evans and Sutherland Picture System

• raster displays

– 1975 – Evans and Sutherland frame buffer

– 1980s – cheap frame buffers bit-mapped personal computers

– 1990s – liquid-crystal displays laptops

– 2000s – micro-mirror projectors digital cinema

• other

– stereo, head-mounted displays

– autostereoscopic displays

– tactile, haptic, sound

15

Input hardware• 2D

– light pen, tablet, mouse, joystick, track ball, touch panel, etc.

– 1970s & 80s - CCD analog image sensor + frame grabber

– 1990s & 2000’s - CMOS digital sensor + in-camera processing

[Nayar00]

high-X imaging (dynamic range, resolution, depth of field,…)

16

• negative film = 130:1 (7 stops)• paper prints = 46:1• [Debevec97] = 250,000:1 (18 stops)

17

Input hardware• 2D

– light pen, tablet, mouse, joystick, track ball, touch panel, etc.

– 1970s & 80s - CCD analog image sensor + frame grabber

– 1990s & 2000’s - CMOS digital sensor + in-camera processing high-X imaging (dynamic range, resolution, depth of field,…)

• 3D

– 3D trackers

– multiple cameras

– active rangefinders

• other

– data gloves

– voice

18

Rendering

• 1960s - the visibility problem– Roberts (1963), Appel (1967) - hidden-line algorithms– Warnock (1969), Watkins (1970) - hidden-surface

algorithms– Sutherland (1974) - visibility = sorting

19

• 1960s - the visibility problem

– Roberts (1963), Appel (1967) - hidden-line algorithms

– Warnock (1969), Watkins (1970) - hidden-surface algorithms

– Sutherland (1974) - visibility = sorting

• 1970s - raster graphics

– Gouraud (1971) - diffuse lighting

– Phong (1974) - specular lighting

– Blinn (1974) - curved surfaces, texture

– Catmull (1974) - Z-buffer hidden-surface algorithm

– Crow (1977) - anti-aliasing

20

• 1960s - the visibility problem– Roberts (1963), Appel (1967) - hidden-line algorithms– Warnock (1969), Watkins (1970) - hidden-surface algorithms– Sutherland (1974) - visibility = sorting

• 1970s - raster graphics– Gouraud (1971) - diffuse lighting– Phong (1974) - specular lighting– Blinn (1974) - curved surfaces, texture– Catmull (1974) - Z-buffer hidden-surface algorithm– Crow (1977) - anti-aliasing

21

• early 1980s - global illumination– Whitted (1980) - ray tracing– Goral, Torrance et al. (1984), Cohen (1985) -

radiosity– Kajiya (1986) - the rendering equation

22

• early 1980s - global illumination– Whitted (1980) - ray tracing– Goral, Torrance et al. (1984), Cohen (1985) - radiosity– Kajiya (1986) - the rendering equation

• late 1980s - photorealism– Cook (1984) - shade trees– Perlin (1985) - shading languages– Hanrahan and Lawson (1990) - RenderMan

23

• early 1990s - non-photorealistic rendering

– Drebin et al. (1988), Levoy (1988) - volume rendering– Haeberli (1990) - impressionistic paint programs– Salesin et al. (1994-) - automatic pen-and-ink

illustration– Meier (1996) - painterly rendering

24

• early 1990s - non-photorealistic rendering– Drebin et al. (1988), Levoy (1988) - volume rendering– Haeberli (1990) - impressionistic paint programs– Salesin et al. (1994-) - automatic pen-and-ink

illustration– Meier (1996) - painterly rendering

25

Basic raster graphics algorithms for drawing 2d primitives.

How do things end up on the screen?

26

System Bus

CPUDisplay

ProcessorSystem Memory

Display Processor Memory

Frame Buffer

Video Controller

MonitorMonitor

Architecture Of A Graphics System

27

Output Devices

• There are a range of output devices currently available:– Printers/plotters– Cathode ray tube displays– Plasma displays– LCD displays– 3 dimensional viewers– Virtual/augmented reality headsets

28

Basic Cathode Ray Tube (CRT)

• Fire an electron beam at a phosphor coated screen

29

Raster Scan Systems

Draw one line at a time

30

Colour CRT

• An electron gun for each colour – red, green and blue

31

Applying voltages to crossing pairs of conductors causes the gas (usually a mixture including neon) to break down into a glowing plasma of electrons and ions

Plasma-Panel Displays

32

Liquid Crystal Displays

• Light passing through the liquid crystal is twisted so it gets through the polarizer

• A voltage is applied using the crisscrossing conductors to stop the twisting and turn pixels off

33

Scan Conversion• A line segment in a scene is defined by

the coordinate positions of the line end-points

x

y

(2, 2)

(7, 5)

34

• But what happens when we try to draw this on a pixel based display?

• How do we choose which pixels to turn on?

35

• Considerations to keep in mind:– The line has to look good

• Avoid jaggies

– It has to be lightening fast!• How many lines need to be drawn in a typical

scene?• This is going to come back to bite us again and

again

36

Line Equations

• Let’s quickly review the equations involved in drawing lines

x

y

y0

yend

xendx0

Slope-intercept line equation:

bxmy where:

0

0

xx

yym

end

end

00 xmyb

37

• The slope of a line (m) is defined by its start and end coordinates

• The diagram below shows some examples of lines and their slopes

m = 0

m = -1/3

m = -1/2

m = -1

m = -2m = -4

m = ∞

m = 1/3

m = 1/2

m = 1

m = 2m = 4

m = 0

38

• Find corresponding y coordinate for each unit x coordinate

example:

x

y

(2, 2)

(7, 5)

2 7

2

5

39

1

2

3

4

5

0

1 2 3 4 5 60 7

40

x

y

(2, 2)

(7, 5)

2 3 4 5 6 7

2

5

5

3

27

25

m5

42

5

32 b

• First work out m and b:

• Now for each x value work out the y value:

5

32

5

43

5

3)3( y

5

13

5

44

5

3)4( y

5

43

5

45

5

3)5( y

5

24

5

46

5

3)6( y

41

Now just round off the results and turn on these pixels to draw our line

35

32)3( y

35

13)4( y

45

43)5( y

45

24)6( y

0 1 2 3 4 5 6 7 8

0

1

2

3

4

5

6

7

42

However, this approach is just way too slow

In particular look out for:– The equation y = mx + b requires the multiplication of m by x– Rounding off the resulting y coordinates

We need a faster solution

In the previous example we chose to solve the parametric line equation to give us the y coordinate for each unit x coordinate

What if we had done it the other way around?

So this gives us:

• where: and

m

byx

0

0

xx

yym

end

end

00 xmyb

43

Leaving out the details this gives us:

We can see easily that this line doesn’t lookvery good!

We choose which way to work out the line pixels based on the slope of the line

0 1 2 3 4 5 6 7 8

0

1

2

3

4

5

6

7

43

23)3( x 5

3

15)4( x

44

If the slope of a line is between -1 and 1 then we work out the y coordinates for a line based on it’s unit x coordinates

Otherwise we do the opposite – x coordinates are computed based on unit y coordinates

m = 0

m = -1/3

m = -1/2

m = -1

m = -2m = -4

m = ∞

m = 1/3

m = 1/2

m = 1

m = 2m = 4

m = 0

45

#include <stdio.h>#include <graphics.h>

void main(void){

int graphdriver = DETECT, graphmode, color, n, m;

initgraph(&graphdriver, &graphmode, "c:\\tc");/* detect and initialize graphics system */for(n=0; n<50; n++){ putpixel(250+n,350,BLUE); /* draw a horizontal line */}

for(m=0; m<5; m++){ for(n=0; n<5; n++) {

putpixel(250+n,250+m,RED); }}

}

46

Initializes the graphics system

Declaration: void far initgraph(int far *graphdriver,int far *graphmode, char far *pathtodriver);

Remarks:To start the graphics system, you must first call initgraph.

initgraph initializes the graphics system by loading a graphics driver from disk (or validating a registered driver) then putting the system into graphics mode.

initgraph also resets all graphics settings (color, palette, current position, viewport, etc.) to their defaults, then resets graphresult to 0.

*graphdriver : Integer that specifies the graphics driver to be used. You can give graphdriver a value using a constant of the graphics_drivers enumeration type.

47

*graphmode :Integer that specifies the initial graphics mode (unless *graphdriver = DETECT). If *graphdriver = DETECT, initgraph sets *graphmode to the highest resolution available for the detected driver. You can give *graphmode a value using a constant of the graphics_modes enumeration type.

pathtodriver : Specifies the directory path where initgraph looks fo graphics drivers (*.BGI) first. þ If they're not there, initgraph looks in the current directory. þ If pathtodriver is null, the driver files must be i the current directory.This is also the path settextstyle searches for the stroked character font files (*.CHR).

*graphdriver and *graphmode must be set to valid graphics_drivers andgraphics_mode values or you'll get unpredictable results. (The exception isgraphdriver = DETECT.)After a call to initgraph, *graphdriver is set to the current graphicsdriver, and *graphmode is set to the current graphics mode.Return Value:initgraph always sets the internal error code.On success, initgraph sets the code to 0 On error, initgraph sets *graphdriver to-2, -3, -4, or -5, and graphresul returns the same value.

48

Towards the Ideal Line

• We can only do a discrete approximation

• Illuminate pixels as close to the true path as possible, consider bi-level display only– Pixels are either lit or not lit

49

What is an ideal line

• Must appear straight and continuous– Only possible axis-aligned and 45o lines

• Must interpolate both defining end points• Must have uniform density and intensity

– Consistent within a line and over all lines– What about antialiasing?

• Must be efficient, drawn quickly– Lots of them are required!!!

50

Simple Line

Based on slope-intercept algorithm from algebra:

y = mx + b

Simple approach:

increment x, solve for y

Floating point arithmetic required

51

Does it Work?It seems to work okay for lines with a slope of 1 or less,

but doesn’t work well for lines with slope greater than 1 – lines become more discontinuous in appearance and we must add more than 1 pixel per column to make it work.

Solution? - use symmetry.

52

Modify algorithm per octant

OR, increment along x-axis if dy<dx else increment along y-axis

53

DDA algorithm

• DDA = Digital Differential Analyser– finite differences

• Treat line as parametric equation in t :

)()(

)()(

121

121

yytyty

xxtxtx

),(

),(

22

11

yx

yxStart point -End point -

54

DDA Algorithm• Start at t = 0

• At each step, increment t by dt

• Choose appropriate value for dt

• Ensure no pixels are missed:– Implies: and

• Set dt to maximum of dx and dy

)()(

)()(

121

121

yytyty

xxtxtx

dt

dyyy

dt

dxxx

oldnew

oldnew

1dt

dx1

dt

dy

55

DDA algorithm

line(int x1, int y1, int x2, int y2)

{float x,y;int dx = x2-x1, dy = y2-y1;int n = max(abs(dx),abs(dy));float dt = n, dxdt = dx/dt, dydt = dy/dt;

x = x1;y = y1;while( n-- ) {

point(round(x),round(y));x += dxdt;y += dydt;}

}

n - range of t.

56

• Again the values calculated by the equations used by the DDA algorithm must be rounded to match pixel values

(xk, yk) (xk+1, yk+m)

(xk, round(yk))

(xk+1, round(yk+m))

(xk, yk) (xk+ 1/m, yk+1)

(round(xk), yk)

(round(xk+ 1/m), yk+1)

57

DDA algorithm

• Still need a lot of floating point arithmetic.– 2 ‘round’s and 2 adds per pixel.

• Is there a simpler way ?

• Can we use only integer arithmetic ?– Easier to implement in hardware.

58

Observation on lines.

while( n-- ) {draw(x,y);move right;if( below line )move up;}

59

Testing for the side of a line.

• Need a test to determine which side of a line a pixel lies.

• Write the line in implicit form:

0),( cbyaxyxF

• Easy to prove F<0 for points above the line, F>0 for points below.

60

Testing for the side of a line.

• Need to find coefficients a,b,c.• Recall explicit, slope-intercept form :

• So:

0),( cbyaxyxF

bxdx

dyybmxy so and

0..),( cydxxdyyxF

61

Decision variable.

PreviousPixel(xp,yp)

Choices forCurrent pixel

Choices forNext pixel

Evaluate F at point M

Referred to as decision variable

)2

1,1( pp yxFd

M

NE

E

62

Decision variable.

Evaluate d for next pixel, Depends on whether E or NE Is chosen :

If E chosen :

cybxayxFd ppppnew )2

1()2()

2

1,2(

But recall :

cybxa

yxFd

pp

ppold

)2

1()1(

)2

1,1(

So :

dyd

add

old

oldnew

M

E

NE

PreviousPixel

(xp,yp)

Choices forCurrent pixel

Choices forNext pixel

63

Decision variable.

If NE was chosen :

cybxayxFd ppppnew )2

3()2()

2

3,2(

So :

dxdyd

badd

old

oldnew

M

E

NE

PreviousPixel

(xp,yp)

Choices forCurrent pixel

Choices forNext pixel

64

Summary of mid-point algorithm

• Choose between 2 pixels at each step based upon the sign of a decision variable.

• Update the decision variable based upon which pixel is chosen.

• Start point is simply first endpoint (x1,y1).

• Need to calculate the initial value for d

65

Initial value of d.

2

)2

1()1()

2

1,1(

11

1111

bacbyax

cybxayxFdstart

But (x1,y1) is a point on the line, so F(x1,y1) =0

2/dxdydstart

Conventional to multiply by 2 to remove fraction doesn’t effect sign.

2),( 11

bayxF

Start point is (x1,y1)

66

Bresenham algorithm

void MidpointLine(int x1,y1,x2,y2)

{

int dx=x2-x1;

int dy=y2-y1;

int d=2*dy-dx;

int increE=2*dy;

int incrNE=2*(dy-dx);

x=x1;

y=y1;

WritePixel(x,y);

while (x < x2) {if (d<= 0) {

d+=incrE;x++

} else {d+=incrNE;x++;y++;

}WritePixel(x,y);

}}

67

Bresenham was (not) the end!

2-step algorithm by Xiaolin Wu:

(see Graphics Gems 1, by Brian Wyvill)

Treat line drawing as an automaton , or finite state machine, ie. looking at next two pixels of a line, easy to see that only a finite set of possibilities exist.

The 2-step algorithm exploits symmetry by simultaneously drawing from both ends towards the midpoint.

68

Two-step Algorithm

Possible positions of next two pixels dependent on slope – current pixel in blue:

Slope between 0 and ½

Slope between ½ and 1

Slope between 1 and 2

Slope greater than 2

69

Circle drawing.• Can also use Bresenham to draw circles.

• Use 8-fold symmetry

Choices forNext pixel

M

E

SE

PreviousPixel

Choices forCurrent pixel

70

Circle drawing.

• Implicit form for a circle is:

2 2 2) ( ) ( ) , (r y y x x y x fc c

)32(chosen is E If

)522(chosen is SE If

poldnew

ppoldnew

xdd

yxdd

Functions are linear equations in terms of (xp,yp)

–Termed point of evaluation

71

Problems with Bresenham algorithm

• Pixels are drawn as a single line unequal line intensity with change in angle.

Pixel density = n pixels/mm

Pixel density = 2.n pixels/mm

Can draw lines in darker colours according to line direction.-Better solution : antialiasing !-(eg. Gupta-Sproull algorithm)

72

Summary of line drawing so far.

• Explicit form of line– Inefficient, difficult to control.

• Parametric form of line.– Express line in terms of parameter t– DDA algorithm

• Implicit form of line– Only need to test for ‘side’ of line.– Bresenham algorithm.– Can also draw circles.

73

74

75

76

77

78

79

80

Circle Midpoint Algorithm

draw pixels in this octant(draw others using symmetry)

(0,R)

(0,-R)

(R,0)(-R,0)

222),( RyxyxF Implicit function for circle

0),( yxF

0),( yxF

0),( yxF

on circle

inside

outside

x+

y+

81

Choosing the Next Pixel

M

(x, y) (x+1, y)

(x+1, y+1)

E

SE

0)2/1,1( yxF

0)2/1,1( yxF

choose E

choose SE

)2/1,1()( yxFMFddecision variable d

82

Change of d when E is chosen

Mold

(x, y) (x+1, y)

(x+1, y+1)

E

SE

(x+2, y)

(x+2, y+1)

Mnew

32

)2/1()1(

)2/1()2(222

222

xddd

Ryxd

Ryxd

oldnew

old

new

83

Change of d when SE is chosen

Mold

(x, y) (x+1, y)E

SE

(x+1, y+2) (x+2, y+2)

Mnew

522

)2/1()1(

)2/3()2(222

222

yxddd

Ryxd

Ryxd

oldnew

old

new

84

Initial value of d

Rd

RRd

RFd

MFd

4/5

)2/1()1(

)2/1,1(

)(

0

2220

0

00

(0,-R)

M0

(1,-R)

(1,-R+1)

85

Midpoint Circle Algox = 0;y = -R;d = 5/4 – R; /* real */setPixel(x,y);while (y > x) {

if (d > 0) { /* E chosen */d += 2*x + 3;x++;

} else { /* SE chosen */d += 2*(x+y) + 5;x++; y++;

}setPixel(x,y);

}

86

New Decision Variable

• Our circle algorithm requires arithmetic with real numbers.• Let’s create a new decision variable h

h=d-1/4

• Substitute h+1/4 for d in the code.• Note h > -1/4 can be replaced with h > 0 since h will always have an

integer value.

87

New Circle Algorithm

x = 0;y = -R;h = 1 – R; setPixel(x,y);while (y > x) {

if (h > 0) { /* E chosen */h += 2*x + 3;x++;

} else { /* SE chosen */h += 2*(x+y) + 5;x++; y++;

}setPixel(x,y);

}

88

Second-Order Differences

• Note that d is incremented by a linear expression each time through the loop.– We can speed things up a bit by tracking how these linear

expressions change.– Not a huge improvement since multiplication by 2 is just a left-

shift by 1 (e.g. 2*x = x<<1).

89

2nd Order Difference when E chosen

• When E chosen, we move from pixel (x,y) to (x+1,y).

2

3)1(2

32

oldnew

new

old

EE

xE

xE

2

5)1(2

5)(2

oldnew

new

old

SESE

yxSE

yxSE

90

2nd Order Difference when SE chosen

• When SE chosen, we move from pixel (x,y) to (x+1,y+1).

2

3)1(2

32

oldnew

new

old

EE

xE

xE

4

5)11(2

5)(2

oldnew

new

old

SESE

yxSE

yxSE

91

New and Improved Circle Algorithm

x = 0; y = -R;h = 1 – R; dE = 3; dSE = -2*R + 5;setPixel(x,y);while (y > x) {

if (h > 0) { /* E chosen */h += dE;dE += 2; dSE += 2;x++;

} else { /* SE chosen */h += dSE;dE += 2; dSE += 4;X++; y++;

}setPixel(x,y);

}

92

93

94

95

96

97

98

99

100

101

102

103