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. 

handledning för java swing

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:  

1. Ställ in initiala värden för (xc yc) och (x y).
2. Ställ in beslutsparametern d till d = 3 – (2 * r).
3. Kalla funktionen drawCircle(int xc int yc int x int y).
4. 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:  

ställ in java

// 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. 

// 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²+y²=r²

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.