Chapter 3

Two Dimensional Algorithms

Output Primitives
Output primitives are the geometric structure such as straight line segments and polygon areas
used to describe the shapes and color of the objects.
In case of the two dimensional algorithm, we mostly deal with the line, circle, ellipse etc as they
are the basic output primitives.
Line Scan Conversion
The slope-intercept equation of a straight line is:
y=mx +b
where
m = slope of line and ,
b = y-intercept.
For any two given points ( x1 , y 1 ) and ( x 2 , y 2 )
y 2  y1
slope (m) =
x 2  x1
y 2  y1
∴b= y− x from above equation
x 2  x1
At any point ( x k , y k )
y k  mx k  b ………………………..1
At ( x k 1 , y k 1 ) ,
y k 1  mx k 1  b …………….2
subtracting 1 from 2 we get-
y k +1− y k =m( x k +1 −x k )
Here ( y k 1  y k ) is increment in y as corresponding increment in x.
∴Δy=m. Δx ………………3
y
or m  ………………….4
x
When the value of m is calculated using equation 4, test for three cases can be performed as
Case I: For |m| < 1,
△x can be set to small increment (Generally 1) and the corresponding △y
calculated from equation 3.
Case II: For |m| > 1,
△y can be set to small increment (Generally 1) and the corresponding △x
calculated from equation 3.
Case III: For |m| = 1,
△y=△x, x and y pixels both are equal.

Compiled by: Mohan Bhandari 1

DDA Algorithm
It is a scan conversion line algorithm based on calculation either △x or △y using equation
m=△y/△x.
We sample the line at unit interval in one direction (X if △x is greater than △y otherwise
in y direction) and determine the corresponding integer values nearest the line path for
the other coordinate.
➢ Algorithm
Consider a line with positive slope as shown in the figure below

The equation of the line is given,

y = mx+b …………….……………….(i)
m = (y2-y1)/(x2-x1) ………………….(ii)
For any interval △x, corresponding interval is given by △y = m.△x.
Case I:
If |m| ≤ 1, we sample at unit x interval i.e △x = 1.
xk+1 = xk+1
Then we compute each successive y-values, by setting △y = m
yk+1 = yk + m
The calculated y value must be rounded to the nearest integer
Case II:
If |m| > 1, we sample at unit y-interval i.e △y = 1 and compute each successive x-
values.
yk+1 = yk + 1
Therefore, 1 = m.△x, and △x = 1/m (since, m=△y/△x and △y=1).
xk+1 = xk + 1/m
The above equations are under the assumption that lines are to be processed from left
endpoints (xk, yk) to right endpoints (xk+1, yk+1).
➢ Advantage of DDA
a. It is simple to understand.
b. It is faster method than direct use of line equation y=mx+c.
(Removes multiplication operation and only involve increments operation of x or y
direction)
c. It requires no special skills for implementation
➢ Disadvantages of DDA
a. A floating point addition is still needed in determining each successive point which
is time consuming.
b. The accumulation of round off error in successive addition of the floating point
increments may cause the calculated pixel position to drift away from the true line path
for long line segment.
Compiled by: Mohan Bhandari 2
 ➢ The other possible combinations can be as:

Numerical Examples for DDA

Q. Consider a line from (2,1) to (8,3). Using simple DDA algorithm, rasterize this line.
Given,
Starting Point :(x1, y1)= (2,1)
Ending Point: (x2,y2) = (8,3)
Now,
Slope m=(y2-y1)/(x2-x1)= (3-1)/(8-2) =(1/3) = 0.333
Since |m|<1, From DDA algorithm we have
Xk+1 = Xk + 1
Yk+1 = Yk + m
X Y X-Plot Y-Plot (X,Y)
2 1 2 1 (2,1)
3 (2+1) 1.33 (1+0.33) 3 1 (3,1)
4 (3+1) 1.66 (1.33+0.33) 4 2 (4,2)
5 1.993 5 2 (5,2)
6 2,326 6 2 (6,2)
7 2.659 7 3 (7,3)
8 2.999 8 3 (8,3)

Compiled by: Mohan Bhandari 3

Q. Digitized the line with end points (0,0) and (4,5) using DDA.
Given Starting Point :(x1, y1)= (0,0) and Ending Point: (x2,y2) = (4,5)
Now Slope m=(y2-y1)/(x2-x1)= (5-0)/(5-0) =(5/4) = 1.25
Since |m|>1, From DDA algorithm we have
yk+1 = yk + 1
xk+1 = xk + (1/m)

X Y X-Plot Y-Plot (X,Y)

0 0 0 0 (0,0)
0.8 1 1 1 (1,1)
1.6 2 2 2 (2,2)
2.4 3 2 3 (2,3)
3.2 4 3 4 (3,4)
4 5 4 5 (4,5)

Q. Digitized the line with end points (3,7) and (8,3) using DDA.
Given Starting Point :(x1, y1)= (3,7) and Ending Point: (x2,y2) = (8,3)
Now Slope m=(y2-y1)/(x2-x1)= (3-7)/(8-3) =(-4/5) = -0.8
Since |m|<1, From DDA algorithm we have
Xk+1 = Xk + 1
Yk+1 = Yk + m

X Y X-Plot Y-Plot (X,Y)

3 7 3 7 (3,7)
4 7-0.8=6.2 4 6 (4,6)
5 5.4 5 5 (5,5)
6 4.6 6 5 (6,5)
7 3.8 7 4 (7,4)
8 3 8 3 (8,3)

Q. Consider a line from (0,0) to (5,5). Using simple DDA algorithm, rasterize this line.
Solution:
Given Starting Point :(x1, y1)= (0,0) and Ending Point: (x2,y2) = (5,5)
Now Slope m=(y2-y1)/(x2-x1)= (5-0)/(5-0) =(/55) = 1
Since |m|<=1, From DDA algorithm we have
Compiled by: Mohan Bhandari 4
 Xk+1 = Xk + 1
Yk+1 = Yk + m
X Y X-Plot Y-Plot (X,Y)
0 0 0 0 (0,0)
1 1 1 1 (1,2)
2 2 2 2 (2,2)
3 3 3 3 (3,3)
4 4 4 4 (4,4)
5 5 5 5 (5,5)

Bresenham’s Line Algorithm

An accurate and efficient line generating algorithm, developed by Bresenham that scan
converts lines only using integer calculation to find the next (x,y) position to plot. It avoids
incremental error accumulation.

Line with positive slope less than 1 (|m| ≤ 1)

Pixel position along the line path are determined by sampling at
unit x intervals. Starting from left end point, we step to each
successive column and plot the pixel closest to line path.

Assume that (xk,yk) is pixel at kth step then next point to plot may
be either ( x k  1, y k ) or ( x k  1, y k  1)

At sampling position xk+1, we label vertical pixel separation from

line path as d1 and d2 as in figure. The y-coordinate on the
mathematical line path at pixel column xk+1 is y=m(xk+1)+b
Then d1 = y - yk
= m(xk + 1) + b - yk
d2 =( yk + 1) - y
= (yk + 1)-m ( xk + 1 ) - b
Now d1 - d2 = [m(xk + 1) + b –yk ] - [(yk + 1) - m ( xk + 1 ) - b]
= m(xk + 1) + b –yk - (yk + 1) + m ( xk + 1 ) + b
= 2m ( xk + 1 ) - ( yk + 1 ) - yk + 2b
= 2m (xk + 1) - 2yk + 2b – 1

A decision parameter pk for the kth step in the line algorithm can be obtained by substituting
y
m in above eqn and defining
x
p k  x ( d 1  d 2 )
Δy
= Δx[2 ( x +1)−2 y k +2 b−1]
Δx k
=2 Δy . x k−2 Δx . y k +2 Δy+ Δx(2 b−1)
 2y.x k  2x. y k  c Where the constant c=2 Δy+ Δx (2 b−1 ) which is independent.

If decision parameter pk is negative i.e. d1 < d2, pixel at yk is closer to the line path than pixel at
yk+1 . In this case we plot lower pixel ( xk + 1 , yk) other wise plot upper pixel (xk+1,yk+1).

At step k+1, pk+1 is evaluated as:

p k 1  2y.x k 1  2xy k 1  c
We get,
Compiled by: Mohan Bhandari 5
 pk +1− p k =2 Δy( x k +1−x k )−2 Δx ( y k +1 − y k )

Since we are sampling at X-direction, we have x k 1  x k  1

∴ pk +1 =p k +2 Δy−2 Δx( y k +1 − y k )
The term y k 1  y k is either 0 or 1 depending upon the sign of p k .
So,
if pk is negative
yk+1 = yk and Pk+1 = pk+ 2 y
otherwise
yk+1 = yk+1, then pk+1 = pk+ 2 y -2 x

Q. If the starting point is (x0 , y0 ), then what will be the value of initial decision
parameter (P0) when |m| ≤ 1?
We have Pk = ∆x(d1 - d2)
Pk = ∆x (2m(xk +1) - 2yk + 2b -1)
Pk = ∆x (2mxk +2m + 2b - 2yk -1)
Pk = ∆x {2(mxk + b - yk )+2m -1)
The line y = mx + b must passes through the initial point (x 0, y0) and hence (mxk+b -
yk) = 0, we have
Thus, P0 = ∆x (2m -1)
P0 = ∆x (2 ∆y/∆x - 1)
P0 = 2∆y - ∆x, which is the initial decision parameter.

