Bresenham-Ellipsen-Algorithmus

 
void DrawEllipseQuadrant(
  int x0, int y0,
  int rx, int ry,
  int color
) {
  const int rx2(rx*rx);
  const int ry2(ry*ry);
  int F(Round(ry2-rx2*ry+0.25*rx2));
  int ddF_x(0);
  int ddF_y(2*rx2*ry);
  int x(0);
  int y(ry);

  SetPixel(x+x0, y+y0, color);
    // while ( 2*ry2*x < 2*rx2*y ) {  we can use ddF_x and ddF_y
  while( ddF_x < ddF_y ) {
    if(F >= 0) {
      y     -= 1;        // south
      ddF_y -= 2*rx2;
      F     -= ddF_y;
    }
    x     += 1;          // east
    ddF_x += 2*ry2;
    F     += ddF_x + ry2;
    SetPixel(x+x0, y+y0, color);
  }
  F = Round(ry2*(x+0.5)*(x+0.5) + rx2*(y-1)*(y-1) - rx2*ry2);
  while( y > 0 ) {
    if(F <= 0) {
      x     += 1;        // east
      ddF_x += 2*ry2;
      F     += ddF_x;
    }
    y     -=1;           // south
    ddF_y -= 2*rx2;
    F     += rx2 - ddF_y;
    SetPixel(x+x0, y+y0, color);
  }
}

Die Multiplikationen mit 2 können ebenfalls durch vorherige Konstantenberechnung eliminiert werden.

Alle vier Quadranten erhält man einfach durch Ausnutzen der Symmetrie! Man zeichnet 4 Pixel in jeder der Schleifen.

Es ist sehr mühsam diesen Bresenham-Ellipsen-Algorithmus auf rotierte Ellipsen anzuwenden, obwohl prinzipiell möglich.

Es treten folgende Schwierigkeiten auf:

• Die Einteilung in acht Oktanten erfordert eine Bestimmung der Punkte, an denen die Steigung 0, 1, -1 oder unendlich beträgt,
  diese liegen i.A. nicht alle genau auf Pixelwerten (was Runden erfordert).
• Die impliziten Gleichungen (Ellipse sowie partielle Ableitungen) enthalten Wurzeln, und können deshalb nicht mehr (einfach) mit ganzzahliger Arithmetik inkrementell berechnet werden.