Det er ikke lett å vise en kontinuerlig jevn bue på dataskjermen siden vår dataskjerm er laget av piksler organisert i matriseform. Så for å tegne en sirkel på en dataskjerm bør vi alltid velge de nærmeste pikslene fra en trykt piksel slik at de kan danne en bue. Det er to algoritmer for å gjøre dette:

1. Algoritme for tegning av sirkel i midtpunkt
2. Bresenhams sirkeltegningsalgoritme

Vi har allerede diskutert Algoritme for tegning av midtpunktssirkel i vårt forrige innlegg.I dette innlegget vil vi diskutere om Bresenhams sirkeltegningsalgoritme. 

Begge disse algoritmene bruker nøkkeltrekket til sirkelen at den er svært symmetrisk. Så for hele 360 ​​graders sirkel vil vi dele den i 8 deler hver oktant på 45 grader. For å gjøre det vil vi bruke Bresenhams Circle Algorithm for å beregne plasseringen av pikslene i den første oktanten på 45 grader. Det forutsetter at sirkelen er sentrert på origo. Så for hver piksel (x y) beregner den at vi tegner en piksel i hver av de 8 oktantene i sirkelen som vist nedenfor: 

Nå skal vi se hvordan du beregner neste pikselplassering fra en tidligere kjent pikselplassering (x y). I Bresenhams algoritme på et hvilket som helst punkt (x y) har vi to alternativer enten å velge neste piksel i øst, dvs. (x+1 y) eller i sørøst, dvs. (x+1 y-1).
 

Og dette kan bestemmes ved å bruke beslutningsparameteren d som: 
 

• Hvis d > 0 skal (x+1 y-1) velges som neste piksel da den vil være nærmere buen.
• else (x+1 y) skal velges som neste piksel.

Nå for å tegne sirkelen for en gitt radius 'r' og sentrum (xc yc) Vi starter fra (0 r) og beveger oss i første kvadrant til x=y (dvs. 45 grader). Vi bør starte fra oppført starttilstand: 
 

 d = 3 - (2 * r)   
 x = 0   
 y = r  
 Nå for hver piksel vil vi gjøre følgende operasjoner:    
 
 
 Angi startverdier for (xc yc) og (x y).  
 
 Sett beslutningsparameteren d til d = 3 – (2 * r).  
 
 Kalle funksjonen drawCircle(int xc int yc int x int y).  
 
 Gjenta følgende trinn til x <= y:  
 
 Hvis d < 0 set d = d + (4 * x) + 6.  
 
 Ellers sett d = d + 4 * (x – y) + 10 og reduser y med 1.  
 
 Øk verdien av x.  
 
 Kalle funksjonen drawCircle(int xc int yc int x int y).  
 
 
 
 
    drawCircle() funksjon:       
 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  );   }   
   
 Nedenfor er C-implementering av tilnærmingen ovenfor.   
 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  ;   }   
   
    Produksjon:      
    
 
   
 
  
    Fordeler       
 
 
 Det er en enkel algoritme.  
 
 Det kan implementeres enkelt  
 
 Den er helt basert på sirkelligningen, dvs. x   2   +y   2   =r   2   
 
 
    Ulemper       
 
 
 Det er et problem med nøyaktighet mens du genererer poeng.  
 
 Denne algoritmen er ikke egnet for komplekse og høye grafiske bilder.  
 
         Lag quiz