Conclusion for Bresenham’s Line drawing Algorithm for slope, |m| ≤ 1

a) Calculate the starting value of the decision parameter: P 0 = 2∆y - ∆x.
b) At each xk along the line, starting at k = 0, perform the following test.
If Pk >0,
P k+1 = P k + 2∆y - 2∆x, and y k+1 = y k + 1 & x k+1 = x k +1
Else If Pk<0,
P k+1 = P k + 2∆y , and y k+1 = yk & x k+1 = x k +1

Compiled by: Mohan Bhandari 6

Like wise,
Conclusion for Bresenham’s Line drawing Algorithm for slope, |m| >1
a) Calculate the starting value of the decision parameter: P 0 = 2∆x - ∆y
b) At each yk along the line, starting at k = 0, perform the following test.
If Pk >0,
P k+1 = P k + 2∆x - 2∆y, and xk+1 = xk + 1 & yk+1 = y k +1
Else If P k <0,
P k+1 = P k + 2∆x , and x k+1 = x k & y k+1 = y k +1

Q. Digitize the line with end points (20, 10) and (30, 18) using BLA.
Solution
Here, Starting point of line = (x1, y1) = (20, 10)
Ending point of line = (x2, y2) = (30, 18)
Thus, slope of line,
m = ∆y / ∆x = y2-y1 / x2-x1 = (18-10) / (30-20) = 8/10
As the given points, it is clear that the line is moving left to right,
|m| = 0.8 ≤ 1
Thus,
The initial decision parameter (P0) = 2∆y - ∆x = 2*8 – 10 = 6
Since, for the Bresenham’s Line drawing Algorithm of slope, |m| ≤ 1, we have
If Pk >0,
P k+1 = P k + 2∆y - 2∆x, and y k+1 = y k + 1 & x k+1 = x k +1
Else If Pk<0,
P k+1 = P k + 2∆y , and y k+1 = yk & x k+1 = xk +1

Compiled by: Mohan Bhandari 7

Q. Apply Bresenham’s algorithm to draw a line from (20,15) and end point is
(30,30)
Solution
Starting Point (x0,y0) = (20, 15)
Ending Point (xn, yn) = (30, 30) such that scanning takes place from left to right
Slope m = (30-15)/ ( 30-20) = 1.5 i.e. |M|>1
Here: Δx= 30-20 = 10
Δy= 30-15 = 15
2Δx = 2 * 10 = 20
2Δy = 2 * 15 = 30
Now from Bresenhams Algorithm for |M|>1, and scanning from left to right
Initial Decision Parameter:
p0 = 2Δx – Δy = 20-15= 5
if(pk<0) then
Xk+1 = Xk
Yk+1 = Yk+1
Pk+1 = Pk + 2Δx
otherwise
Xk+1 = Xk+1
Yk+1 = Yk+1
Pk+1 = Pk + 2Δx - 2Δy

K Pk (Xk+1, Yk+1)
0 5 (21,16)
1 -5 (21,17)
2 15 (22,18)
3 5 (23,19)
4 -5 (23,20)
5 15 (24,21)
6 5 (25,22)
7 -5 (25,23)
8 15 (26,24)
9 5 (27,25)
10 -5 (27,26)
11 15 (28,27)
12 5 (29,28)
13 -5 (29,29)
14 15 (30,30)

Compiled by: Mohan Bhandari 8

Q. Apply Bresenham’s algorithm to draw a line from (-3,0) and end point is (4,4)
Solution
Starting Point (x0,y0) = (-3, 0)
Ending Point (xn, yn) = (4,4) such that scanning takes place from left to right
Slope m = (4-0)/ ( 4+3) = 4/ 5 = 0.57 i.e. |M|<1
Here:
Δx= 4 + 3 = 7
Δy= 4 - 0 = 4
2Δx = 2 * 7 = 14
2Δy = 2 * 4 = 8
Now from Bresenhams Algorithm for |M|<1, and scanning from left to right
Initial Decision Parameter: P0 = 2Δy – Δx
if(pk<0) then
Xk+1 = Xk + 1
Yk+1 = Yk
Pk+1 = Pk + 2Δy
otherwise
Xk+1 = Xk+1 and
Yk+1 = Yk+1 and
Pk+1 = Pk + 2Δy - 2Δx
K Pk (Xk+1, Yk+1)
0 1 (-2,1)
1 -5 (-1,1)
2 3 (0,2)
3 -3 (1,2)
4 5 (2,3)
5 -1 (3,3)
6 7 (4,4)

Advantage of BLA over DDA

