Experiment-4

AIM: Write a program to implement the Mid-point ellipse algorithm

Theory :
The midpoint ellipse algorithm is a method for drawing ellipses in computer
graphics. This method is modified from Bresenham s algorithm. The
advantage
of this modified method is that only addition operations are required in the
program loops. This leads to simple and fast implementation in all
processors
Let us consider one quarter of an ellipse. The curve is divided into two
regions. In region 1, the slope on the curve is greater than-1 while in region
less than-1

y
Region I
b
dy/dx = –1

Region II

a x

m = –1

Derivation:

Consider the general equation of an ellipse,

b2x2 + a2y2 – a2b2 = 0
where a is the horizontal radius and b is the vertical radius, we can define an
function f(x,y) by which the error due to a prediction coordinate (x,y) can be
obtained. The appropriate pixels can be selected according to the error so that
the required ellipse is formed. The error can be confined within half a pixel.

Set f(x,y) = b2x2 + a2y2 – a2b2

In region I (dy/dx > –1),

(xk, yk)

SE

Prediction
(xk +1, yk –½) Region I
x is always incremented in each step, i.e. xk+1 = xk + 1.
yk+1 = yk if E is selected, or yk+1 = yk – 1 if SE is selected.
In order to make decision between S and SE, a prediction (x k+1, yk–½) is set at
the middle between the two candidate pixels. A prediction function P k can be
defined as follows:

Pk = f(xk+1, yk–½)
= b2(xk+1)2 + a2(yk–½)2 – a2b2
= b2(xk2 + 2xk + 1) + a2(yk2 – yk + ¼) – a2b2

If Pk < 0, select E :

Pk+1E= f(xk+2, yk–½)

= b2(xk+2)2 + a2(yk–½)2 – a2b2
= b2(xk2 + 4xk + 4) + a2(yk2 – yk + ¼) – a2b2

Change of PkE is: PkE = Pk+1E – Pk = b2(2xk + 3)

If Pk > 0, select SE :

Pk+1SE = f(xk+2, yk–3/2)

= b2(xk+2)2 + a2(yk–3/2)2 – a2b2
= b2(xk2 + 4xk + 4) + a2(yk2 – 3yk + 9/4) – a2b2
Change of PkSE is PkSE = Pk+1SE – Pk = b2(2xk + 3) – 2a2(yk – 1)

∆alculate the changes of

C Pk:

If E is selected,
Pk+1E = b2(2xk + 5)
2PkE = Pk+1E – PkE = 2b2

Pk+1SE = b2(2xk + 5) – 2a2(yk – 1)

2PkSE = Pk+1SE – PkSE = 2b2

If SE is selected,
Pk+1E = b2(2xk + 5)
2PkE = Pk+1E – PkE = 2b2

Pk+1SE = b2(2xk + 5) – 2a2(yk – 2)

2PkSE = Pk+1SE – PkSE = 2(a2 + b2)

Initial values:
x0 = 0, y0 = b, P0 = b2 + ¼a2(1 – 4b)
P0E = 3b2, P0SE = 3b2 – 2a2(b – 1)

In region II (dy/dx < –1), all calculations are similar to that in region I except
that y is decremented in each step.
 (xk, yk)

SE

Prediction
(xk +½, yk –1)
Region II

y is always decremented in each step, i.e. yk+1 = yk – 1.

xk+1 = xk if S is selected, or xk+1 = xk + 1 if SE is selected.

Pk = f(xk+½, yk–1)
= b2(xk+½)2 + a2(yk–1)2 – a2b2
= b2(xk2 + xk + ¼) + a2(yk2 – 2yk + 1) – a2b2

If Pk > 0, select S :

Pk+1S= f(xk+½, yk–2)

= b2(xk+½)2 + a2(yk–2)2 – a2b2
= b2(xk2 + xk + ¼) + a2(yk2 – 4yk + 4) – a2b2

Change of PkS is: PkS = Pk+1S – Pk = a2(3 – 2yk)

If Pk < 0, select SE :

Pk+1SE = f(xk+3/2, yk–2)

= b2(xk+3/2)2 + a2(yk–2)2 – a2b2
= b2(xk2 + 3xk + 9/4) + a2(yk2 – 4yk + 4) – a2b2
Change of PkSE is PkSE = Pk+1SE – Pk = 2b2(xk + 1) + a2(3 – 2yk)

Calculate the changes of Pk:

If S is selected,
Pk+1S = a2(5 – 2yk)
2PkS = Pk+1S – PkS = 2a2

Pk+1SE = 2b2(xk + 1) + a2(5 – 2yk)

2PkSE = Pk+1SE – PkSE = 2a2

If SE is selected,
Pk+1S = a2(5 – 2yk)
2PkS = Pk+1S – PkS = 2a2
 Pk+1SE = 2b2(2xk + 2) – a2(5 – 2yk)
2PkSE = Pk+1SE – PkSE = 2(a2 + b2)

Determine the boundary between region I and II:

Set f(x, y) = 0, dy/dx = –bx / [a2√(1 – x2/a2)].

When dy/dx = –1, x = a2√/(a 2 + b2) and y = b 2√/(a 2
+ b 2).

