algorytm Bresenhama

Napisałem javową implementację algorytmu Bresenhama. Jednak nie działa on do końca sprawnie ,bo na krańcach elipsa nie jest okragła tylko prosta ! Wie ktoś jak to rozwiązać ?

public void piksel (Graphics g,int x,int y,int c)
{
   if (c==0) g.setColor( Color.black );
   else g.setColor ( Color.blue );
   
   g.drawLine(x,y,x+1,y);
}
    public void elipsa (Graphics g,int xs,int ys,int rx,int ry)
{
// na podstawie algorytmu kreslenia elipsy Bresenhama
int x,y; //współrzędne punktów na obwodzie elipsy o środku w początku układu współrzędnych
int e,e1,e2; ////wyrażenie błędu dla narysowanego punktu P
int rx2 = rx * rx;
int ry2 = ry * ry;
int kolor=0;
// zaczynamy
x=0;y=ry;
e=0;
int fx=0;
int fy=rx;
while (ry2*x<=rx2*y) //pierwsza petla
{
//zmienimy kolory
if (kolor==0) kolor=1;
else kolor=0;
piksel(g,x+xs,y+ys,kolor); //prawy dolny
piksel(g,x+xs,ys-y,kolor); //prawy gorny
piksel(g,xs-x,y+ys,kolor); //lewy dolny
piksel(g,xs-x,ys-y,kolor);//lewy gorny

e1=e+2*ry2*x+ry2;
e2=e1-2*rx2*y+rx2;
x++;
if ((e1+e2)<0) e=e1;
else
{
e=e2;
y--;
} // koniec petli
while(y>=0)//poczatek petli
{
if (kolor==0) kolor=1;
else kolor=0;   
piksel(g,x+xs,y+ys,kolor); //prawy dolny
piksel(g,x+xs,ys-y,kolor); //prawy gorny
piksel(g,xs-x,y+ys,kolor); //lewy dolny
piksel(g,xs-x,ys-y,kolor);//lewy gorny

e1=e-2*rx2*y+rx2;
e2=e1+2*ry2*x+ry2;
y--;
if((e1+e2)>=0) e=e1;
else
{
e=e2;
x++;
}

}//koniec petli

} 

Poniżej zamieszczam kod apletu javy, rysujący elipsy przy użyciu algorytmu Bresenhama (to raczej już dla innych szukających, nie dla kolegi, bo to pytanie jest jak widzę sprzed roku :) )

import java.applet.Applet;
import java.awt.Color;
import java.awt.Graphics;

public class Bresenham extends Applet {
	int a=700,b=600;
	
	/* Metoda nadpisujaca java.applet.Applet.init */
    public void init() {    	
    	setSize(a,b);
    	setBackground(Color.black);
    }
    
	/* Metoda nadpisujaca java.awt.Container.paint. 
	 * Przykladowe elipsy i prostokat.*/
	public void paint(Graphics g) {
        elipsa(g,300,300,170,120,Color.blue);
        elipsa(g,310,280,280,30,Color.red);
        elipsa(g,300,180,35,30,Color.yellow);
        g.drawRect(1,1,695,595);
    }

	
	/* Metoda rysujaca pojedynczy piksel. */
	private void piksel (Graphics g,int x,int y, Color color){
		g.setColor(color);
	    g.drawLine(x,y,x,y);
	    try {
			Thread.sleep(0,5);
		} catch (InterruptedException e) {
			// kod obslugi bledu
			e.printStackTrace();
		}
	}
	
	/* Metoda rysujaca elipse.
	 * Wykorzystuje algorytm Bresenhama. */
	private void elipsa(Graphics g, int xs, int ys, int rx, int ry, Color color) {
		int x,y; 
		int e,e1,e2; 
		x=0;
		y=ry;
		e=0;
		int rx2 = rx * rx;
		int ry2 = ry * ry;
		
		while (ry2*x <= rx2*y){
			piksel(g,x + xs, y + ys, color);
			piksel(g,x + xs,-y + ys, color);
			piksel(g,-x + xs, y + ys, color);
			piksel(g,-x + xs,-y + ys, color);
			
			e1= e + 2*ry2*x + ry2; 
			e2= e1 - 2*rx2*y + rx2;
			x= x + 1 ;
			if ((e1+e2)<=0)
				e=e1;
			else {
				e=e2;
				y=y-1;
			}
		}		
		while (y>=0){
			piksel(g,x + xs, y + ys, color);
			piksel(g,x + xs,-y + ys, color);
			piksel(g,-x + xs, y + ys, color);
			piksel(g,-x + xs,-y + ys, color);
			
			e1= e -(2*rx2*y) + rx2;
			e2= e1 + (2*ry2*x) + ry2;
			y= y-1;
			if ((e1+e2)>=0)
				e=e1;
			else {
				e=e2;
				x=x+1;
			}			
		}			
	}
}