➢ In DDA algorithm each successive point is computed in floating point, so it requires more
time and more memory space. While in BLA each successive point is calculated in
integer value or whole number. So it requires less time and less memory space.
➢ In DDA, since the calculated point value is floating point number, it should be rounded at
the end of calculation but in BLA it does not need to round, so there is no accumulation
of rounding error.
➢ Due to rounding error, the line drawn by DDA algorithm is not accurate, while in BLA line
is accurate.
➢ DDA algorithm cannot be used in other application except line drawing, but BLA can be
implemented in other application such as circle, ellipse and other curves.

Compiled by: Mohan Bhandari 9

Symmetry in circle scan conversion
Symmetry simply means the exact correspondence on either side of a dividing line, plane , center or
axis.
In circle, we can reduce the time required for circle generation by using the symmetries. e.g. 4-way or 8-
way symmetry. So we only need to generate the points for one quadrant or octants and then use the
symmetry to determine all the other points.

Y
Y (-y,x) (y,x)
● ●

(-x,y) ●
(x,y)
●
(-x,y) ● ● (x,y)

● ● X
X (-x,-y) (x,-y)
● (x,-y)
●
● ●
(-x,-y)
(-y,-x) (y,-x)

8-way symmetry
4-way symmetry

Mid point circle Algorithm

Let us consider a circle centered at origin. Assume that (x, y) is any point on the circle we can easily
compute other seven points on the circle. We can generate all pixel positions around a circle by
calculating only the points within the first octants & positions in the other seven octants are obtained by
symmetry.
For a given radius r, we have to calculate all the pixel position from (0, r).
To apply the midpoint method, we define a circle function:
fcircle(x, y) = x 2 + y 2 –r 2
The relative position of any point (x, y) can be
determined by checking the sign of the circle function
as: -
i. fcircle(x, y) < 0, the point (x, y) is inside the
circle boundary.
ii. fcircle(x, y) = 0, the point (x, y) is on the circle
boundary.
iii. fcircle(x, y) > 0, the point (x, y) is outside the
circle boundary.
Suppose, (xk,yk) is the pixel plotted, then the next pixel
(xk+1, yk+1) will be either (xk+1 , yk) or (xk+1 ,yk-1 ).
Here,
the mid-point (m) = (xk+1, yk-1/2).
Now, decision parameter (Pk) = fcircle(xk+1, yk-1/2) = (xk+1)2 + (yk-1/2)2 – r2, is the circle function
evaluated at midpoint.
Also, the next pixel to plot will either be (x k+1 +1, yk+1 ) or (x k+1 +1, y k+1 -1)
Also, the midpoint here is (xk+1 +1, y k+1 -1/2)
And the next decision parameter Pk+1 = fcircle(xk+1 +1, yk+1 -1/2)
Pk+1 = (x k+1 +1)2 + (y k+1 -1/2)2 –r2
P k+1 = {(x k +1) +1}2 + (y k+1 -1/2)2 –r 2
P k+1 = (x k +1)2 + 2(x k +1) + 1 + (yk+1 -1/2)2 –r2

Compiled by: Mohan Bhandari 10

Now, subtracting Pk+1 and Pk , we have
P k+1 - P k = {(x k +1)2 + 2(x k +1) + 1 + (yk+1 -1/2)2 –r2} - {(xk+1)2 + (yk-1/2)2 – r2}
2 2
= 2(x k +1) + 1+ yk+12 – yk+1 + ½ – yk2+ yk - ½
2 2
= 2(x k +1) + (y k+1 - y k ) - (yk+1 - y k ) +1
If Pk< 0, the midpoint is inside the circle and the pixel on the scan line y k closer to the circle boundary.
Otherwise, the midpoint is outside or on the circle boundary, and we select the pixel on scan line yk -1.
Case Pk< 0:
x k+1 = x k +1
y k+1 = y k
P k+1 = P k + 2(x k +1) + 1
P k+1 = P k + 2 x k+1 + 1
Case Pk >= 0:
xk+1 = xk +1
yk+1 = yk - 1
Pk+1 = Pk + 2(x k +1) + [(y k -1) 2 - y k2 )] - (y k - 1 - y k ) +1
= Pk + 2(x k +1) + [(y k 2 - 2y k +1 - y k2 )] - (y k -1- y k ) + 1
= Pk + 2(x k +1) - 2y k +1 +1 + 1
= Pk + 2(x k +1) - 2y k +2 + 1
= Pk + 2(x k +1) – 2(y k -1) +1
= Pk + 2x k+1 – 2y k+1 +1
Q. Calculate the initial decision parameter (P0) for circle
The initial decision parameter is obtained by evaluating the circle function at the start position (x 0 , y 0 ) =
(0, r).
Here, the next pixel will either be (1, r) or (1, r-1) where the midpoint is (1, r- ½ ). Thus, the initial
decision parameter is given by:
P 0 = f circle (1, r- ½ )
= 1 2 + (r – ½ )2 – r 2
= 5/4 – r
≈1–r
Thus, P 0 =1 – r
Conclusion:
1. Calculate the initial decision parameter (P 0 ) =1 – r
2. If P < 0
Plot (x k +1, y k )
P k+1 = P k + 2x k+1 + 1
Else (P >= 0)
Plot (x k +1, y k - 1)
P k+1 = P k +2x k+1 – 2y k+1 +1

