Breve introducción a OpenGL en Python con PyOpenGL

B

Introducción

En este tutorial, aprenderemos a usar PyOpenGL biblioteca en Python. OpenGL es una biblioteca de gráficos que es compatible con múltiples plataformas, incluidas Windows, Linux y MacOS, y también está disponible para su uso en muchos otros idiomas; sin embargo, el alcance de esta publicación se limitará a su uso en el lenguaje de programación Python.

OpenGL, en comparación con otras bibliotecas de gráficos similares, es bastante simple. Comenzaremos configurándolo en nuestro sistema, seguido de escribir un ejemplo simple que demuestre el uso de la biblioteca.

Instalación

La forma más sencilla de instalar OpenGL usando Python es a través del pepita gerente de empaquetación. Si tiene pip instalado en su sistema, ejecute el siguiente comando para descargar e instalar OpenGL:

$ pip install PyOpenGL PyOpenGL_accelerate

Recomiendo copiar el comando anterior para ayudar a evitar errores tipográficos.

Una vez que este comando termina de ejecutarse, si la instalación es exitosa, debería obtener el siguiente resultado al final:

Successfully installed PyOpenGL-3.1.0 PyOpenGL-accelerate-3.1.0

Si esto no funciona, también puede descargarlo manualmente. Para eso, este enlace, desplácese hacia abajo hasta el encabezado ‘descarga e instalación’ y descargue todos los archivos allí. Después de eso, navegue hasta la carpeta donde descargó esos archivos y ejecute el siguiente comando en la terminal o símbolo del sistema:

$ python setup.py

Es pertinente mencionar que necesita herramientas de compilación Visual C ++ 14.0 instaladas en su sistema para trabajar con bibliotecas OpenGL en Python.

Ahora que hemos instalado OpenGL con éxito en nuestro sistema, ensuciemos nuestras manos con él.

Ejercicio de codificación

Lo primero que debemos hacer para usar OpenGL en nuestro código es importarlo. Para hacer eso, ejecute el siguiente comando:

import OpenGL

Antes de continuar, hay algunas otras bibliotecas que debe importar siempre que desee utilizar esta biblioteca en su programa. A continuación se muestra el código para esas importaciones:

import OpenGL.GL
import OpenGL.GLUT
import OpenGL.GLU
print("Imports successful!") # If you see this printed to the console then installation was successful

Ahora que hemos terminado con las importaciones necesarias, primero creemos una ventana en la que se mostrarán nuestros gráficos. El código para eso se da a continuación, junto con su explicación en los comentarios:

def showScreen():
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # Remove everything from screen (i.e. displays all white)

glutInit() # Initialize a glut instance which will allow us to customize our window
glutInitDisplayMode(GLUT_RGBA) # Set the display mode to be colored
glutInitWindowSize(500, 500)   # Set the width and height of your window
glutInitWindowPosition(0, 0)   # Set the position at which this windows should appear
wind = glutCreateWindow("OpenGL Coding Practice") # Give your window a title
glutDisplayFunc(showScreen)  # Tell OpenGL to call the showScreen method continuously
glutIdleFunc(showScreen)     # Draw any graphics or shapes in the showScreen function at all times
glutMainLoop()  # Keeps the window created above displaying/running in a loop

Copie las importaciones anteriores, así como este código en un solo archivo python (.py) y ejecútelo. Debería ver aparecer una pantalla de dimensión cuadrada blanca. Ahora, si deseamos dibujar alguna forma o hacer cualquier otro tipo de gráficos, tenemos que hacerlo en nuestra función “showScreen”.

Intentemos ahora hacer un cuadrado usando OpenGL, pero antes necesitamos entender el sistema de coordenadas que sigue OpenGL.

El punto (0,0) es la parte inferior izquierda de su ventana, si sube desde allí, se está moviendo a lo largo del eje y, y si va a la derecha desde allí, se está moviendo a lo largo del eje x. Por lo tanto, el punto superior izquierdo de su ventana sería (0, 500), la parte superior derecha sería (500, 500), la parte inferior derecha sería (500, 0).

Nota: Estamos hablando de la ventana que creamos arriba, que tenía una dimensión de 500 x 500 en nuestro ejemplo, y no la pantalla completa de su computadora.

Ahora que lo hemos sacado del camino, codifiquemos un cuadrado. La explicación del código se puede encontrar en los comentarios.

from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *

w, h = 500,500

