Curvas cónicas

Las curvas cónicas son una parte fundamental de la geometría en gráficos por computadora y son esenciales para la representación y manipulación de formas en aplicaciones de diseño y modelado tridimensional. A continuación se muestra un ejemplo escrito en python.

Requerimientos del ejemplo

Para este ejemplo hay que tener instalado las librerías PyOpenGL, se puede instalar utilizando el siguiente comando desde la terminal:

pip install pyopengl

Código de ejemplo

from OpenGL.GL import *
from OpenGL.GLUT import *
from math import *
import sys


def draw_elipce():
    glClear(GL_COLOR_BUFFER_BIT)
    glBegin(GL_LINE_LOOP)  # Inicia el dibujo de un lazo de líneas
    glColor3f(0.0, 1.0, 0.0)  # Color verde
    for i in range(360):
        angle = i * (3.141592 / 180.0)  # Convierte grados a radianes
        x = 0.5 * cos(angle)  # Coordenada X
        y = 0.3 * sin(angle)  # Coordenada Y
        glVertex2f(x, y)
    glEnd()  # Finaliza el dibujo
    glFlush()

def draw_circunferencia():
    glClear(GL_COLOR_BUFFER_BIT)
    glBegin(GL_LINE_LOOP)  # Inicia el dibujo de un lazo de líneas
    glColor3f(0.0, 1.0, 0.0)  # Color verde
    for i in range(360):
        angle = i * (3.141592 / 180.0)  # Convierte grados a radianes
        radius = 0.5  # Radio de la circunferencia
        x = radius * cos(angle)  # Coordenada X
        y = radius * sin(angle)  # Coordenada Y
        glVertex2f(x, y)
    glEnd()  # Finaliza el dibujo
    glFlush()

def draw_hiperbola():
    glClear(GL_COLOR_BUFFER_BIT)
    glBegin(GL_LINES)  # Inicia el dibujo de líneas
    glColor3f(0.0, 1.0, 0.0)  # Color verde
    a = 0.5  # Parámetro "a" de la hipérbola
    b = 0.3  # Parámetro "b" de la hipérbola
    for i in range(200):
        x = 2.0 * a * i / 200 - a
        y = b * (1 + (x / a) ** 2) ** 0.5
        glVertex2f(x, y)
    glEnd()  # Finaliza el dibujo
    glFlush()

def draw_parabola():
    glClear(GL_COLOR_BUFFER_BIT)
    glBegin(GL_LINES)  # Inicia el dibujo de líneas
    glColor3f(0.0, 1.0, 0.0)  # Color verde
    a = 0.5  # Parámetro "a" de la parábola
    for i in range(200):
        x = 4.0 * a * i / 200 - 2.0 * a
        y = (x**2) / (4.0 * a)
        glVertex2f(x, y)
    glEnd()  # Finaliza el dibujo
    glFlush()


# Función de renderización
def render():
    op=input("1: elipce. 2: circunferncia. 3: hiperbola. 4: parabola. ")
    if op == "1":
        draw_elipce();
        
    if op == "2":
        draw_circunferencia();
        
    if op == "3":
        draw_hiperbola();
        
    if op == "4":
        draw_parabola();
        

# Inicialización de Pygame
def setup_opengl_window():
    
    glutInit(sys.argv)
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB)
    glutInitWindowSize(800, 600)
    glutInitWindowPosition(100, 100)
    glutCreateWindow(b'Ejemplo de OpenGL')
    glClearColor(0.0, 0.0, 0.0, 1.0)  # Color de fondo (negro)
    glutDisplayFunc(render) 
    glutMainLoop()


if __name__ == "__main__":
    setup_opengl_window()

Este código dibuja las curvas cónicas (un elipse, una circunferencia, una hipérbola y una parábola) en una ventana de visualización. A continuación, se explica el código:

1. Se importan las bibliotecas necesarias:
   • OpenGL.GL: Proporciona funciones y constantes para OpenGL.
   • OpenGL.GLUT: Proporciona una interfaz de usuario y funciones relacionadas con GLUT (OpenGL Utility Toolkit).
   • math: Importa funciones matemáticas, como cos y sin, para cálculos trigonométricos.
   • sys: Utilizado para manipular argumentos de línea de comandos.
2. Se definen cuatro funciones para dibujar diferentes figuras: elipse, circunferencia, hipérbola y parábola. Estas funciones se encargan de borrar el búfer de color, establecer el color de dibujo en verde, y luego generar los vértices de la figura deseada utilizando un bucle for que varía el ángulo en grados (de 0 a 359) y calcula las coordenadas x e y de los puntos en función de la figura deseada.
3. La función render() permite al usuario seleccionar qué figura desea dibujar. Se muestra un menú simple con cuatro opciones: elipse, circunferencia, hipérbola y parábola. Dependiendo de la opción elegida por el usuario, se llama a la función correspondiente para dibujar la figura deseada.
4. La función setup_opengl_window() realiza la inicialización de la ventana de visualización y OpenGL. Configura las dimensiones de la ventana, la posición y el título, así como el color de fondo negro. Asigna la función render() como la función de visualización para que se llame cada vez que se necesita actualizar la ventana.
5. Finalmente, el bloque if __name__ == "__main__": se encarga de iniciar la ventana y entrar en el bucle principal de GLUT para que el usuario pueda interactuar con la aplicación.

Para ejecutar este código, asegúrate de tener instaladas las bibliotecas necesarias y un entorno de Python compatible con OpenGL (como PyOpenGL). Luego, al ejecutar el programa, podrás seleccionar qué figura deseas dibujar y observar cómo se representa en la ventana de visualización.