Il n’est pas facile d’afficher un arc continu et lisse sur l’écran d’un ordinateur car notre écran d’ordinateur est constitué de pixels organisés sous forme matricielle. Ainsi, pour dessiner un cercle sur un écran d'ordinateur, nous devons toujours choisir les pixels les plus proches d'un pixel imprimé afin qu'ils puissent former un arc. Il existe deux algorithmes pour ce faire :

1. Algorithme de dessin de cercle à mi-point
2. Algorithme de dessin de cercle de Bresenham

Nous avons déjà discuté du Algorithme de dessin de cercle à mi-point dans notre article précédent. Dans cet article, nous discuterons de l'algorithme de dessin de cercle de Bresenham. 

c exemples de programmes de programmation

Ces deux algorithmes utilisent la caractéristique clé du cercle : il est hautement symétrique. Ainsi, pour un cercle entier de 360 ​​degrés, nous le diviserons en 8 parties, chaque octant de 45 degrés. Pour ce faire, nous utiliserons l'algorithme du cercle de Bresenham pour calculer les emplacements des pixels dans le premier octant de 45 degrés. On suppose que le cercle est centré sur l’origine. Ainsi, pour chaque pixel (x y) calculé, nous dessinons un pixel dans chacun des 8 octants du cercle comme indiqué ci-dessous : 

Nous allons maintenant voir comment calculer l'emplacement du pixel suivant à partir d'un emplacement de pixel précédemment connu (x y). Dans l'algorithme de Bresenham, à tout moment (x y), nous avons deux options : choisir le pixel suivant à l'est, c'est-à-dire (x+1 y), ou au sud-est, c'est-à-dire (x+1 y-1).
 

Et cela peut être décidé en utilisant le paramètre de décision d comme : 
 

• Si d > 0 alors (x+1 y-1) doit être choisi comme pixel suivant car il sera plus proche de l'arc.
• sinon (x+1 y) doit être choisi comme pixel suivant.

Maintenant, pour dessiner le cercle pour un rayon 'r' et un centre (xc yc) donnés, nous allons commencer à partir de (0 r) et nous déplacer dans le premier quadrant jusqu'à x=y (c'est-à-dire 45 degrés). Nous devrions partir de la condition initiale répertoriée : 
 

d = 3 - (2 * r)  
x = 0  
y = r

Maintenant, pour chaque pixel, nous allons effectuer les opérations suivantes :  

1. Définissez les valeurs initiales de (xc yc) et (x y).
2. Définissez le paramètre de décision d sur d = 3 – (2 * r).
3. Appelez la fonction drawCircle(int xc int yc int x int y).
4. Répétez les étapes suivantes jusqu'à ce que x<= y:
   • Si d< 0 set d = d + (4 * x) + 6.
   • Sinon, définissez d = d + 4 * (x – y) + 10 et décrémentez y de 1.
   • Incrémentez la valeur de x.
   • Appelez la fonction drawCircle(int xc int yc int x int y).

Fonction drawCircle() :  

// 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); } 

Vous trouverez ci-dessous la mise en œuvre en C de l’approche ci-dessus. 

// 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; } 

Sortir: 
 

json dans l'exemple json

Avantages  

• C'est un algorithme simple.
• Il peut être mis en œuvre facilement
• Il est totalement basé sur l'équation du cercle, c'est-à-dire x²+o²=r²

Inconvénients  

• Il y a un problème de précision lors de la génération de points.
• Cet algorithme n'est pas adapté aux images complexes et très graphiques.