Q. Digitized the circle with radius 10

Solution:
Initial Point = (Xo,Yo)= (0,r) = (0,10) and origin = (0,0)
Initial decision parameter (p0) = 1 – r
= 1 – 10
= -9
From midpoint circle algorithm we have
If P < 0
Plot (x k +1, y k )
Pk+1 = P k + 2x k+1 + 1
Else (P >= 0)
Compiled by: Mohan Bhandari 11
 Plot (x k +1, y k - 1)
P k+1 = P k +2x k+1 – 2y k+1 +1
Now, the successive decision parameter values and position along the circle path are determined as
follow.

K Pk Xk+1 YK+1 (XK+1, Yk+1)

0 -9 1 10 (1,10)
1 -9*2*1+1=-6 2 10 (2,10)
2 -6 + 2*2+1=-1 3 10 (3,10)
3 -1 + 2 * 3 + 1 = 6 4 9 (4,9)
4 6 + 2 * 4 – 2 * 9 + 1 =-3 5 9 (5,9)
5 -3 + 2 * 5 + 1= 8 6 8 (6,8)
6 8+2*6–2*8+1=5 7 7 (7,7)
7 5+ 2 * 7-2 * 7 + 1 =6 8 6 [stop and discard this point since x>y

(0,0)

Q. Digitized a circle with radius r=12 and centered at (250,300)

Solution:
Note: When center is not origin, we first calculate the octants points of the circle in the same way as
the center at origin then add the given circle center on each calculated pixels.

Here, Initial Point (x0,y0) = (0,r) = (0,12) and origin=(0,0)

Initial decision parameter (p0) = 1 – 12 = 1 – 12 = -11
From midpoint circle algorithm we have
If P < 0
Plot (x k +1, y k )
Pk+1 = P k + 2 x k+1 + 1
Else (P >= 0)
Plot (x k +1, y k – 1)
P k+1 = P k +2x k+1 – 2y k+1 +1
Now, the successive decision parameter values and position along the circle path are
determined as follow.
K Pk Xk+1 Yk+1 (Xk+1, Yk+1) at (0,0) (Xk+1, Yk+1) at (250,300)
0 -11 1 12 (1,12) (250+1, 300+12)=(251,312)
1 -11 + 2* 1 + 1 = -8 2 12 (2,12) (250+2,300+12) =(252,312)
2 -8 + 2 * 2 + 1 = -3 3 12 (3,12) (250+3,300+12) =(253,312)
3 -3 + 2 * 3 + 1=4 4 11 (4,11) (250+4,300+11) =(254,311)
4 4 + 2 * 3 – 2 * 11 + 1= -9 5 11 (5,11) (250+5,300+11) =(255,311)
5 -9 + 2 * 5 + 1 = 2 6 10 (6,10) (250+6,300+10) =(256,310)
6 2 + 2*6 – 2* 10 + 1 = -5 7 10 (7,10) (250+7,300+10) =(257,310)
7 -5 + 2 * 7 + 1 = 10 8 9 (8,9) (250+8,300+9) =(258,309)
8 10+ 16 – 18 + 1= 9 9 8 (Discard and stop
since X>Y)

Compiled by: Mohan Bhandari 12

Midpoint Ellipse Algorithm
Our approach here is similar to that used in displaying a raster circle but the ellipse has 4-way
symmetry. The midpoint ellipse method is applied throughout the first quadrant in two parts or region as
shown in figure.
The region-1 just behaves as the circular property and the region- 2
is slightly straight curve.
We have,
The equation of ellipse, whose centre at (0, 0) is
x2 / a2 + y 2/ b 2 = 1
Hence, we define the ellipse function for centre at origin (0, 0) as:
F ellipse (x, y) = x 2b 2 + y 2a 2 – a 2 / b 2
This has the following properties:
< 0, if (x, y) is inside the ellipse boundary
Fellipse (x, y) = 0, if (x, y) is on the ellipse boundary
> 0, if (x, y) is outside the ellipse boundary
Starting at (0, b), we take unit steps in the x direction until we reach the boundary between region 1 and
region 2. Then we switch to unit steps in the y direction over the remainder of the curve in the first
quadrant. At each step, we need to test the value of the slope of the curve. The ellipse slope is
calculated by differentiating the ellipse function as:
2 x b2 + 2 y a 2 * dy / dx = 0
Or
dy / dx = - 2xb 2 / 2ya 2
At the boundary between region 1 and region 2, dy / dx = - 1 and 2 x b 2 = 2 y a2 . Therefore, we move
out of region 1 whenever 2xb 2 >= 2ya2
For Region – 1: Condition (2xb2< 2ya2)
Assuming that the position (x k , y k ) has been plotted, we determine next position (xk+1 , yk+1 ) as either
(xk+1 , yk ) or (x k+1 , yk-1 ) by evaluating the decision parameter P1k as:
P1 k = F ellipse (x k +1, yk – ½ )
= b2(x k +1) 2 + a 2 (y k – ½ ) 2 –a2b 2
At next sampling position, the decision parameter will be
P1k+1 = Fellipse(xk+1 +1, yk+1 – ½ )
= b2(xk+1 +1) 2 + a 2 (yk+1 – ½ ) 2 – a2b 2
= b2{(xk +1) +1} 2 + a2(yk+1 – ½ ) 2 – a2b 2
= b 2 {(xk +1) 2 + 2(xk +1) + 1} + a 2(yk+1 – ½ ) 2 – a 2b 2
Now, P1k+1 – P1k = (b {(x +1) + 2(x +1) + 1} + a (y – ½ ) – a b ) - (b (x +1) + a
2
k
2
k
2
k+1
2 2 2 2
k
2 2
(y k – ½ ) 2 – a 2b 2 )
= (b (x +1) + 2b (x +1) + b + a (y ) – a y + a ¼ – a b ) - (b (x
2
k
2 2
k
2 2
k+1
2 2
k+1
2 2 2 2
k +1) 2 + a 2 y k2 – a 2y k+a 2 ¼ –

ab )
2 2

= 2b 2 (xk +1) + b 2 + a 2{((y ) – y ) -(y k+1 – y k )}

k+1
2
k
2

If Pk < 0, the midpoint is inside the ellipse and the pixel on the scan line y k closer to the ellipse boundary.
Otherwise, the midpoint is outside or on the ellipse boundary, and we select the pixel on scan line y k -1.
Case: P1k < 0
x k+1 = x k +1
y k+1 = y k
P1k+1 = P1k + 2b 2(x k+1) + b 2
Case I: P1k >=0
x k+1 = x k +1
y k+1 = y k - 1
Compiled by: Mohan Bhandari 13
 P k+1 = P k + 2b 2 (xk +1) + b 2 + a 2{((yk+1)2 – y k2) -(y k+1 – y k )}
= P k + 2b 2 (xk +1) + b 2 + a 2(( y k - 1)2 – y k2) -a 2( y k - 1 – y k )}
= P k +2b 2 (x k +1) + a2 [(y k 2 - 2y k +1 - y k2 )] – a 2 (y k -1- y k ) + b 2
= P k +2b 2 (x k +1) – 2a2 y k + a 2 + a 2 + b 2
= P k +2b 2 (x k +1) – 2a 2 (y k -1) + b 2
= P k +2b 2 x k+1 – 2a 2 y k+1 + b 2
Initial decision parameter (P10 ) for region-1 of ellipse
The initial decision parameter is obtained by evaluating the ellipse function at the start position (x 0,y0 )
=(0, b).
Here, the next pixel will either be (1, b) or (1, b-1) where the midpoint is (1, b- ½). Thus, the initial
decision parameter is given by:
P10 = F ellipse (1, b- ½)
= b 2 + a 2 (b- ½) 2 – a 2 b 2
= b 2 – a 2 b + a 2/4
For Region – 2: Condition (2xb2 >= 2ya2)
Assuming that the position (xk ,yk ) has been plotted, we determine next position (x k+1, yk+1 ) as either
(xk+1 , yk-1 ) or (xk, yk-1 ) by evaluating the decision
parameter P2 k as:
P2k = Fellipse (x k + ½ , y k -1)
= b2(x k + ½ )2 + a2(yk -1)2 – a2b2
At next sampling position, the decision parameter will be
P2 k+1 = F ellipse (xk+1 + ½ , y k+1 -1)
= b2(x k+1 + ½ )2 + a 2(y k+1 -1) 2 – a2b2

