AUTORES: M. ROCÍO GARCÍA DE LA FUENTE Y AGUSTÍN GONZÁLEZ REDONDO.
Hoy volvemos de nuevo a trabajar con Python, en este caso, añadimos nuevas posibilidades a una IDE que ya conocemos, Processing, además de trabajar con este lenguaje de programación realizaremos una primera animación en 3D.
Para comenzar debemos añadir un nuevo modo de trabajo para poder interpretar el código que vamos a escribir, lo podemos realizar sencillamente a través de menú de herramientas de Processing o añadiendo un nuevo modo:
- Abrimos el menú de herramientas de Processing (figura 1. Accesos a la ventana de herramientas).
- Seleccionamos la pestaña de modos (figura 2. Ventana de herramientas de Processing).
- Elegimos “Python Mode for Processing 3” de Jonathan Feinberg (figura 2).
- Por último, elegimos la opción de instalar en la parte inferior de la ventana (figura 2. Ventana de instalación del Modo Python Processing).
Para comenzar a programar con Python, basta con seleccionar el modo Python la IDE (figura 3. Selección del modo de trabajo en Processing) se reiniciará automáticamente y, ahora ya estamos en disposición de comenzar a trabajar.
Inicialmente definiremos las variables necesarias para dibujar un objeto, en este caso una esfera:
- Variables de posición del objeto (x, y, z), que modificaremos durante la ejecución del código.
- Radio de la esfera.
También incluiremos unas variables de velocidad en los distintos ejes del espacio, que nos permitirán definir la rapidez con la que se desplaza nuestro objeto, en este caso sólo le damos valor al “velZ”, para que el objeto solamente se aleje de nosotros.
radio=20
x=150
y=150
z=0
velX=0
velZ=-0.25
velY=0
A diferencia de otros lenguajes de programación, no es necesario definir el tipo de variables que se está empleando, aunque también se puede hacer, ya que Python reconoce de manera automática el tipo de variable con la que se está trabajando (enteras: como el radio, o de coma flotante como el valor de velZ).
Y, en cuanto a los comentarios se refiere, en este caso deben ir precedidos de una almohadilla “#”, a diferencia de C++ o Java donde llevan “//” delante.
A continuación, al igual que con cualquier otro programa realizado con Java en Processing, llamaremos a la función “setup()” (def setup()), para inicializar la pantalla de dibujo, y crearemos un espacio en tres dimensiones, usando la función size(***,***,P3D):
#Inicializacion del lienzo en 3D
def setup():
size(200,200,P3D)
#finaliza la funcion def setup()
Otra de las particularidades de Python es el sangrado, que es obligatorio, se hace con espacios en blanco o saltos de tabulación y sirve para agrupar bloques de líneas de código que tienen relación a distintos niveles. Se utiliza con estructuras de control (if-else, while, for), o con funciones, como en el caso que nos ocupa, donde todo lo que está incluido en la función setup() esta desplazado un salto de tabulador.
Utilizando este concepto, que por otra parte, hace que la lectura del código sea más agradable podemos utilizar la función “beginShape()……endShape()”, para dibujar tres paredes cuadradas y el suelo en el lienzo, que nos darán una sensación tridimensional, y una referencia gráfica del dibujo ()” (figura 4. Paredes dibujadas por puntos en el lienzo). Todo ello dentro de la función “def draw()” , cuyo código vemos a continuación:
def draw():
#dibujamos las paredes de color negro
fill(0)
beginShape()
vertex(0,0,0)
vertex(0,0,-200)
vertex(0,200,-200)
vertex(0,200,0)
endShape()
beginShape()
vertex(0,0,-200)
vertex(200,0,-200)
vertex(200,200,-200)
vertex(0,200,-200)
endShape()
beginShape()
vertex(200,0,-200)
vertex(200,0,0)
vertex(200,200,0)
vertex(200,200,-200)
endShape()
#dibujamos el suelo de color gris
fill(100)
beginShape()
vertex(0,200,0)
vertex(0,200,-200)
vertex(200,200,-200)
vertex(200,200,0)
endShape()
De la misma forma que hemos hecho con las paredes, dibujadas en la función, incluiremos ahora las ordenes que se repetirán de forma continua para animar el objeto que hemos dibujado, en este caso una esfera.
#desplazamos los objetos
global x,y,z,velY,velZ,velX
#desplazamiento de la esfera
z=velZ+z
translate(x,y,z)
#dibujamos la esfera
stroke(255)
sphere(radio)
#finaliza la función def draw()
En el caso que nos ocupa, el programa realizará el desplazamiento de una esfera, paralelo al eje z, por lo que su tamaño va disminuyendo de tamaño conforme se aleja de la posición inicial, tal y como ocurre en la realidad con los objetos que se alejan de nosotros, hasta desaparecer detrás de la pared del fondo del dibujo (figura 5. Varias posiciones de la esfera durante la ejecución del código en Processing).
Para finalizar, hemos trabajado nuevas posibilidades de la IDE Processing, en este caso:
- Añadimos el modo Python como intérprete.
- Añadimos objetos tridimensionales a nuestro lienzo de trabajo.
Os proponemos esta alternativa, como una nueva forma de acercaros a un lenguaje de programación muy empleado en la actualidad y que a través de la IDE Processing añade muchas posibilidades, especialmente gráficas, a nuestros proyectos.
