Scribd
Upload
12 views

Rasterizing Primitives: Know Where To Draw The Line

The document discusses algorithms for rasterizing primitives like lines and circles. It describes Bresenham's algorithms from 1965 and 1977 which use integer arithmetic to rasterize lines and circles efficiently with minimal computations. The core ideas are using error functions to make pixel selection choices and updating error values in a way that requires only additions.

Uploaded by

rick
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
12 views

Rasterizing Primitives: Know Where To Draw The Line

The document discusses algorithms for rasterizing primitives like lines and circles. It describes Bresenham's algorithms from 1965 and 1977 which use integer arithmetic to rasterize lines and circles efficiently with minimal computations. The core ideas are using error functions to make pixel selection choices and updating error values in a way that requires only additions.

Uploaded by

rick
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 23

Rasterizing primitives:

know where to draw the


line
Dr Nicolas Holzschuch
University of Cape Town
e-mail: [email protected]
Modified by Longin Jan Latecki
[email protected]
Sep 2002

Rasterization of Primitives
How to draw primitives?
Convert from geometric definition to
pixels
rasterization = selecting the pixels

Will be done frequently


must be fast:
use integer arithmetic
use addition instead of multiplication

Rasterization Algorithms
Algorithmics:
Line-drawing: Bresenham, 1965
Polygons: uses line-drawing
Circles: Bresenham, 1977

Currently implemented in all


graphics libraries
Youll probably never have to
implement them yourself

Why should I know them?


Excellent example of efficiency:
no superfluous computations

Possible extensions:
efficient drawing of parabolas, hyperbolas

Applications to similar areas:


robot movement, volume rendering

The CG equivalent of Eulers


algorithm

Map of the lecture


Line-drawing algorithm
nave algorithm
Bresenham algorithm

Circle-drawing algorithm
nave algorithm
Bresenham algorithm

Nave algorithm for lines


Line definition: ax+by+c = 0
Also expressed as: y = mx + d
m = slope
d = distance

For x=xmin to xmax


compute y = m*x+d
light pixel (x,y)

Extension by symmetry
Only works with -1 m 1:
m=3
m = 1/3

Extend by symmetry for m > 1

Problems
2 floating-point operations per pixel
Improvements:
compute y = m*p+d
For x=xmin to xmax
y += m
light pixel (x,y)

Still 1 floating-point operation per pixel


Compute in floats, pixels in integers

Bresenham algorithm: core


idea
At each step, choice between 2 pixels
(0 m 1)

or that one

Line drawn so far

Either I lit this pixel

Bresenham algorithm
I need a criterion to pick between
them
Distance between line and center of
pixel:
the error associated with this pixel

Error pixel 2
Error pixel 1

Bresenham Algorithm (2)


The sum of the 2 errors is 1
Pick the pixel with error < 1/2

If error of current pixel < 1/2,


draw this pixel

Else:
draw the other pixel.
Error of current pixel = 1 - error

How to compute the error?

Origin (0,0) is the lower left corner


Line defined as: y = ax + c
Distance from pixel (p,q) to line:
d = y(p) q = ap - q + c
Draw this pixel iff:
ap - q + c < 1/2
Update for next pixel:
x += 1, d += a

Were still in floating point!


Yes, but now we can get back to
integer:
e = 2ap - 2q + 2c - 1< 0
If e<0, stay horizontal, if e>0, move up.
Update for next pixel:
If I stay horizontal: x+=1, e += 2a
If I move up:
x+=1, y+=1, e += 2a - 2

Bresenham algorithm:
summary
Several good ideas:

use of symmetry to reduce complexity


choice limited to two pixels
error function for choice criterion
stay in integer arithmetics

Very straightforward:
good for hardware implementation
good for assembly language

Circle: nave algorithm


Circle equation: x2+y2-r2 = 0
Simple algorithm:
for x = xmin to xmax
y = sqrt(r*r - x*x)
draw pixel(x,y)

Work by octants and use symmetry

Circle: Bresenham algorithm


Choice between two pixels:
or that one

Circle drawn so far

Either I lit this pixel

Bresenham for circles


Mid-point algorithm:

E
SE
If the midpoint between pixels is inside the circle,
E is closer, draw E
If the midpoint is outside, SE is closer, draw SE

Bresenham for circles (2)


Error function: d = x2+y2 - r2
Compute d at the midpoint:
If the last pixel drawn is (x,y),
then E = (x+1,y), and SE = (x+1,y-1).
Hence, the midpoint = (x+1,y-1/2).
d(x,y) = (x+1)2 + (y - 1/2)2 - r2
d < 0: draw E
d 0: draw SE

Updating the error


In each step (go to E or SE), i.e.,
increment x: x+=1:
d += 2x +3

If I go to SE, i.e., x+=1, y+=-1:


d += -2y + 2

Two mult, two add per pixel


Can you do better?

Doing even better


The error is not linear
However, what I add to the error is
Keep x and y:
At each step:
x += 2, y += -2
d += x
If I decrement y, d += y

4 additions per pixel

Midpoint algorithm:
summary
Extension of line drawing algorithm
Test based on midpoint position
Position checked using function:
sign of (x2+y2-r2)

With two steps, uses only additions

Extension to other functions


Midpoint algorithm easy to extend
to any curve defined by: f(x,y) = 0
If the curve is polynomial, can be
reduced to only additions using norder differences

Conclusion
The basics of Computer Graphics:
drawing lines and circles

Simple algorithms, easy to


implement with low-level
languages

You might also like