Dibuja un círculo usando la ecuación polar y la ecuación de Bresenham

En este artículo, discutiremos cómo dibujar círculos usando la ecuación de Bresenham y la ecuación polar.

Algoritmo de dibujo circular

• Considere círculos centrados en el origen con radios enteros.
• Puede aplicar traducciones para obtener círculos no centrados en el origen.
• La ecuación del círculo está dada por:

x ² + y ² = R ²
y = +/-raíz cuadrada (R2-x2)

• La ecuación dada se puede escribir como:

F(x, y)= x2+ y2-R2=0
5.

• Uso de Simetría: Solo es necesario calcular un octante. Uno puede obtener puntos en los otros 7 octantes de la siguiente manera:
  • Punto(x, y)
  • Punto de trama (y, x)
  • Punto(x, -y)
  • Punto de trama (-y, x)
  • Punto de trama (-x, -y)
  • Punto de trama (-y, -x)
  • Punto de trama (-x, y)
  • Punto de trama (-y, x)

Dibujo circular usando la ecuación de Bresenham

a los grados, en grados, los

En el Algoritmo de Bresenham en cualquier punto (x, y) tenemos dos opciones para elegir el siguiente píxel en el este, es decir, (x + 1, y) o en el sureste, es decir, (x + 1, y – 1) .

• Si d > 0 , entonces (x + 1, y – 1) se elegirá como el siguiente píxel, ya que estará más cerca del arco.
• De lo contrario , (x + 1, y) se elegirá como el siguiente píxel.

A continuación se muestra el algoritmo para la ecuación de Bresenham:

• F(x, y) = x ² + y ² = 0 El punto se encuentra en el círculo.
• F(x, y) > 0 El punto se encuentra fuera del círculo.
• F(x, y) < 0 El punto se encuentra dentro del círculo.
• Si d >= 0 entonces actualice x como (x + 1) y y = (y – 1) lo que da una nueva d
• Si d < 0, actualice x como (x + 1), lo que da el nuevo valor de d

// C program for the above approach
#include <GL/gl.h>
#include <GL/glut.h>
#include <math.h>
#include <stdio.h>
  
int xo, yo, r;
  
// Function to display the circle using
// the above algorithm
void Display(void)
{
    glClear(GL_COLOR_BUFFER_BIT);
  
    // Color of printing object
    glColor3f(1, 0, 0);
  
    // Giving the size of the point
    glPointSize(2);
  
    int x = 0;
    int y = r;
    float p = 5 / 4 - r;
  
    glColor3f(1, 0, 0);
  
    // Starting of drawing the circle
    glBegin(GL_POINTS);
  
    while (y > x) {
        if (p < 0) {
  
            // Increment x to x+1
            x++;
            p = p + 2 * x + 1;
        }
        else {
  
            // Increment x to x+1
            // and decrease y to y-1
            y--;
            x++;
            p = p + 2 * (x - y) + 1;
        }
  
        // Draw the coordinates
        glVertex2d(x + xo, y + yo);
        glVertex2d(-x + xo, y + yo);
        glVertex2d(x + xo, -y + yo);
        glVertex2d(-x + xo, -y + yo);
        glVertex2d(y + yo, x + xo);
        glVertex2d(-y + yo, x + xo);
        glVertex2d(y + yo, -x + xo);
        glVertex2d(-y + yo, -x + xo);
    }
  
    glEnd();
  
    // Its empties all the buffer
    // causing the issue
    glFlush();
}
  
// Driver Code
int main(int argc, char** argv)
{
    printf("X-coordinate Y-coordinate radius:");
    scanf("%d %d %d", &xo, &yo, &r);
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
  
    // Assigning the size of window
    glutInitWindowSize(1000, 1000);
  
    // Assign the position of window
    // to be appeared
    glutInitWindowPosition(100, 100);
  
    // Defining the heading of the window
    glutCreateWindow("GeeksforGeeks");
  
    // Backgronnd Color
    glClearColor(1, 1, 1, 1);
  
    // limit of the coordinate points
    gluOrtho2D(-500, 500, -500, 500);
  
    // Calling the function
    glutDisplayFunc(Display);
  
    glutMainLoop();
  
    return 0;
}

Producción:

Complejidad temporal: O(N)
Espacio auxiliar: O(1)

Círculo usando la ecuación polar

módulo r con θ

1. θ_fin = 100 .
2. Si θ_end < θ , salga del bucle.
3. Encuentre el valor de x como rad*cos(ángulo) y y como rad*sin(ángulo) .
4. Trace los ocho puntos, encontrados por simetría, es decir, el centro (x0, y0) en las coordenadas actuales (x, y) .
   •  Parcela (x + xo, y + yo)
   • Parcela (-x + xo, -y + yo)
   • Parcela (y + xo, x + yo)
   • Parcela (-y + xo, -x + yo)
   • Parcela (-y + xo, x + yo)
   • Parcela (y + xo, -x + yo)
   • Parcela (-x + xo, y + yo)
   • Parcela (x + xo, -y + yo)
5. Incremente el ángulo en i*2*(M_PI/100) .

A continuación se muestra el programa para implementar el enfoque anterior:

// C program to demonstrate circle
// drawing using polar equation
#include <GL/glut.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
float xo, yo, rad;
  
// Function to display the circle
void display()
{
    glClear(GL_COLOR_BUFFER_BIT);
  
    // Color of printing object
    glColor3f(1, 1, 1);
  
    float angle;
  
    // Start to drawing the circle
    glBegin(GL_POLYGON);
  
    for (int i = 0; i < 100; i++) {
  
        // Change the angle
        angle = i * 2 * (M_PI / 100);
        glVertex2f(xo + (cos(angle) * rad),
                   yo + (sin(angle) * rad));
    }
  
    glEnd();
  
    // Its empties all the buffer
    // causing the issue
    glFlush();
}
  
// Driver Code
int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    printf("Enter x y radius ");
    scanf("%f %f %f", &xo, &yo, &rad);
  
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
  
    // Assigning the size of window
    glutInitWindowSize(500, 500);
  
    // Assign the position of window
    // to be appeared
    glutInitWindowPosition(200, 200);
  
    // Defining the heading of the window
    glutCreateWindow("GeeksforGeeks");
  
    // Backgronnd Color
    glClearColor(0, 1, 0, 1);
  
    // limit of the coordinate points
    gluOrtho2D(-500, 500, -500, 500);
  
    // Calling the function
    glutDisplayFunc(Display);
  
    glutMainLoop();
  
    return 0;
}

Producción:

Complejidad temporal: O(N)
Espacio auxiliar: O(1)