Computer

Graphics
Bresenham's line drawing algorithm
& Mid Point Circle algorithm

Team Members
Group-I

Assignment Topic : BRESENHARAM'S ALGORITHM (ELIPSE

Drawing)

S.No.

BITS ID

NAME

2011HW6989
8

2011HW6990
0

2011HW6993
SHENBAGAMOORTHY A
2

2011HW6991
3

2011HW6990
9

2011HW6956
9

2011HW6989
3

2011HW6990
4

2011HW6989
6

Group's representative: TANGUTURU SAI KRISHNA

Official Email ID

Personal Email ID

TANGUTURU SAI KRISHNA

saikrishna.tanguturu@wipro.com

sai.tsk2008@gmail.com

RAYAPU MOSES

rayapu.moses@wipro.com

stalinkvd001@gmail.com

shenbagamoorthy.a83@wipro.com

moorthy2626@gmail.com

ANURUPA K C

anurupa.c85@wipro.com

anu.rupa30@gmail.com

ARUNJUNAISELVAM P

arunjunaiselvam.p95@wipro.com

arunjunai.carrer@gmail.com

PRANOB JYOTI KALITA

pranob.kalita@wipro.com

pranob.kalita90@gmail.com

TINNALURI V N PRASANTH

prasanth.tinnaluri@wipro.com

naga.prasanth985@gmail.com

KONDALA SUMATHI

sumathi.kondala@wipro.com

sumathi.kondala@gmail.com

DASIKA KRISHNA

dasika.krishna@wipro.com

dasikakrishnas@gmail.com

Lines
Analog devises, such as a random-scan display
or a vector plotter, display a straight line
smoothly from one endpoint to another. Linearly
varying horizontal and vertical deflection
voltages are generated that are proportional to
the required changes in the x and y directions to
produce the smooth line.

Digital devices display a straight line by plotting

discrete coordinate points along the line path
which are calculated from the equation of the
line.
Screen locations are referenced with integer values, so
plotted positions may only approximate actual line
positions between two specific endpoints.
A computed line position of (10.48, 20.51) will be
converted to pixel position (10, 21). This rounding of
coordinate values to integers causes lines to be displayed
with a stairstep appearance (the jaggies).
Particularly noticeable on systems with low resolution.
To smooth raster lines, pixel intensities along the line
paths must be adjusted.

Line Drawing Algorithms

Cartesian equation:
y = mx + c
where

y2
y1

m slope
c y-intercept

y 2 y1 y
m

x2 x1 x
5

x1

x2

Slope
+ve
if |m| = 1

45
45

= 45

if |m| 1
-45 < < 45

if |m| 1
45 < < 90 or
-90 < < -45

-ve

y=x
m=1
c=0

x
0
1
2
3
4
5
6
7
8
7

|m| =
1
y

y
0
1
2
3
4
5
6
7
8

4
3

1
0

|m|
y=x+ 1
1

m=
c = 1x

round(y)

0
1

1
1.5

1
2

2
3

2
2.5

2
3

4
5

3
3.5

3
4

6
7

4
4.5

4
5

0
0

|m|
y = 3x - 2 1
m=3
c = -2

round(y)

-2

-2

10

10

13

13

16

19

16
outside
19

6
5

0
0

Bresenham Line Algorithm

A more efficient approach
Basis of the algorithm:

A
B
Start position

From start position decide A or B next

10

Bresenham Line Algorithm

True line

ti
si

For a given value of x

11

one pixel lies at distance ti above the line, and

one pixel lies at distance si below the line

Bresenham Line Algorithm

Decision parameter

di = (si - ti)
If di 0, then closest pixel is below true line (si
smaller)
If di 0, then closest pixel is above true line (ti
smaller)

12

We must calculate the new values for di as we

move along the line.

Example:

dy
Let gradient(slope) 0.5 (i.e.
0.5 or
dx

2dy dx)

Start pixel at (x0,y1)

y5

At x1 :

y3

lin
True

y2

y0

13

2dy

dy

y1
x0

x1

x2

x3

3dy

x4

4dy

x5

