Het is niet eenvoudig om een ​​ononderbroken vloeiende boog op het computerscherm weer te geven, omdat ons computerscherm is gemaakt van pixels die in matrixvorm zijn georganiseerd. Als we dus een cirkel op een computerscherm willen tekenen, moeten we altijd de dichtstbijzijnde pixels uit een afgedrukte pixel kiezen, zodat deze een boog kunnen vormen. Er zijn twee algoritmen om dit te doen:

1. Algoritme voor het tekenen van middelpunten
2. Het cirkeltekenalgoritme van Bresenham

We hebben het al besproken Algoritme voor het tekenen van middelpunten in ons vorige bericht. In dit bericht zullen we het hebben over het cirkeltekenalgoritme van Bresenham. 

Beide algoritmen gebruiken het belangrijkste kenmerk van cirkel, namelijk dat deze zeer symmetrisch is. Dus voor een hele cirkel van 360 graden verdelen we deze in 8 delen, elk octant van 45 graden. Om dat te doen zullen we het cirkelalgoritme van Bresenham gebruiken voor het berekenen van de locaties van de pixels in het eerste octant van 45 graden. Er wordt aangenomen dat de cirkel gecentreerd is op de oorsprong. Dus voor elke pixel (xy) die wordt berekend, tekenen we een pixel in elk van de 8 octanten van de cirkel, zoals hieronder weergegeven: 

Nu zullen we zien hoe we de volgende pixellocatie kunnen berekenen op basis van een eerder bekende pixellocatie (x y). In het algoritme van Bresenham hebben we op elk punt (x y) twee opties om ofwel de volgende pixel in het oosten, dat wil zeggen (x+1 y), of in het zuidoosten, dat wil zeggen (x+1 y-1), te kiezen.
 

En dit kan worden besloten door de beslissingsparameter d te gebruiken als: 
 

• Als d > 0, dan moet (x+1 y-1) worden gekozen als de volgende pixel, omdat deze zich dichter bij de boog bevindt.
• anders moet (x+1 y) als volgende pixel worden gekozen.

Om nu de cirkel te tekenen voor een gegeven straal 'r' en middelpunt (xc yc) We beginnen vanaf (0 r) en gaan in het eerste kwadrant tot x=y (dat wil zeggen 45 graden). We moeten uitgaan van de vermelde beginvoorwaarde: 
 

 d = 3 - (2 * r)   
 x = 0   
 y = r  
 Nu zullen we voor elke pixel de volgende bewerkingen uitvoeren:    
 
 
 Stel initiële waarden van (xc yc) en (xy) in.  
 
 Stel de beslissingsparameter d in op d = 3 – (2 * r).  
 
 Roep de functie drawCircle(int xc int yc int x int y) aan.  
 
 Herhaal de volgende stappen tot x <= y:  
 
 Als d < 0 set d = d + (4 * x) + 6.  
 
 Stel anders d = d + 4 * (x – y) + 10 in en verlaag y met 1.  
 
 Verhoog de waarde van x.  
 
 Roep de functie drawCircle(int xc int yc int x int y) aan.  
 
 
 
 
    drawCircle()-functie:       
 CPP   
   // 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  );   }   
   
 Hieronder vindt u de C-implementatie van bovenstaande aanpak.   
 CPP   
   // 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  ;   }   
   
    Uitgang:      
    
 
   
 
  
    Voordelen       
 
 
 Het is een eenvoudig algoritme.  
 
 Het kan eenvoudig worden geïmplementeerd  
 
 Het is volledig gebaseerd op de vergelijking van cirkel, d.w.z. x   2   +y   2   = r   2   
 
 
    Nadelen       
 
 
 Er is een probleem met de nauwkeurigheid bij het genereren van punten.  
 
 Dit algoritme is niet geschikt voor complexe en hoog grafische afbeeldingen.  
 
         Quiz maken