Now, subtracting P2k from P2K+1, we have

P2k+1 – P2k = {b2(xk+1 + ½ )2 + a 2 (yk+1-1)2 - a2b2 } - {b (x2

k + ½ )2 + a2(yk -1)2 – a2b2}

= {b2(xk+1 + ½ )2 + a 2 (yk+1-1)2 - a2b2 - b2(x k + ½ )2 - a2(yk -1)2 + a2b2}

= {b2(xk+1 + ½ )2 + a2 (yk+1-1)2 - b (x
2
k + ½ )2 - a2(yk -1)2}

= b2(xk+1 + ½ )2 + a2 {(yk-1)-1}2 - b (x
2
k + ½ )2 - a2(yk -1)2

= b2xk+12+ b2xk+1 + b2/4 + a2(yk -1)2 - 2a2(yk -1) +a2 - b2xk2 – b2xk - b2/4 -a2(yk -1)2

= a2 + b2(xk+12 -xk2) - 2a2(yk -1) + b2(xk+1 -xk)

If Pk<0, the midpoint is inside the ellipse and the pixel on the scan line x k is closer to the ellipse
boundary. Otherwise, the midpoint is outside or on the ellipse boundary, and we select the pixel on scan
line x k +1.
Case : P2 k ≤ 0
x k+1 = x k +1
y k+1 = y k -1