s1 = dy
t1 = dx - dy
d1 = (si - ti) = dy - (dx - dy) = 2dy
- dx
but 2dy dx di 0 y stays
the same
At
x2next
: pixel is at (x ,y )
hence
1
1
s2 = 2dy
t2 = dx - 2dy
d2 = (s2 t2) = 2dy - (dx - 2dy) =
4dy - dx
Suppose d2 0 y is
incremented
At
x3 next
:
hence
pixel is at (x2,y2)
s3 = 3dy - dx
t2 = 2dx - 3dy
d3 = (s2 t3) = 6dy - 3dx 0
so y stays the same
hence next pixel is at (x3,y2)

In General

For a line with gradient 1

d0 = 2dy dx
if di 0 then yi+1 = yi
di+1 = di + 2dy
if di 0 then yi+1 = yi + 1
di+1 = di + 2(dy dx)
xi+1 = xi + 1

For a line with gradient

1
d0 = 2dx dy
if di 0 then
di+1

xi+1 = xi
= di + 2dx

if di 0 then xi+1 = xi + 1
di+1 = di + 2(dx dy)
14

yi+1 = yi +2dy
1 and 2(dy-dx) can be
Note: For |m| 1 the constants
calculated once,
so the arithmetic will involve only integer addition and

Example

Draw a line from (20,10) to (30,18)

(30,18)

dx = 10
dy = 8
initial decision d0 = 2dy dx = 6
Also 2dy = 16, 2(dy dx) = -4
i

di

(xi+1,yi+1)

0
1
2
3
4
5
6
7
8
9

6
2
-2
14
10
6
2
-2
14
10

(21,11)
(22,12)
(23,12)
(24,13)
(25,14)
(26,15)
(27,16)
(28,16)
(29,17)
(30,18)

19
18
17
16
15
14
13

15

12

(20,10)

void LineBres(int x0, int y0, int x1, int y1)

// line for |m| < 1
{
int dx = abs(x1 x0), dy = abs(y1 y0);
int d = 2 * dy dx, twoDy = 2 * dy, twoDyMinusDx = 2 * (dy
dx);
int x, y;
if (x0 > x1) {
which as end
x = x1;
y = y1;
x1 = x0;
}
else {
x = x0;
y = y0;
}
setPixel(x,y);

16

// determines which point to use as start,

while (x < x1) {

x++;
if (d < 0) d += twoDy;
else {
y++;
d += twoDyMinusDx;
}
setPixel(x, y);
}

Special cases
Special cases can be handled separately
Horizontal lines (y = 0)
Vertical lines (x = 0)
Diagonal lines (|x| = |y|)

directly into the frame-buffer without

processing them through the line-plotting

algorithms.

17

Circle Equations
Polar form

x = rCos
y = rSin

(r = radius of circle)
y
P=(rCos, rSin)
r

rCos )

18

rSin )
x

Drawing a circle
= 0
while ( < 360)
x = rCos
y = rSin
setPixel(x,y)
= + 1
end while

Disadvantages
To find a complete circle varies from 0
to 360
The calculation of trigonometric functions
is very slow.
19

Cartesian form
Use Pythagoras theorem

x2 + y2 = r2

x
y

P x, r 2 x 2
r

y
x

20

Circle algorithms
Step through x-axis to determine y-values

Disadvantages:
21

Not all pixel filled in

Square root function is very slow

Circle Algorithms
Use 8-fold symmetry and only compute

pixel positions for the 45 sector.

(-x, y)

(-y, x)

(x, y)

45

(-y, -x)

(y, -x)

(-x, -y)
22

(y, x)

(x, -y)

Bresenhams Circle Algorithm

Consider only
45 90

General Principle
The circle function:

f circle ( x, y ) x 2 y 2 r 2
and

0 if (x,y) is inside the circle boundary

f circle ( x, y ) 0 if (x,y) is on the circle boundary

0 if (x,y) is outside the circle boundary

23

Bresenhams Circle Algorithm

yi

p1

p3

yi - 1

p2

D(si)
D(ti)

r
xi xi + 1
After point p1, do we choose p2 or p3?
24

Bresenhams Circle Algorithm

Define: D(si) = distance of p3 from circle
D(ti) = distance of p2 from circle
i.e. D(si) = (xi + 1)2 + yi2 r2
[always
+ve]
D(ti) = (xi + 1)2 + (yi 1)2 r2 [always -ve]
Decision Parameter pi = D(si) + D(ti)

