Breve introducción a OpenGL en Python con PyOpenGL

En este tutorial, aprenderemos a usar la biblioteca PyOpenGL en Python. OpenGL es una biblioteca de gráficos compatible con varias plataformas, incluida W...

Introducción

En este tutorial, vamos a aprender a usar la biblioteca PyOpenGL 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 fácil de instalar OpenGL usando Python es a través del administrador de paquetes pepita. Si tiene pip instalado en su sistema, ejecute el siguiente comando para descargar e instalar OpenGL:

1
$ pip install PyOpenGL PyOpenGL_accelerate

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

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

1
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 a la carpeta donde descargó esos archivos y ejecute el siguiente comando en la terminal o en el símbolo del sistema:

1
$ python setup.py

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

Ahora que hemos instalado correctamente OpenGL en nuestro sistema, ensuciémonos las manos con él.

Ejercicio de codificación {#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:

1
import OpenGL

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

1
2
3
4
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:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
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 cualquier forma o hacer cualquier otro tipo de gráfico, debemos 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 de la x- eje. Entonces, el punto superior izquierdo de su ventana sería (0, 500), el superior derecho sería (500, 500), el inferior derecho 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 de la pantalla completa de su computadora.

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
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 también debemos asignarle un color diferente, para eso haremos algunos cambios en "Sección 2" del código anterior, es decir, la función showScreen. Agregue la siguiente línea debajo de la declaración glLoadIdentity y arriba de la declaración square():

1
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 borrar la pantalla nuevamente. No queremos eso. En realidad, ni siquiera podremos 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.

1
2
3
4
5
6
7
8
# 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 de iteración en "Sección 2" del código anterior. Agréguelo debajo de glLoadIdentity y encima de la declaración glColor3d en la función showScreen.

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
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.

Producción:

{.img-responsive}

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 con OpenGL, lo que nos dio una idea de algunas llamadas de funciones complejas que deben realizarse cada vez que necesitamos dibujar algo con esta biblioteca. Para concluir, OpenGL es muy ingenioso y se vuelve más y más complejo a medida que profundizamos en él.