Na računalniškem zaslonu ni enostavno prikazati neprekinjenega gladkega loka, saj je zaslon našega računalnika sestavljen iz slikovnih pik, organiziranih v obliki matrike. Za risanje kroga na računalniškem zaslonu moramo vedno izbrati najbližje slikovne pike iz natisnjene slikovne pike, da lahko tvorijo lok. Za to obstajata dva algoritma:

1. Algoritem za risanje kroga sredinske točke
2. Bresenhamov algoritem za risanje kroga

Smo že razpravljali o Algoritem za risanje kroga sredinske točke v naši prejšnji objavi. V tej objavi bomo razpravljali o Bresenhamovem algoritmu za risanje kroga. 

Oba algoritma uporabljata ključno lastnost kroga, da je zelo simetričen. Torej za celoten 360-stopinjski krog ga bomo razdelili na 8 delov, vsak oktant 45 stopinj. Da bi to naredili, bomo uporabili Bresenhamov krožni algoritem za izračun lokacij slikovnih pik v prvem oktantu 45 stopinj. Predpostavlja, da je krog središče v izhodišču. Torej za vsako slikovno piko (x y), ki jo izračuna, narišemo slikovno piko v vsakem od 8 oktantov kroga, kot je prikazano spodaj: 

Zdaj bomo videli, kako izračunati naslednjo lokacijo piksla iz predhodno znane lokacije piksla (x y). V Bresenhamovem algoritmu imamo na kateri koli točki (x y) dve možnosti, da izberemo naslednji piksel na vzhodu, tj. (x+1 y) ali na jugovzhodu, tj. (x+1 y-1).
 

In to se lahko odloči z uporabo odločitvenega parametra d kot: 
 

• Če je d > 0, je treba kot naslednjo slikovno piko izbrati (x+1 y-1), saj bo bližje loku.
• drugače (x+1 y) je treba izbrati kot naslednjo slikovno piko.

Zdaj, da narišemo krog za dani polmer 'r' in središče (xc yc). Začeli bomo od (0 r) in se premikali v prvem kvadrantu do x=y (tj. 45 stopinj). Začeti moramo z navedenim začetnim pogojem: 
 

 d = 3 - (2 * r)   
 x = 0   
 y = r  
 Zdaj bomo za vsako slikovno piko izvedli naslednje operacije:    
 
 
 Nastavite začetne vrednosti (xc yc) in (x y).  
 
 Odločitveni parameter d nastavite na d = 3 – (2 * r).  
 
 Pokličite funkcijo drawCircle(int xc int yc int x int y).  
 
 Ponavljajte naslednje korake, dokler x <= y:  
 
 Če d < 0 set d = d + (4 * x) + 6.  
 
 Drugače nastavite d = d + 4 * (x – y) + 10 in zmanjšajte y za 1.  
 
 Povečajte vrednost x.  
 
 Pokličite funkcijo drawCircle(int xc int yc int x int y).  
 
 
 
 
    funkcija drawCircle():       
 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  );   }   
   
 Spodaj je C implementacija zgornjega pristopa.   
 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  ;   }   
   
    Izhod:      
    
 
   
 
  
    Prednosti       
 
 
 To je preprost algoritem.  
 
 Lahko se izvaja enostavno  
 
 V celoti temelji na enačbi kroga, tj. x   2   +y   2   =r   2   
 
 
    Slabosti       
 
 
 Obstaja problem natančnosti pri ustvarjanju točk.  
 
 Ta algoritem ni primeren za kompleksne in visoko grafične slike.  
 
         Ustvari kviz