so if pi < 0 then the circle is closer to p3 (point

above)
if pi 0 then the circle is closer to p2 (point
below)
25

The Algorithm
x0 = 0
y0 = r
p0 = [12 + r2 r2] + [12 + (r-1)2 r2] = 3
2r
if pi < 0 then
yi+1 = yi
pi+1 = pi + 4xi + 6

xi+1 = xi + 1

else if pi 0 then
yi+1 = yi 1
pi+1 = pi + 4(xi yi) + 10
26

Stop when xi yi and determine

symmetry points in the other octants

Example
r = 10
p0 = 3 2r = -17
Initial point (x0, y0) = (0, 10)
10

i
0

pi
-17

xi, yi
(0, 10)

9
8
7

27

-11

(1, 10)

-1

(2, 10)

13

(3, 10)

-5

(4, 9)

Midpoint Circle Algorithm

yi
yi-1

Midpoin
t
x2 + y2 r2 = 0

xi xi+1 xi+2
Assuming that we have just plotted the pixels at (xi , yi).
Which is next? (xi+1, yi) OR (xi+1, yi 1).
- The one that is closer to the circle.

28

Midpoint Circle Algorithm

The decision parameter is the circle at the

midpoint between the pixels yi and yi 1.

pi f circle ( xi 1, yi 12 )
( xi 1) 2 ( yi 12 ) 2 r 2
If pi < 0, the midpoint is inside the circle and

the pixel yi is closer to the circle boundary.

If pi 0, the midpoint is outside the circle and

the pixel yi - 1 is closer to the circle boundary.

29

Decision Parameters
Decision Parameters are obtained using

incremental calculations

pi 1 f circle ( xi 1 1, yi 1 12 )

Note:
xi+1 = xi +1

( xi 2) 2 ( yi 1 12 ) 2 r 2
OR

pi 1 pi 2( xi 1) 2 ( yi21 yi2 ) ( yi 1 yi ) 1
where yi+1 is either yi or yi-1 depending on the sign of
pi

30

1.

Initial values:- point(0,r)

x0 = 0
y0 = r

2.
3.

The Algorithm

move circle origin at

(0,0) by
Initial decision parameter
x = x xc and y = y yc

p0 f circle (1, r 12 ) 1 ( r 12 ) 2 r 2 54 r

At each xi position, starting at i = 0, perform the

following test: if pi < 0, the next point is (xi + 1,
yi) and
pi+1 = pi + 2xi+1 + 1

If pi 0, the next point is (xi+1, yi-1) and

pi+1 = pi + 2xi+1 + 1 2yi+1

where 2xi+1 = 2xi + 2 and 2yi+1 = 2yi 2

4.
5.

31

6.

Determine symmetry points in the other octants

Move pixel positions (x,y) onto the circular path
centered on (xc, yc) and plot the coordinates: x
= x + x c, y = y + y c
Repeat 3 5 until x y

Example

i
0

r = 10
p0 = 1 r = -9 (if r is integer round p0 = 5/4 r to
integer)
Initial point (x0, y0) = (0, 10)
pi

-9

xi+1, yi+1 2xi+1 2yi+1

(1, 10)

20

10
9
8

-6

(2, 10)

20

-1

(3, 10)

20

32

(4, 9)

18

-3

(5, 9)

10

18

(6, 8)

12

16

(7, 7)

Midpoint function
void plotpoints(int x,
{
setpixel(xcenter+x,
setpixel(xcenter-x,
setpixel(xcenter+x,
setpixel(xcenter-x,
setpixel(xcenter+y,
setpixel(xcenter-y,
setpixel(xcenter+y,
setpixel(xcenter-y,
}

33

int y)
ycenter+y);
ycenter+y);
ycenter-y);
ycenter-y);
ycenter+x);
ycenter+x);
ycenter-x);
ycenter-x);

void circle(int r)
{
int x = 0, y = r;
plotpoints(x,y);
int p = 1 r;
while (x<y) {
x++;
if (p<0) p += 2*x + 1;
else {
y--;
p += 2*(x-y) + 1;
}
plotpoints(x,y);
}
}

Ellipse-Generating Algorithms
Ellipse A modified circle whose radius varies from a