At region I, dy/dx > –1, x < a2√/(a 2 + b2) and y > b 2√/(a 2 + b 2), therefore
PkSE < b 2(2a2/√(a 2 + b 2) – 2a2(b 2/√(a 2 + b2) – 1) = 2a2 + 3b 2

Initial values at region II: x0

= a2√/(a 2
+ b 2)
y0 = b √/(a
2 2
+ b 2)
x0 and y0 will be the accumulative results from region I at the boundary. It is not
necessary to calculate them from values of a and b.
P0 = PkI – ¼[a2(4y0 – 3) + b2(4x0 + 3)] where PkI is the accumulative result from
region I at the boundary.
P0E = b2(2x0 + 3)
P0SE = 2a2 + 3b2
Pseudocode:
DrawEllipse (xC, yC, a, b)
Declare integers x, y, P, PE, PS, PSE, 2PE, 2PS and 2PSE
// Set initial values in region I Set x = 0
and y = b
P = b2 + (a2(1 – 4b) – 2)/4 // Intentionally –2 to round off the value
PE = 3b2
2PE = 2b2
PSE = PE – 2a2(b – 1)
2PSE = 2PE + 2a2
// Plot the pixels in region I
PlotEllipse(xC, yC, x, y) while PSE <
2a2 + 3b2
if P < 0 then // Select E P = P
+ P E

PE = PE + 2PE

PSE = PSE + 2PE
else // Select SE P = P
+ PSE
PE = PE + 2PE
PSE = PSE + 2PSE
decrement y end
if
increment x PlotEllipse(xC, yC,
x, y)
end while
// Set initial values in region II
P = P – (a2(4y – 3) + b2(4x + 3) + 2) / 4 // Intentionally +2 to round off the value
 PS = a2(3 – 2y)
PSE = 2b2 + 3a2
2PS = 2a2
// Plot the pixels in region II while y >
0
if P > 0 then // Select S P = P
+ PE
PE = PE + 2PS
PSE = PSE + 2PS
else // Select SE P = P
+ P SE

PE = PE + 2PS

PSE = PSE + 2PSE
increment x end
if
decrement y PlotEllipse(xC, yC,
x, y)
end while end
DrawEllipse

Code:
#include<iostream>
#include<dos.h>
#include<conio.h>
#include<math.h>
#include<graphics.h>

using namespace std;

void display (int xs1, int ys1, int x, int y);
void ellips1(int xs1,int ys1,int rx, int ry)
{
int x,y;
float d1,d2,dx,dy;
x = 0; // take start position as (0,ry)
y = ry; // finding decision parameter d1
d1 = pow(ry,2) - (pow(rx,2) * ry) + (0.25 * pow(rx,2));
dx = 2 * pow(ry,2) * x;
dy = 2 * pow(rx,2) * y;
do // region one
{
display(xs1,ys1,x,y);
if(d1<0)
{
x++;
dx = dx + (2 * (pow(ry,2)));
d1 = d1 + dx +(pow(ry,2));
}
else
{
x++;
y--;
dx = dx + (2 * (pow(ry,2)));
 dy = dy - (2 * (pow(rx,2)));
d1 = d1 + dx - dy + (pow(ry,2));
}
}while(dx<dy); // change over condition for region-2
do // region two
{
display(xs1,ys1,x,y);
if(d2>0)
{
x = x;
y--;
dy = dy - (2 * (pow(rx,2)));
d2 = d2 - dy + pow(rx,2);
}
else
{
x++;
y--;
dy = dy - (2 * (pow(rx,2)));
dx = dx + (2 * (pow(ry,2)));
d2 = d2 +dx - dy + pow(rx,2);

}
}while(y>0);
}
void display(int xs,int ys,int x,int y)
{
putpixel(xs+x,ys+y,WHITE); // plot points by using 4 point symmetry
putpixel(xs-x,ys-y,WHITE);
putpixel(xs+x,ys-y,WHITE);
putpixel(xs-x,ys+y,WHITE);
}
int main(void)
{
int xs1,ys1;
float rx1,ry1;
int gd = DETECT,gm; // Initialise the graphics system
initgraph(&gd,&gm,"c:\\tc\\bgi");
cout<<"\t\tMidpoint Ellipe Drawing Algorithm\n";
cout<<"Enter the Center Co-ordinates\n";
cout<<"xc = \t";
cin>>xs1;
cout<<"yc = \t";
cin>>ys1;
cout<<"Enter the X Radius\t";
cin>>rx1;
cout<<"Enter the Y Radius\t";
cin>>ry1;
ellips1(xs1,ys1,rx1,ry1);
getch();
closegraph();
}
Output:

Discussion
The algorithm first determines the point for region 1 than proceeds to
calculate for Region 2. The processing time for the algorithm is high.

Finding and Learning

The midpoint method for deriving efficient scan-conversion algorithm to
draw geometric curves on raster displays in described The method is general
and is used to transform the nonparametric equation f(x,y)=0, which
describes the curve into an algorithms that draw the curve
Time Consumption is high
The distance between the pool is not equals so we wont get smooth ellipse.