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
o
– Only possible axis-aligned and 45 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 )
End point - ( x2 , y2 )
x(t )  x1  t ( x2  x1 )
y (t )  y1  t ( y2  y1 )
7
Computer Graphics
x(t )  x1  t ( x2  x1 )
DDA Algorithm
•
•
•
•
y (t )  y1  t ( y2  y1 )
Start at t = 0
At each step, increment t by dt
Choose appropriate value for dt
Ensure no pixels are missed:
– Implies:
dx
1
dt
and
dx
dt
dy
 yold 
dt
xnew  xold 
ynew
dx  x2  x1
dy  y2  y1
dy
1
dt
• Set dt to maximum of dx and dy
8
Computer Graphics
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.
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 :
y  mx  b and so y 
• So:
dy
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
Referred to as decision variable
1
d  F ( x p  1, y p  )
2
NE
M
E
Previous
Pixel
(xp,yp)
Choices for
Current pixel
Choices for
Next pixel
Computer Graphics
Decision variable.
Evaluate d for next pixel, Depends on whether E or NE Is chosen :
If E chosen :
d new
1
1
 F ( x p  2, y p  )  a( x p  2)  b( y p  )  c
2
2
But recall :
NE
M
E
Previous
Pixel
(xp,yp)
Choices for
Current pixel
Choices for
Next pixel
1
d old  F ( x p  1, y p  )
2
1
 a ( x p  1)  b( y p  )  c
2
So :
d new  d old  a
 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
NE
d new  d old  a  b
 d old  dy  dx
E
Previous
Pixel
(xp,yp)
Choices for
Current pixel
So :
Choices for
Next 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)
{
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);
}
}
19
Computer Graphics
Circle drawing.
• Can also use Bresenham to draw circles.
• Use 8-fold symmetry
E
M
SE
Previous
Pixel
Choices for
Current pixel
Choices for
Next pixel
20
Computer Graphics
Circle drawing.
• Implicit form for a circle is:
f ( x, y )  ( x  xc )  ( y  yc )  r
2
2
2
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
M
dx
v
Angle = 
D
E
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
yp+1
y  ( ax  c )
b
m
xp
For pixel E:
x p 1  x p  1
So:
v
y p 1  y p
a( x p  1)  c
b
 yp
v
D
yp
v  y  y p 1
E
xp+1
Q
Computer Graphics
Gupta-Sproull algorithm (cont)
Line to draw
From previous slide:
v
a( x p  1)  c
b
NE
 yp
yp+1
m
From the midpoint computation, y
b   dx
So:
vdx  a( x p  1)  by p  c  F ( x p  1, y p ) / 2
v
D
p
xp
E
xp+1
Q
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 )
 2a ( x p  1)  2by p  2c
yp
 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
m
v
D
xp
E
xp+1
Q
Computer Graphics
Gupta-Sproull algorithm (cont)
So,
D
d  dx
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