maximum value in one direction (major axis) to a

minimum value in the perpendicular direction (minor axis).

F1

d1

P=(x,y)

F2

d2

The sum of the two distances d1 and d2, between the fixed
positions F1 and F2 (called the foci of the ellipse) to any point P
on the ellipse, is the same value, i.e.
d1 + d2 = constant
34

Ellipse Properties
Expressing distances d1 and d2 in terms of the focal

coordinates F1 = (x1, x2) and F2 = (x2, y2), we have:

( x x1 ) 2 ( y y1 ) 2 ( x x2 ) 2 ( y y2 ) 2 constant
ry
rx

Polar coordinates:
35

y yc
1

rx
ry

Cartesian coordinates:
x xc

x xc rx cos
y yc ry sin

Ellipse Algorithms
Symmetry between quadrants
Not symmetric between the two octants of a

quadrant
Thus, we must calculate pixel positions along
the elliptical arc through one quadrant and
then we obtain positions in the remaining 3
quadrants by symmetry
(-x, y)
(x, y)

ry
rx
(-x, -y)
36

(x, -y)

Ellipse Algorithms
f ellipse ( x, y ) ry2 x 2 rx2 y 2 rx2 ry2
Decision parameter:

0 if ( x, y ) is inside the ellipse

f ellipse ( x, y ) 0 if ( x, y ) is on the ellipse

0 if ( x, y ) is outside the ellipse

Slope = -1
ry

rx
37

2ry2 x
dy
Slope
2
dx
2rx y

Ellipse Algorithms

Slope = -1
1

ry 2
rx

Starting at (0, ry) we take unit steps in the x

direction until we reach the boundary between

region 1 and region 2. Then we take unit steps
in the y direction over the remainder of the
curve in the first quadrant.
At the boundary
dy
2
2

dx

2ry x 2rx y

therefore, we move 2out of2 region 1 whenever

2ry x 2rx y

38

Midpoint Ellipse Algorithm

yi

Midpoin
t

yi-1

xi

xi+1 xi+2

Assuming that we have just plotted the pixels at

(xi , yi).
The next p
position
1 f is( determined
x 1, y 1 ) by:
i

ellipse

ry2 ( xi 1) 2 rx2 ( yi 12 ) 2 rx2 ry2

39

If p1i < 0 the midpoint is inside the ellipse yi is

closer

Decision Parameter (Region

1)
At the next position [xi+1 + 1 = xi + 2]
p1i 1 f ellipse ( xi 1 1, yi 1 12 )
ry2 ( xi 2) 2 rx2 ( yi 1 12 ) 2 rx2 ry2

OR
p1i 1 p1i 2ry2 ( xi 1) 2 ry2 rx2 ( yi 1 12 ) 2 ( yi 12 ) 2

where yi+1 = yi
or
40

yi+1 = yi 1

Decision Parameter (Region 1)

Decision parameters are incremented by:
2ry2 xi 1 ry2
if p1i 0
increment
2
2
2
2
r
x

2
r
if p1i 0
y i 1 y
x yi 1
Use only addition and subtraction by
obtaining 2ry2 x and 2rx2 y
At 2initial
ry2 x 0 position (0, ry)
2rx2 y 2rx2 ry

41

p10 f ellipse (1, ry 12 ) ry2 rx2 ( ry 12 ) 2 rx2 ry2

ry2 rx2 ry 14 rx2

Region 2
Over region 2, step in the negative y direction and
midpoint is taken between horizontal pixels at each
step.
yi

Midpoin
t

yi-1

xi

xi+1 xi+2

Decision parameter:

p 2i f ellipse ( xi 12 , yi 1)
ry2 ( xi 12 ) 2 rx2 ( yi 1) 2 rx2 ry2
42

If p2i > 0 the midpoint is outside the ellipse xi is

closer

Decision Parameter (Region

2)
At the next position [yi+1 1 = yi 2]
p 2i 1 f ellipse ( xi 1 12 , yi 1 1)
ry2 ( xi 1 12 ) 2 rx2 ( yi 2) 2 rx2 ry2

OR
p 2i 1 p 2i 2rx2 ( yi 1) rx2 ry2 ( xi 1 12 ) 2 ( xi 12 ) 2

