Não é fácil exibir um arco contínuo e suave na tela do computador, pois a tela do computador é feita de pixels organizados em forma de matriz. Portanto, para desenhar um círculo na tela do computador devemos sempre escolher os pixels mais próximos de um pixel impresso para que possam formar um arco. Existem dois algoritmos para fazer isso:

1. Algoritmo de desenho de círculo de ponto médio
2. Algoritmo de desenho de círculo de Bresenham

Já discutimos o Algoritmo de desenho de círculo de ponto médio em nosso post anterior. Neste post discutiremos sobre o algoritmo de desenho do círculo de Bresenham. 

divisão de string c++

Ambos os algoritmos usam o recurso principal do círculo: ele é altamente simétrico. Portanto, para um círculo inteiro de 360 ​​​​graus, vamos dividi-lo em 8 partes, cada octante de 45 graus. Para isso utilizaremos o Algoritmo do Círculo de Bresenham para cálculo das localizações dos pixels no primeiro octante de 45 graus. Assume que o círculo está centrado na origem. Então, para cada pixel (x y) calculado, desenhamos um pixel em cada um dos 8 octantes do círculo, conforme mostrado abaixo: 

Agora veremos como calcular a localização do próximo pixel a partir de uma localização de pixel previamente conhecida (x y). No algoritmo de Bresenham, em qualquer ponto (x y), temos duas opções: escolher o próximo pixel no leste, ou seja, (x+1 y) ou no sudeste, ou seja, (x+1 y-1).
 

E isso pode ser decidido usando o parâmetro de decisão d como: 
 

• Se d > 0 então (x+1 y-1) deve ser escolhido como o próximo pixel, pois estará mais próximo do arco.
• caso contrário (x+1 y) deve ser escolhido como o próximo pixel.

Agora, para desenhar o círculo para um determinado raio 'r' e centro (xc yc), começaremos em (0 r) e nos moveremos no primeiro quadrante até x = y (ou seja, 45 graus). Devemos começar pela condição inicial listada: 
 

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

Agora para cada pixel faremos as seguintes operações:  

idade de Salman Khan

1. Defina os valores iniciais de (xc yc) e (x y).
2. Defina o parâmetro de decisão d como d = 3 – (2 * r).
3. Chame a função drawCircle(int xc int yc int x int y).
4. Repita os seguintes passos até x<= y:
   • Se d< 0 set d = d + (4 * x) + 6.
   • Caso contrário, defina d = d + 4 * (x - y) + 10 e diminua y em 1.
   • Aumente o valor de x.
   • Chame a função drawCircle(int xc int yc int x int y).

Função 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); } 

Abaixo está a implementação C da abordagem acima. 

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

Saída: 
 

Vantagens  

• É um algoritmo simples.
• Pode ser implementado facilmente
• É totalmente baseado na equação do círculo, ou seja, x²+s²=r²

Desvantagens  

• Existe um problema de precisão ao gerar pontos.
• Este algoritmo não é adequado para imagens gráficas complexas e altas.