P2 k+1 = P2 k + b 2 [(xk+12 -xk2 ) + ( xk+1 -xk )] - 2a2(yk -1) + a2

Compiled by: Mohan Bhandari 14

 = P2 k + b 2 [(x k2 + 2 x k + 1 - x k2 )]+ (x k +1 - x k )] – 2a 2 (y k -1) + a 2

= P2 k + b 2 [2x k +1+1] – 2a 2 (y k -1) + a 2

= P2 k + 2b2(x k +1) – 2a 2 (y k -1) + a 2
= P2 k + 2b 2 x k+1 – 2a 2 y k+1 + a 2
Case P2k > 0
x k+1 = x k
y k+1 = y k - 1

P2 k+1 = P2 k + b 2 [(xk+12 -xk2 ) + ( xk+1 -xk )] - 2a2(yk -1) + a2

= P2 k – 2a 2 (y k -1) + a 2
= P2 k – 2a 2 y k+1 + a 2
Initial decision parameter (P20) for region-2 of ellipse
When we enter region 2, the initial position (xo, y 0 ) is taken as the last position selected in region 1 and
the initial derision parameter in region 2 is given by:
P2 0 = F ellipse (x 0 +1/2, y 0 -1)
= b 2 (x0 +1/2) 2 + a 2 (y 0 -1) 2 –a 2 b 2
Q. Example: Given input ellipse parameters rx = a = 8 and r y = b = 6, we illustrate
the steps in the midpoint ellipse algorithm by determining raster positions along
the ellipse path in the first quadrant.
Solution:
Given a = 8 and b= 6
For Region 1
The initial point for the ellipse on the origin (xo, yo) = (0, b) = (0,6)
Calculation the initial decision parameter
P10 = b 2 – a 2 b + a 2/4
= 62 - 6 * (8)2+(82 / 4)
= -332
From midpoint algorithm, for Region 1 we know,
If(P1k<0) then
x k+1 = x k +1
y k+1 = y k
P1 k+1= P1k + 2b 2x k+1+ b 2
Else (i.e. P1k >=0)
x k+1 = x k +1
y k+1 = y k - 1
P1 k+1= P1 k +2b 2 x k+1 – 2a 2 y k+1 + b 2
And stop when 2xk+1b2 >= 2yk+1a2
Now successive decision parameter values and positions along the ellipse path are
calculated using midpoint method as
K P1k (Xk+1, YK+1) 2b 2(x k+1) 2a 2 y k+1
0 -332 (1, 6) 72 768
1 -224 (2, 6) 144 768
2 -44 (3, 6) 216 768
3 208 (4, 5) 288 640
4 -108 (5, 5) 360 640
5 288 (6, 4) 432 512
6 244 (7, 3) 540 384

Compiled by: Mohan Bhandari 15

 Since 2xk+1b2 >= 2yk+1a2 so we stop here for region 1.
[note: (7, 3) is the starting point for region 2]

Now for Region-2,

From midpoint algorithm, for Region 2 we know,
Initial Decision Parameter:
P2 0 = b 2 (x0 +1/2) 2 + a 2 (y 0 -1) 2 –a 2 b 2
If(Pk<0) then
Xk+1 = Xk + 1
Yk+1 = Yk - 1
P2 k+1 = P2k + 2b 2 x k+1 – 2a 2 y k+1 + a 2
Else (i.e. Pk >=0)
Xk+1 = Xk
Yk+1 = Yk -1
P2K+1 = P2k – 2a 2 y k+1 + a 2
So, the initial point for region 2 is (x0, y0) = (7, 3) and the initial decision parameter is
P20 = b 2 (x0 +1/2) 2 + a 2 (y 0 -1) 2 –a2b 2
= 36 * (7 + 0.5)2 + 64 * (3-1)2 – 64 * 36
= -23
The remaining pixels in region two for first quadrant are than calculated as
K P2k (Xk+1, YK+1)
0 -23 (8,2)
1 361 (8,1)
2 297 (8,0)
So remaining points in other quadrants can be calculated using the symmetry property of
ellipse.

Filled Area Primitive