where xi+1 = xi
or
43

xi+1 = xi + 1

Decision Parameter (Region 2)

Decision parameters are incremented by:
2rx2 yi 1 rx2
increment
2
2
2
2
r
x

2
r
y

r
y i 1
x i 1
x

if p 2i 0
if p 2i 0

At initial position (x0, y0) is taken at the

last position selected in region 1

p 20 f ellipse ( x0 12 , y0 1)
ry2 ( x0 12 ) 2 rx2 ( y0 1) 2 rx2 ry2
44

Midpoint Ellipse Algorithm

1. Input rx, ry, and ellipse center (xc, yc), and obtain the

first point on an ellipse centered on the origin as

(x0, y0) = (0, ry)
2. Calculate the initial parameter in region 1 as

p10 ry2 rx2 ry 14 rx2

3. At each xi position, starting at i = 0, if p1i < 0, the

next point along the ellipse centered on (0, 0) is (xi

+ 1, yi) and

p1i 1 p1i 2ry2 xi 1 ry2

otherwise, the next point is (xi + 1, yi 1) and

p1i 1 p1i 2ry2 xi 1 2rx2 yi 1 ry2

45

and continue until

2ry2 x 2rx2 y

Midpoint Ellipse Algorithm

4. (x0, y0) is the last position calculated in region 1.

Calculate the initial parameter in region 2 as

p 20 ry2 ( x0 12 ) 2 rx2 ( y0 1) 2 rx2 ry2

5. At each yi position, starting at i = 0, if p2i > 0, the

next point along the ellipse centered on (0, 0) is

(xi, yi 1) and
p 2i 1 p 2i 2rx2 yi 1 rx2

p 2the
p 2i point
2ry xi 1is (x
2rix +
yi 1,
rxi 1) and
otherwise,
i 1 next
1 y
2

46

Use the same incremental calculations as in

region 1. Continue until y = 0.
6. For both regions determine symmetry points in
the other three quadrants.
7. Move each calculated pixel position (x, y) onto the
elliptical path centered on (xc, yc) and plot the

Example
rx = 8 ,
2ry2x = 0

ry = 6
(with increment 2ry2 = 72)

2rx2y = 2rx2ry (with increment -2rx2 = -128)

Region 1
(x0, y0) = (0, 6)

p10 ry2 rx2 ry 14 rx2 332

47

pi

xi+1, yi+1 2ry2xi+1

2rx2yi+1

-332

(1, 6)

72

768

-224

(2, 6)

144

768

-44

(3, 6)

216

768

208

(4, 5)

288

640

-108

(5, 5)

360

640

288

(6, 4)

432

512

244

(7, 3)

504

384Move out of region 1 since

2ry2x > 2rx2y

Example
Region 2
(x0, y0) = (7, 3)

(Last position in region 1)

p 20 f ellipse (7 12 , 2) 151
i

pi

-151

(8, 2)

576

256

233

(8, 1)

576

128

745

(8, 0)

6
5
4
3

48

xi+1, yi+1 2ry2xi+1

2rx2yi+1

Stop at y = 0

Midpoint Ellipse Function

void ellipse(int Rx, int Ry)
{
int Rx2 = Rx * Rx, Ry2 = Ry * Ry;
int twoRx2 = 2 * Rx2, twoRy2 = Ry2 * Ry2;
int p, x = 0, y = Ry;
int px = 0, py = twoRx2 * y;

49
}

ellisePlotPoints(xcenter, ycenter, x, y);

// Region 1
p = round(Ry2 (Rx2 * Ry) + (0.25 * Rx2));
while (px < py) {
x++;
px += twoRy2;
if (p < 0) p += Ry2 + px;
else {
y--;
py -= twoRx2;
p += Ry2 + px py;
}
ellisePlotPoints(xcenter, ycenter, x, y);
}
// Region 2
p = round(Ry2 * (x+0.5) * (x+0.5) + Rx2 * (y-1)*(y-1) Rx2 * Ry2;
while (y > 0) {
y--;
py -= twoRx2;
if (p > 0) p += Rx2 py;
else {
x++;
px += twoRy2;
p += Rx2 py + px;
}
ellisePlotPoints(xcenter, ycenter, x, y);
}

Click icon to add picture

Thank You