WHERE TO DRAW A LINE??

Line drawing is accomplished by calculating

intermediate positions along the line path between
specified end points.
Precise definition of line drawing
Given two points P and Q in the plane, both with
integer coordinates, determine which pixels on a
raster screen should be on in order to make a
picture of a unit-width line segment starting from
P and ending at Q.
0 1 2 3 4 5 6
6
5
4
3
2
1
0
(3, 3)
Line drawing (cont)
The thinnest line is of one-pixel wide. We will
concentrate on drawing a line of 1 pixel resolution.
The Cartesian slope-intercept equation for a straight line
is
y= m. x + b
m is the slope of the line and b is the y intercept.
Given the endpoints of a line segment.
m = y2-y1 / x2-x1
b= y1-m.x1
Line Drawing (cont)
Also for any given interval x along a line, we can
compute the corresponding y interval y from
y= m. x
Similarly we can obtain the x interval x corresponding
to a specified y as
x= y / m
These equations form the basis for determining
deflection voltages in analog devices.
Line Drawing (cont)
Also , for any given x interval x along a line, we can
compute the corresponding y interval y from
y= m. x
These equations form the basis for determining
deflection voltages in analog devices.
On Raster systems, lines are plotted with pixels, and
step sizes in the horizontal and vertical directions are
constrained by pixel separations. Hence we ought to
sample a line at discrete positions and determine the
nearest pixel to the line at each sampled position.
Symmetry
If we could draw lines with positive slope (0<=slope<=1) we would
be done.
For a line with negative slope (0>=slope>=-1)
We negate all Y values
For a line with slope > 1 or slope <-1
we just swap x and y axes
45
0
(y,x)
(x,y)
(x,-y)
(y,-x)
(-y,x)
(x,-y)
(-x,-y)
(-y,-x)
Code for drawing a line
Invert_y_draw(int x,int y)
draw_pixel(x,-y)
Swap_xy_draw(int x,int y)
draw_pixel(y,x)
Swap_xy_invert_y_draw(int x,int y)
draw_pixel(y,-x)
.
If(0 <= slope <= 1)
draw_fn= draw_pixel
draw_lne(Px, PY, QX, QY, draw_fn)
Else if (-1 <= slope <= 0)
draw_fn = invert_y_draw
Draw_line(PX, -PY, QX, -QY, draw_fn)
Else if (1 < slope)
draw_fn= swap_xy_draw
Draw_line(PY,PX,QY,QX)
Else
Draw_fn=swap_xy_invert_y_draw
Draw_line(-PY,PX,QY,-QX, draw_fn)
DDA ALGORITHM
The digital differential analyzer (DDA) samples the line at
unit intervals in one coordinate corresponding integer
values nearest the line path of the other coordinate.
The following is thus the basic incremental scan-
conversion(DDA) algorithm for line drawing
for x from x0 to x1
Compute y=mx+b
Draw_fn(x, round(y))
Major deficiency in the above approach :
Uses floats
Has rounding operations
DDA Illustration
(x
i
, Round(y
j
))
(x
i
+1, y
j
+m)
(x
i
, y
j
)
(x
i
+1, Round(y
j
+m))
Desired Line
x1 x2
y2
y1
Bresenhams Line Algorithm
An accurate, efficient raster line drawing algorithm
developed by Bresenham, scan converts lines using only
incremental integer calculations that can be adapted to
display circles and other curves.
Keeping in mind the symmetry property of lines, lets
derive a more efficient way of drawing a line.
Starting from the left end point (x
0
,y
0
) of a given line , we step to
each successive column (x position) and plot the pixel whose
scan-line y value closest to the line path
Assuming we have determined that the pixel at (x
k
,y
k
) is to
be displayed, we next need to decide which pixel to plot in
column x
k+1
.
Bresenham Line Algorithm
(cont)
The difference between these 2 separations is
A decision parameter p
k
for the k
th
step in the
line algorithm can be obtained by rearranging
above equation so that it involves only integer
calculations
Choices are(x
k
+1, y
k
) and (x
k
+1, y
K
+1)
d
1
= y y
k
= m(x
k
+ 1) + b y
k
d
2
= (y
k
+ 1) y = y
k
+ 1- m(x
k
+ 1) b
d1-d2 = 2m(xk + 1) 2 yk + 2b 1
Bresenhams Line Algorithm
Define
P
k
= x ( d
1
-d
2
) = 2yx
k
-2 xy
k
+ c
The sign of P
k
is the same as the sign of d
1
-d
2
, since x > 0.
Parameter c is a constant and has the value 2y + x(2b-1)
(independent of pixel position)
If pixel at y
k
is closer to line-path than pixel at y
k
+1
(i.e, if d
1
< d
2
) then p
k
is negative. We plot lower pixel in such
a case. Otherwise , upper pixel will be plotted.
Bresenhams algorithm (cont)
At step k + 1, the decision parameter can be evaluated as,
p
k
+1 = 2yx
k
+1 - 2xy
k
+1 + c
Taking the difference of p
k+ 1
and p
k
we get the following.
p
k+1
p
k
= 2y(x
k+1
- x
k
)-2x(y
k+1
y
k
)
But, x
k+1
= x
k
+1, so that
p
k+1
= p
k
+ 2y - 2 x(y
k+1
y
k
)
Where the term y
k+1
-y
k
is either 0 or 1, depending on the
sign of parameter p
k
Bresenhams Line Algorithm
The first parameter p
0
is directly computed
p
0
= 2 yx
k
- 2 xy
k
+ c = 2 yx
k
2 y + x (2b-1)
Since (x
0
,y
0
) satisfies the line equation , we also have
y
0
= y/ x * x
0
+ b
Combining the above 2 equations , we will have
p
0
= 2y x
The constants 2y and 2y-2x are calculated once for
each time to be scan converted
Bresenhams Line Algorithm
So, the arithmetic involves only integer addition and
subtraction of 2 constants
Input the two end points and store the left end
point in (x
0,
y
0
)
Load (x
0
,y
0
) into the frame buffer (plot the first
point)
Calculate the constants x, y, 2y and 2y-2x
and obtain the starting value for the decision
parameter as
p
0
= 2y- x
Bresenhams Line Algorithm
At each x
k
along the line, starting at k=0, perform the
following test:
If p
k
< 0 , the next point is (x
k
+1, y
k
) and
p
k+1
= p
k
+ 2y
Repeat step 4 (above step) x times
Otherwise
Point to plot is (x
k
+1, y
k
+1)
p
k+1
= p
k
+ 2y - 2x
Where do we draw a circle???
Properties of a circle:
A circle is defined as a set of points that are all the
given distance (x
c
,y
c
). This distance relationship is
expressed by the pythagorean theorem in Cartesian
coordinates as
(x x
c
)
2
+ (y y
c
)
2
= r
2
We could use this equation to calculate the points on
the circle circumference by stepping along x-axis in unit
steps from x
c
-r to x
c
+r and calculate the corresponding
y values at each position as
y = y
c
+(- ) (r
2
(xc x )
2
)
1/2
This is not the best method:
Considerable amount of computation
Spacing between plotted pixels is not uniform
Polar co-ordinates for a circle
We could use polar coordinates r and ,
x = x
c
+ r cos y = y
c
+ r sin
A fixed angular step size can be used to plot equally spaced
points along the circumference
A step size of 1/r can be used to set pixel positions to
approximately 1 unit apart for a continuous boundary
But, note that circle sections in adjacent octants within one
quadrant are symmetric with respect to the 45 deg line
dividing the to octants
Thus we can generate all pixel positions around a circle by
calculating just the points within the sector from x=0 to
x=y
This method is still computationally expensive
Bresenham to Midpoint
Bresenham requires explicit equation
Not always convenient (many equations
are implicit)
Based on implicit equations: Midpoint
Algorithm (circle, ellipse, etc.)
Implicit equations have the form
F(x,y)=0.
Midpoint Line Algorithm
xk+1 = xk+1
yk+1 = Either yk or
yk+1
Midpoint algorithm is an incremental algorithm
Midpoint Algorithm
Assumption:
Slope < 1
Current
Pixel
Candidate Pixels
Current Pixel
( xk, yk)
Midpoint
Line
Coordinates of Midpoint = ( xk+1, yk+(1/2)
)
( xk+1,
yk)
( xk+1,
yk+1)
Midpoint Algorithm -
Notations
Midpoint Below Line Midpoint Above Line
Midpoint Algorithm:
Choice of the next pixel
-If the midpoint is below the line, then the next pixel is (xk+1,
yk+1).
-If the midpoint is above the line, then the next pixel is (xk+1, yk).
A(ax,ay)
B(bx,by)
Equation of a line revisited.
Let w = bx ax, and h = by ay.
Then, h (x ax) w (y ay) = 0.
(h, w , ax , ay are all integers).
In other words, every point (x, y) on the line
satisfies the equation F(x, y) =0, where
F(x, y) = h (x ax) w (y ay).
Equation of the line:
Midpoint Algorithm:
Regions below and above the line.
F (x,y) > 0
(for any point below line)
F(x,y) < 0
(for any point above line)
F(x,y) = 0
F(MP) > 0
0 ) , ( = y x f
Midpoint below line
F(MP) < 0
Midpoint above line
Midpoint Algorithm
Decision Criteria
Midpoint Algorithm
Decision Criteria
F(MP) = F(xk+1, yk+ ) = Fk (Notation)
If Fk < 0 : The midpoint is above the line. So the next
pixel is (xk+1, yk).
If Fk 0 : The midpoint is below or on the line. So
the next pixel is (xk+1, yk+1).
Decision
Parameter
Midpoint Algorithm Story so far
Midpoint Below Line
Next pixel = (xk+1,
yk+1)
Fk >
0
yk+1 =
yk+1
Midpoint Above Line
Next pixel = (xk+1,
yk)
Fk <
0
yk+1 =
yk
Midpoint Algorithm
Update Equation
Fk = F(xk+1, yk+ ) = h (xk+1 ax) w (yk+ ay)
But, Fk+1 = Fk + h w (yk+1--- yk). (Refer
notes)
So,
Fk< 0 : yk+1 = yk. Hence, Fk+1 = Fk + h .
Fk 0 : yk+1 = yk+1. Hence, Fk+1 = Fk + h
w.
F0 = h w/2.
Update Equation
Midpoint Algorithm
3333
int h = by-ay;
int w = bx-ax;
float F=h-w/2;
int x=ax, y=ay;
for (x=ax; x<=bx; x++){
setPixel(x, y);
if(F < 0)
F+ = h;
else{
F+ = h-w;
y++;
}
}
Midpoint Circle Algorithm
We will first calculate pixel positions for a circle centered
around the origin (0,0). Then, each calculated position (x,y)
is moved to its proper screen position by adding xc to x and
yc to y
Note that along the circle section from x=0 to x=y in the
first octant, the slope of the curve varies from 0 to -1
Circle function around the origin is given by
fcircle(x,y) = x
2
+ y
2
r
2
Any point (x,y) on the boundary of the circle satisfies the
equation and circle function is zero
Midpoint Circle Algorithm
For a point in the interior of the circle, the circle function is
negative and for a point outside the circle, the function is
positive
Thus,
f
circle
(x,y) < 0 if (x,y) is inside the circle boundary
f
circle
(x,y) = 0 if (x,y) is on the circle boundary
f
circle
(x,y) > 0 if (x,y) is outside the circle boundary
yk
Yk-1
xk xk+1 Xk+3 Midpoint
X
2
+y
2
-r
2
=0
Midpoint between candidate
pixels at sampling position
x
k
+1 along a circular path
Midpoint Circle Algorithm
Assuming we have just plotted the pixel at (x
k
,y
k
) , we next
need to determine whether the pixel at position (x
k
+ 1, y
k
-
1) is closer to the circle
Our decision parameter is the circle function evaluated at
the midpoint between these two pixels
p
k
= f
circle
(x
k
+1, y
k
-1/2) = (x
k
+1)
2
+ (y
k
-1/2)
2
r
2
If p
k
< 0 , this midpoint is inside the circle and the pixel on
the scan line y
k
is closer to the circle boundary. Otherwise,
the
mid position is outside or on the circle boundary, and we
select the pixel on the scan line y
k
-1
Midpoint Circle Algorithm
Successive decision parameters are obtained using
incremental calculations
P
k+1
= f
circle
(x
k+1
+1, y
k+1
-1/2)
= [(x
k+1
)+1]
2
+ (y
k+1
-1/2)
2
r
2
OR
P
k+1
= P
k
+2(x
K
+1) + (y
K+1
2
y
k
2
) (y
k
+1- y
k
)+1
Where y
k+1
is either y
k
or y
k-1
, depending on the sign of p
k
Increments for obtaining P
k+1
:
2x
k+1
+1 if p
k
is negative
2x
k+1
+1-2y
k+1
otherwise
Midpoint circle algorithm
Note that following can also be done incrementally:
2x
k+1
= 2x
k
+2
2 y
k+1
= 2y
k
2
At the start position (0,r) , these two terms have the
values 2 and 2r-2 respectively
Initial decision parameter is obtained by evaluating the
circle function at the start position (x0,y0) = (0,r)
p
0
= f
circle
(1, r-1/2) = 1+ (r-1/2)
2
-r
2
OR
P
0
= 5/4 -r
If radius r is specified as an integer, we can round p
0
to
p
0
= 1-r
The actual algorithm
1: Input radius r and circle center (x
c
,y
c
) and obtain the first
point on the circumference of the circle centered on the origin
as
(x
0
,y
0
) = (0,r)
2: Calculate the initial value of the decision parameter as
P
0
= 5/4 - r
3: At each x
k
position starting at k = 0 , perform the
following test:
If p
k
< 0 , the next point along the circle centered on (0,0) is
(x
k+1
, y
k
) and
p
k+1
= p
k
+ 2x
k+1
+ 1
The algorithm
Otherwise the next point along the circle is (x
k+1
, y
k-1
) and
p
k+1
= p
k
+ 2x
k+1
+1 -2y
k+1
Where 2x
k+1
= 2x
k+2
and 2y
k+1
= 2y
k
-2
4: Determine symmetry points in the other seven octants
5: Move each calculated pixel position (x,y) onto the
circular path centered on (x,yc) and plot the coordinate
values
x = x+ x
c
, y= y+ y
c
6: Repeat steps 3 through 5 until x >= y
Midpoint Ellipse
Derivation
Midpoint Ellipse Algorithm
Input and ellipse center and obtain
the first point on an ellipse centered on the origin
as
Calculate the initial value of the decision
parameter in region 1 as
2 2 2
0
4
1
1
x y x y
r r r r p + =
y x
r r ,
( )
c c
y x ,
( ) ( )
y
r y x , 0 ,
0 0
=
Midpoint Ellipse..
At each position in region 1, starting at
k = 0, perform the following test. if
, the next point along the ellipse centered
on (0,0) is and
Otherwise, the next point along the ellipse
is and
with
and continue until
k
x
0 1 <
k
p
( )
k k
y x ,
1 +
2
1
2
1
2 1 1
y k y k k
r x r p p + + =
+ +
( ) 1 , 1 +
k k
y x
2
1
2
1
2
1
2 2 1 1
y k x k y k k
r y r x r p p + + =
+ + +
2 2
1
2 2 2
1
2
2 2 2 , 2 2 2
x k x k x y k y k y
r y r y r r x r x r = + =
+ +
y r x r
x y
2 2
2 2 >
Midpoint Ellipse Contd.
Calculate the initial value of the decision
parameter in region 2 as
where is the last position calculated in
region 1
At each position in region 2, starting at k=0,
perform the following test. if , the next
point along the ellipse centered on (0,0) is
and
Otherwise, the next point along the ellipse is
and
Using the same incremental calculations for x and
y as in region 1. Continue until y=0
( )
2 2
2
0
2
2
0
2
0
1
2
1
2
y x x y
r r y r x r p +
|
.
|

\
|
+ =
( )
0 0
, y x
k
y
0 2 >
k
p
( ) 1 ,
k k
y x 2
1
2
1
2 2 2
x k x k k
r y r p p + =
+ +
( ) 1 , 1 +
k k
y x
2
1
2
1
2
1
2 2 2 2
x k x k y k k
r y r x r p p + + =
+ + +
Midpoint Ellipse
For both regions, determine
symmetry points in the other three
quadrants
Move each calculated pixel position
(x, y) onto the elliptical path that is
centered on and plot the
coordinate values
( )
c c
y x ,
c c
y y y x x x + = + = ,