A standard output primitive in general graphics is solid color or patterned polygon area. Other kinds of
area primitives are sometimes available, but polygons are easier to process since they have linear
boundaries. The main idea behind the 2D or 3D object filling procedure is that it provides us more
realism on the object of interest.
There are two basic approaches to area filling in raster systems.
➢ One way to fill an area is to determine the overlap intervals for scan lines that crosses the area.
➢ Another method for area filling is to start from a given interior position and point outward from this
until a specified boundary is met.

SCAN-LINE Polygon Fill Algorithm:

In scan-line polygon fill algorithm, for each scan-line crossing a polygon, it locates the intersection points
of the scan line with the polygon edges. These intersection points are then sorted from left to right, and
the corresponding frame-buffer positions between each intersection pair are set to the specified color.

In this method, the scan line must be even. At two edge

connecting point called the vertex, we count the scan line two to
handling the problem for scan line passing through vertex, but
this consideration also may creates problem for some instant as
shown in figure. To handle such problem shown by count-5, we
keep the vertex blank and hence the count become 1, so that
overall count in that scan line become even as shown in figure

Compiled by: Mohan Bhandari 16

Boundary-fill Algorithm:
In Boundary filling algorithm starts at a point called seed pixel inside a region and paint the interior
outward the boundary. If the boundary is specified in a single color, the fill algorithm proceeds outward
pixel by until the boundary color is reached.
Starting from (x,y), the procedure tests neighbouring positions to determine whether they are of
boundary color. If not, they are painted with the fill color, and their neighbours are tested. This process
continue until all pixel up to the boundary color area have tested.
The neighbouring pixels from current pixel are proceeded by two
method:
✗ 4- connected if they are adjacent horizontally and
vertically.
✗ 8- connected if they adjacent horizontally, vertically
and diagonally.

Algorithm for Boundary fill 4- connected: 4- Connected 8- Connected

void Boundary_fill4(int x,int y,int b_color, int fill_color)
{
int value=getpixel (x,y);
if (value ! = b_color && value != fill_color)
{
putpixel (x,y,fill_color);
Boundary_fill4(x-1,y, b_color, fill_color);
Boundary_fill4(x+1,y, b_color, fill_color);
Boundary_fill4(x,y-1, b_color, fill_color);
Boundary_fill4(x,y+1, b_color, fill_color);
}
}

Algorithm for Boundary fill 8- connected:

void Boundary-fill8(int x,int y,int b_color, int fill_color)
{
int current =getpixel(x,y);
if (current != b_color && current != fill_color)
{
putpixel (x,y,fill_color);
Boundary_fill8(x-1,y,b_color,fill_color);
Boundary_fill8(x+1,y,b_color,fill_color);
Boundary_fill8(x,y-1,b_color,fill_color);
Boundary_fill8(x,y+1,b_color,fill_color);
Boundary_fill8(x-1,y-1,b_color,fill_color);
Boundary_fill8(x-1,y+1,b_color,fill_color);
Boundary_fill8(x+1,y-1,b_color,fill_color);
Boundary_fill8(x+1,y+1,b_color,fill_color);
}
}

Recursive boundary-fill algorithm not fill regions correctly if some interior pixels are already displayed in
the fill color. Encountering a pixel with the fill color can cause a recursive branch to terminate, leaving
other interior pixel unfilled. To avoid this we can first change the color of any interior pixels that are
initially set to the fill color before applying the boundary fill procedure.

Compiled by: Mohan Bhandari 17

Flood-fill Algorithm:
Flood_fill Algorithm is applicable when we want to fill an area that is not defined within a single color
boundary. If fill area is bounded with different color, we can paint that area by replacing a specified
interior color instead of searching of boundary color value. This approach is called flood fill algorithm.
We start from a specified interior pixel (x,y) and reassign all pixel values that are currently set to a given
interior color with desired fill_color.
Using either 4-connected or 8-connected region recursively starting from input position, The algorithm
fills the area by desired color.
Algorithm:
void flood_fill4(int x,int y,int fill_color,int old_color)
{
int current;
current = getpixel (x,y);
if (current == old_color)
{
putpixel (x,y,fill_color);
flood_fill4(x-1,y, fill_color, old_color);
flood_fill4(x,y-1, fill_color, old_color);
flood_fill4(x,y+1, fill_color, old_color);
flood_fill4(x+1,y, fill_color, old_color);
}
}

Boundary Fill Algorithm Flood Fill Algorithm

Area filling is started inside a point with in a Area filling is started from a point and it replaces
boundary region and fill the region with in the the old color with the new color
specified color until it reaches the the boundary.
It is used in interactive packages where we can It is used when we cannot specify the region
specify the region boundary boundary
It is less time consuming It consumes more time
It searches for boundary. It searches for old color

Compiled by: Mohan Bhandari 18