Computer Graphics

Computer Graphics

Lecture 3
Line & Circle Drawing
Computer Graphics

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
2
Computer Graphics

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!!!
3
Computer Graphics

Simple Line
Based on slope-intercept
algorithm from algebra:
y = mx + b
Simple approach:
increment x, solve for y
Floating point arithmetic
required

4
Computer Graphics

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.

5
Computer Graphics

Modify algorithm per octant

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

6
Computer Graphics

DDA algorithm
• DDA = Digital Differential Analyser
– finite differences
• Treat line as parametric equation in t :

Start point - ( x1 , y1 ) x(t )  x1  t ( x2  x1 )

End point - ( x2 , y2 )
y (t )  y1  t ( y2  y1 )

7
Computer Graphics

DDA Algorithm x(t )  x1  t ( x2  x1 )

y (t )  y1  t ( y2  y1 )

dx
• Start at t = 0 xnew  xold 
dt
• At each step, increment t by dt ynew  yold 
dy
dt
• Choose appropriate value for dt dx  x2  x1
• Ensure no pixels are missed: dy  y2  y1
– Implies: dx and dy
1 1
dt dt

• Set dt to maximum of dx and dy

8
Computer Graphics

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

{ n - range of t.
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;
}
}

9
Computer Graphics

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.

10
Computer Graphics

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

11
Computer Graphics

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:
F ( x, y )  ax  by  c  0
•If (b<0) F<0 for points above the line, F>0 for
points below.

12
Computer Graphics

Testing for the side of a line.

F ( x, y )  ax  by  c  0
• Need to find coefficients a,b,c.
• Recall explicit, slope-intercept form :

• So:
dy
y  mx  b and so y  xb
dx

F ( x, y )  dy.x  dx. y  c  0
13
Computer Graphics

Decision variable.
Let’s assume dy/dx < 0.5 (we can use symmetry)

Evaluate F at point M 1
d  F ( x p  1, y p  )
2
Referred to as decision variable

NE

M
E

Previous Choices for Choices for

Pixel Current pixel Next pixel
(xp,yp)
Computer Graphics

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

If E chosen :
1 1
d new  F ( x p  2, y p  )  a ( x p  2)  b( y p  )  c
2 2
But recall :
1
d old  F ( x p  1, y p  )
NE 2
1
M  a ( x p  1)  b( y p  )  c
2
E
Previous Choices for
So :
d new  d old  a
Pixel Choices for Next pixel
(xp,yp) Current pixel  d old  dy
15
Computer Graphics

Decision variable.
If NE was chosen :
3 3
d new  F ( x p  2, y p  )  a ( x p  2)  b( y p  )  c
2 2

M So :
NE
d new  d old  a  b
E
 d old  dy  dx
Previous Choices for
Pixel Choices for Next pixel
(xp,yp) Current pixel

16
Computer Graphics

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

17
Computer Graphics

Initial value of d.
Start point is (x1,y1)
1 1
d start  F ( x1  1, y1  )  a( x1  1)  b( y1  )  c
2 2
b
 ax1  by1  c  a 
2
b
 F ( x1 , y1 )  a 
2

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

d start  dy  dx / 2
Conventional to multiply by 2 to remove fraction  doesn’t effect sign.

18
Computer Graphics

Midpoint algorithm
void MidpointLine(int
x1,y1,x2,y2) while (x < x2) {
{ if (d<= 0) {
int dx=x2-x1; d+=incrE;
x++
int dy=y2-y1; } else {
int d=2*dy-dx; d+=incrNE;
x++;
int increE=2*dy; y++;
int incrNE=2*(dy-dx); }
WritePixel(x,y);
x=x1; }
y=y1; }

WritePixel(x,y);

19
Computer Graphics

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

• Use 8-fold symmetry

M
SE

Previous Choices for Choices for

Pixel Current pixel Next pixel

20
Computer Graphics

Circle drawing.
• Implicit form for a circle is:
2 2 2
f ( x, y )  ( x  xc )  ( y  yc )  r
If SE is chosen d new  d old  (2 x p  2 y p  5)
If E is chosen d new  d old  (2 x p  3)

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

–Termed point of evaluation

21
Computer Graphics

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.

22
Computer Graphics

Problems with Bresenham algorithm

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

Pixel density = 2.n pixels/mm

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

Pixel density = n pixels/mm

23
 Computer Graphics

Gupta-Sproull algorithm.
• Calculate the distance of the line and the pixel
center
• Adjust the colour according to the distance
Computer Graphics

Gupta-Sproull algorithm.
Calculate distance using features of mid-point algorithm
D  v cos 
vdx

dx 2  dy 2
dy
NE
dx

v Angle = 
M D

25
Computer Graphics

Gupta-Sproull algorithm (cont)

Recall from the midpoint algorithm:
F ( x, y )  2ax  by  c   0 (doubled to avoid fraction) Line to draw
NE

So y  (ax  c )
yp+1
m
b D v
yp
E 
For pixel E: xp
xp+1
x p 1  x p  1 y p 1  y p v  y  y p 1

So:
a ( x p  1)  c
v  yp
b
 Computer Graphics

Gupta-Sproull algorithm (cont)

Line to draw
From previous slide:
NE
a ( x p  1)  c
v  yp yp+1
b m
From the midpoint computation, y p
D v

b   dx xp E 
xp+1

So:
vdx  a ( x p  1)  by p  c  F ( x p  1, y p ) / 2
 Computer Graphics

Gupta-Sproull algorithm (cont)

From the midpoint algorithm, we had the decision
variable (remember?)
1
d  F ( M )  F ( x p 1 , y p  )
2 Line to draw
Going back to our previous equation: NE
yp+1
2vdx  F ( x p  1, y p ) m

 2a ( x p  1)  2by p  2c py D v

 2a ( x p  1)  2b( y p  1 / 2)  2b / 2  2c xp E
xp+1
 F ( x p  1, y p  1 / 2)  b
 F (M )  b
 d b
 d  dx
Computer Graphics

Gupta-Sproull algorithm (cont)

So,
d  dx
D
2 dx 2  dy 2

And the denominator is constant

Since we are blurring the line, we also need to
compute the distances to points yp – 1 and yp + 1
numerator for y p  1  2(1  v)dx  2dx  2vdx
numerator for y p  1  2(1  v)dx  2dx  2vdx
 Gupta-Sproull algorithm (cont)
Computer Graphics

If the NE pixel had been chosen:

2vdx  F ( x p  1, y p  1)
 2a( x p  1)  2(by p  1)  2c
 2a( x p  1)  2b( y p  1 / 2)  2b / 2  2c
 F ( x p  1, y p  1 / 2)  b
 F (M )  b
 d b
 d  dx
numerator for y p  2  2(1  v)dx  2dx  2vdx
numerator for y p  2(1  v)dx  2dx  2vdx
Computer Graphics

Gupta-Sproull algorithm (cont)

• Compute midpoint line algorithm, with the following alterations:
• At each iteration of the algorithm:
– If the E pixel is chosen, set numerator = d + dx
– If the NE pixel is chosen, set numerator = d – dx
– Update d as in the regular algorithm
– Compute D = numerator/denominator
– Color the current pixel according to D
– Compute Dupper = (2dx-2vdx)/denominator
– Compute Dlower = (2dx+2vdx)/denominator
– Color upper and lower accordingly