# ---Section 1---
def square():
    # We have to declare the points in this sequence: bottom left, bottom right, top right, top left
    glBegin(GL_QUADS) # Begin the sketch
    glVertex2f(100, 100) # Coordinates for the bottom left point
    glVertex2f(200, 100) # Coordinates for the bottom right point
    glVertex2f(200, 200) # Coordinates for the top right point
    glVertex2f(100, 200) # Coordinates for the top left point
    glEnd() # Mark the end of drawing

# This alone isn't enough to draw our square

# ---Section 2---

def showScreen():
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # Remove everything from screen (i.e. displays all white)
    glLoadIdentity() # Reset all graphic/shape's position
    square() # Draw a square using our function
    glutSwapBuffers()

#---Section 3---

glutInit()
glutInitDisplayMode(GLUT_RGBA) # Set the display mode to be colored
glutInitWindowSize(500, 500)   # Set the w and h of your window
glutInitWindowPosition(0, 0)   # Set the position at which this windows should appear
wind = glutCreateWindow("OpenGL Coding Practice") # Set a window title
glutDisplayFunc(showScreen)
glutIdleFunc(showScreen) # Keeps the window open
glutMainLoop()  # Keeps the above created window displaying/running in a loop

Ejecutar el código anterior dibujaría un cuadrado, pero ese cuadrado no sería visible ya que su color sería el mismo que el color de nuestra ventana, por lo que necesitamos asignarle un color diferente también, para eso haremos algunos cambios en “Sección 2” del código anterior, es decir, el showScreen función. Agregue la siguiente línea debajo del glLoadIdentity declaración y por encima de la square() declaración:

glColor3f(1.0, 0.0, 3.0) # Set the color to pink

Sin embargo, nuestro código aún no está completo. Lo que hace actualmente es dibujar el cuadrado una vez y luego limpiar la pantalla nuevamente. No queremos eso. En realidad, ni siquiera seremos capaces de detectar el momento en que realmente dibuja el cuadrado porque aparecería y desaparecería en una fracción de segundo. Escribamos otra función para evitar esto.

# Add this function before Section 2 of the code above i.e. the showScreen function
def iterate():
    glViewport(0, 0, 500,500)
    glMatrixMode(GL_PROJECTION)
    glLoadIdentity()
    glOrtho(0.0, 500, 0.0, 500, 0.0, 1.0)
    glMatrixMode (GL_MODELVIEW)
    glLoadIdentity()

Llame a esta función iterativa en la “Sección 2” del código anterior. Agrégalo a continuación glLoadIdentity y por encima del glColor3d declaración en el showScreen función.

Ahora compilemos todo esto en un solo archivo de código para que no haya ambigüedades:

from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *

w,h= 500,500
def square():
    glBegin(GL_QUADS)
    glVertex2f(100, 100)
    glVertex2f(200, 100)
    glVertex2f(200, 200)
    glVertex2f(100, 200)
    glEnd()

def iterate():
    glViewport(0, 0, 500, 500)
    glMatrixMode(GL_PROJECTION)
    glLoadIdentity()
    glOrtho(0.0, 500, 0.0, 500, 0.0, 1.0)
    glMatrixMode (GL_MODELVIEW)
    glLoadIdentity()

def showScreen():
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
    glLoadIdentity()
    iterate()
    glColor3f(1.0, 0.0, 3.0)
    square()
    glutSwapBuffers()

glutInit()
glutInitDisplayMode(GLUT_RGBA)
glutInitWindowSize(500, 500)
glutInitWindowPosition(0, 0)
wind = glutCreateWindow("OpenGL Coding Practice")
glutDisplayFunc(showScreen)
glutIdleFunc(showScreen)
glutMainLoop()

Cuando ejecute esto, debería aparecer una ventana con un cuadro cuadrado de color rosa.

Salida:

Conclusión

En este tutorial, aprendimos sobre OpenGL, cómo descargarlo e instalarlo, seguido de su uso y un breve programa de ejemplo. En este ejemplo, también practicamos la creación de una forma básica usando OpenGL, lo que nos dio una idea de algunas llamadas de funciones complejas que deben realizarse cada vez que necesitamos dibujar algo usando esta biblioteca. Para concluir, OpenGL es muy ingenioso y se vuelve cada vez más complejo a medida que profundizamos en él.

 

About the author

Ramiro de la Vega

Bienvenido a Pharos.sh

Soy Ramiro de la Vega, Estadounidense con raíces Españolas. Empecé a programar hace casi 20 años cuando era muy jovencito.

Espero que en mi web encuentres la inspiración y ayuda que necesitas para adentrarte en el fantástico mundo de la programación y conseguir tus objetivos por difíciles que sean.

Add comment

Sobre mi

Últimos Post

Etiquetas

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con tus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, aceptas el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Más información
Privacidad