Es ist nicht einfach, einen kontinuierlichen, glatten Bogen auf dem Computerbildschirm anzuzeigen, da unser Computerbildschirm aus Pixeln besteht, die in Matrixform organisiert sind. Um also einen Kreis auf einem Computerbildschirm zu zeichnen, sollten wir immer die Pixel auswählen, die einem gedruckten Pixel am nächsten liegen, damit sie einen Bogen bilden können. Dafür gibt es zwei Algorithmen:

1. Algorithmus zum Zeichnen von Mittelpunktkreisen
2. Bresenhams Kreiszeichnungsalgorithmus

Wir haben das bereits besprochen Algorithmus zum Zeichnen von Mittelpunktkreisen in unserem vorherigen Beitrag. In diesem Beitrag werden wir über den Kreiszeichnungsalgorithmus von Bresenham diskutieren. 

mylivecriclet

Beide Algorithmen nutzen das Hauptmerkmal des Kreises, dass er hochsymmetrisch ist. Also teilen wir den gesamten 360-Grad-Kreis in 8 Teile mit jeweils einem Oktanten von 45 Grad. Dazu verwenden wir den Kreisalgorithmus von Bresenham zur Berechnung der Positionen der Pixel im ersten Oktanten von 45 Grad. Dabei wird davon ausgegangen, dass der Mittelpunkt des Kreises im Ursprung liegt. Für jedes berechnete Pixel (x y) zeichnen wir also ein Pixel in jedem der 8 Oktanten des Kreises, wie unten gezeigt: 

Jetzt werden wir sehen, wie man die nächste Pixelposition aus einer zuvor bekannten Pixelposition (x y) berechnet. Im Bresenham-Algorithmus haben wir an jedem Punkt (x y) zwei Möglichkeiten, entweder das nächste Pixel im Osten, d. h. (x+1 y), oder im Südosten, d. h. (x+1 y-1), auszuwählen.
 

Und dies kann mithilfe des Entscheidungsparameters d wie folgt entschieden werden: 
 

• Wenn d > 0, ist (x+1 y-1) als nächstes Pixel zu wählen, da es näher am Bogen liegt.
• andernfalls ist (x+1 y) als nächstes Pixel zu wählen.

Um nun den Kreis für einen gegebenen Radius 'r' und Mittelpunkt (xc yc) zu zeichnen, beginnen wir bei (0 r) und bewegen uns im ersten Quadranten bis x=y (d. h. 45 Grad). Wir sollten von der aufgeführten Anfangsbedingung ausgehen: 
 

d = 3 - (2 * r)  
x = 0  
y = r

Nun führen wir für jedes Pixel die folgenden Operationen durch:  

1. Legen Sie die Anfangswerte von (xc yc) und (x y) fest.
2. Setzen Sie den Entscheidungsparameter d auf d = 3 – (2 * r).
3. Rufen Sie die Funktion drawCircle(int xc int yc int x int y) auf.
4. Wiederholen Sie die folgenden Schritte bis x<= y:
   • Wenn d< 0 set d = d + (4 * x) + 6.
   • Andernfalls setzen Sie d = d + 4 * (x – y) + 10 und dekrementieren y um 1.
   • Erhöhen Sie den Wert von x.
   • Rufen Sie die Funktion drawCircle(int xc int yc int x int y) auf.

Funktion drawCircle():  

// function to draw all other 7 pixels // present at symmetric position drawCircle(int xc int yc int x int y) {  putpixel(xc+x yc+y RED);  putpixel(xc-x yc+y RED);  putpixel(xc+x yc-y RED);  putpixel(xc-x yc-y RED);  putpixel(xc+y yc+x RED);  putpixel(xc-y yc+x RED);  putpixel(xc+y yc-x RED);  putpixel(xc-y yc-x RED); } 

Nachfolgend finden Sie die C-Implementierung des oben genannten Ansatzes. 

Java-Methoden

// C-program for circle drawing // using Bresenham’s Algorithm // in computer-graphics #include  #include  #include  // Function to put pixels // at subsequence points void drawCircle(int xc int yc int x int y){  putpixel(xc+x yc+y RED);  putpixel(xc-x yc+y RED);  putpixel(xc+x yc-y RED);  putpixel(xc-x yc-y RED);  putpixel(xc+y yc+x RED);  putpixel(xc-y yc+x RED);  putpixel(xc+y yc-x RED);  putpixel(xc-y yc-x RED); } // Function for circle-generation // using Bresenham's algorithm void circleBres(int xc int yc int r){  int x = 0 y = r;  int d = 3 - 2 * r;  drawCircle(xc yc x y);  while (y >= x){    // check for decision parameter  // and correspondingly   // update d y  if (d > 0) {  y--;   d = d + 4 * (x - y) + 10;  }  else  d = d + 4 * x + 6;  // Increment x after updating decision parameter  x++;    // Draw the circle using the new coordinates  drawCircle(xc yc x y);  delay(50);  } } int main() {  int xc = 50 yc = 50 r = 30;  int gd = DETECT gm;  initgraph(&gd &gm ''); // initialize graph  circleBres(xc yc r); // function call  return 0; } 

Ausgabe: 
 

Vorteile  

• Es ist ein einfacher Algorithmus.
• Es lässt sich leicht umsetzen
• Es basiert vollständig auf der Kreisgleichung, d. h. x²+y²=r²

Nachteile  

• Beim Generieren von Punkten besteht ein Genauigkeitsproblem.
• Dieser Algorithmus ist nicht für komplexe und hochgrafische Bilder geeignet.