Det är inte lätt att visa en kontinuerlig jämn båge på datorskärmen eftersom vår datorskärm är gjord av pixlar organiserade i matrisform. Så för att rita en cirkel på en datorskärm bör vi alltid välja de närmaste pixlarna från en utskriven pixel så att de kan bilda en båge. Det finns två algoritmer för att göra detta:

1. Algoritm för cirkelritning i mitten
2. Bresenhams cirkelritningsalgoritm

Vi har redan diskuterat Algoritm för cirkelritning i mitten i vårt tidigare inlägg.I det här inlägget kommer vi att diskutera om Bresenhams cirkelritningsalgoritm. 

Båda dessa algoritmer använder nyckelfunktionen hos cirkeln att den är mycket symmetrisk. Så för hela 360 graders cirkel kommer vi att dela den i 8 delar varje oktant på 45 grader. För att göra det kommer vi att använda Bresenhams cirkelalgoritm för beräkning av pixlarnas placering i den första oktanten på 45 grader. Det förutsätter att cirkeln är centrerad på ursprunget. Så för varje pixel (x y) beräknar vi att vi ritar en pixel i var och en av de 8 oktanterna i cirkeln som visas nedan: 

Nu kommer vi att se hur man beräknar nästa pixelplats från en tidigare känd pixelplats (x y). I Bresenhams algoritm när som helst (x y) har vi två alternativ att antingen välja nästa pixel i öst, dvs. (x+1 y) eller i sydöst, dvs. (x+1 y-1).
 

Och detta kan avgöras genom att använda beslutsparametern d som: 
 

• Om d > 0 ska (x+1 y-1) väljas som nästa pixel eftersom den kommer att vara närmare bågen.
• annat (x+1 y) ska väljas som nästa pixel.

Nu för att rita cirkeln för en given radie 'r' och centrum (xc yc) Vi börjar från (0 r) och rör oss i första kvadranten till x=y (dvs. 45 grader). Vi bör utgå från det angivna initiala tillståndet: 
 

 d = 3 - (2 * r)   
 x = 0   
 y = r  
 Nu kommer vi att göra följande operationer för varje pixel:    
 
 
 Ställ in initiala värden för (xc yc) och (x y).  
 
 Ställ in beslutsparametern d till d = 3 – (2 * r).  
 
 Kalla funktionen drawCircle(int xc int yc int x int y).  
 
 Upprepa följande steg tills x <= y:  
 
 Om d < 0 set d = d + (4 * x) + 6.  
 
 Ange annars d = d + 4 * (x – y) + 10 och minska y med 1.  
 
 Öka värdet på x.  
 
 Kalla funktionen drawCircle(int xc int yc int x int y).  
 
 
 
 
    drawCircle() funktion:       
 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  );   }   
   
 Nedan är C implementering av ovanstående tillvägagångssätt.   
 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  ;   }   
   
    Produktion:      
    
 
   
 
  
    Fördelar       
 
 
 Det är en enkel algoritm.  
 
 Det kan implementeras enkelt  
 
 Den är helt baserad på cirkelekvationen, dvs x   2   +y   2   =r   2   
 
 
    Nackdelar       
 
 
 Det finns ett problem med noggrannhet när man genererar poäng.  
 
 Denna algoritm är inte lämplig för komplexa och höggrafiska bilder.  
 
         Skapa frågesport