Breve introducción a OpenGL en Python con PyOpenGL

    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.

     

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *