Ceibal-Chess en Español de Uruguay

• Mejor Integración con Sugar.
• Internacionalización, soporte para Español e Inglés.
• Mejoras Visuales*

Mejor Integración con Sugar

La nueva versión hace uso del excelente paquete “sugargame” para mejorar significativamente la integración entre Pygame y Sugar.

La Beta 3 permite acceder al Marco y terminar/reanudar la Actividad desde la Vista Personal. También se resuelve el problema de “ícono muerto” en el escritorio tras ejecutar Ceibal-Chess, el cual prevenía que la Actividad pudiera iniciarse dos veces consecutivas.

Internacionalización

Ceibal-Chess soporta ahora internacionalización de Strings y la nueva versión se distribuye con soporte para los idiomas Español e Inglés. Contribuciones para otros idiomas serán bienvenidas, si alguien se encuentra interesado.

Ceibal-Chess debería detectar automáticamente el idioma en el cual se encuentra la plataforma y seleccionar su propio idioma en función de dicho entorno. En caso de que un entorno no sea soportado, se revertirá a Inglés automaticamente.

Mejoras Visuales

Ceibal-Chess incluye un efecto de transición entre estados del tablero (mediante Alpha Blending). Este efecto requiere Pygame 1.8 o superior. En plataformas donde se dispone de Pygame 1.7, este efecto se encontrará dehabilitado y un mensaje será escrito en el Log.

Descarga

Pasos para XO:

1. Remover la Actividad “Ajedrez”, si esta se encuentra instalada y reiniciar Sugar (Ctrl + Alt + Erase).
2. Iniciar la Actividad “Navegar”, dirigirse a http://www.ceibaljam.org y hacer click en “Descargas”.
3. Identificar la fila correspondiente a “Ceibal-Chess” y descargar el bundle “ajedrez.xo”. Una vez descargado, seleccionar “Abrir” en el navegador.

Pasos para otras plataformas (Windows, Linux, Mac con Python y Pygame):

1. Iniciar el navegador Web e ingresar la siguiente dirección: http://www.algorithmia.net/software/download.py?dl=ceibal-chess-beta.zip
2. Descomprimir el zip y dirigirse al Directorio “ceibal-chess-beta3″.
3. Ejecutar el script “main.py”.

Reportar Errores

Como siempre, su feedback es invaluable para corregir problemas y asegurarnos que Ceibal-Chess se encuentre en un buen estado para alcanzar la versión 1.0.

Para reportar errores, por favor utilizar el siguiente formulario: http://code.google.com/p/ceibal-chess/issues/list

d = a – b #diferencia de conjuntos.

Utilizando las construcciones funcionales de Python (en particular List Comprehension), resulta muy sencillo:

d = [x for x in a if x not in b]

Vean como la construcción del lenguaje prácticamente se lee como la definición formal de diferencia de conjuntos: “d es igual a x para todo x que pertenece a a y x no pertenece a b“.

Si comparamos esto con el equivalente imperativo, es fácil ver que estamos expresando mediante el lenguaje lo que queremos que se haga y no cómo hacerlo exactamente.

Esta sutileza nos permite ahorrar mucho código y ser más productivos desarrollando aplicaciones cuando no es crítico el mantener el control sobre cada instrucción exacta a ser ejecutada.

¿Qué otros ejemplos interesantes de manejo de listas sueles utilizar?

El trabajo consiste en desarrollar un programa que dibuja un conjunto de Fractales mediante un sistema iterativo de funciones. La siguiente imagen muestra el programa corriendo para una configuración que corresponde a una Hoja de Helecho:

Hoja de Helecho. Los cálculos del fractal fueron realizados en Cython y el resultado fue dibujado con Pygame.

La optimización principal para el Fractal consistió en reemplazar el uso de una lista de Python de 10.000 elementos (utilizada para almacenar los puntos calculados) por un array de C. Por menos que esto parezca, el evitar tener que usar la lista de Python mejoró la performance general del cálculo en un 11%, aproximadamente.

Dentro de todo, 11% no está mal, sobre todo si tenemos en cuenta que el único cambio fue la declaración de la lista (y escribir un archivo de setup). El compilador de Cython se encargó del resto.

Creo que por más que se encuentre en sus primeras versiones, Cython ofrece mucho potencial para optimizar aplicaciones Python. Todo lo que uno debe hacer es dedicar algo de tiempo para encontrar las porciones críticas en performance en su código, anotar las variables apropiadas con tipos de datos C, y dejar que Cython se encargue del resto.

Este programa, denominado pdfcube, aparentemente utilizaba OpenGL para dibujar la presentación y los efectos de transición, por lo cual me surgió la duda de cómo harían para convertir las páginas del documento en Texturas que pudieran aplicarse sobre objetos 3D.

Según aprendí leyendo el código fuente (el programa es de licenciamiento libre), aparentemente lo que se hace es abrir el documento utilizando una biblioteca que permite extraer información del PDF mismo, en particular, permite renderizar las páginas a un Pixmap, que luego puede ser convertido en una Textura. Esta biblioteca se denomina Poppler (sitio oficial), en honor a unos bichos de la serie de Fox: Futurama.

Investigando un poco más sobre esta biblioteca descubrí que se trata de un fork del proyecto xpdf-3.0 y es la biblioteca de rendering que utilizan varios programas conocidos como Evince, Okular y TeXworks, entre otros.

La biblioteca, que está desarrollada en C, tiene un wrapper sencillo para Python. Les dejo un pequeño snippet para que vean algunas cosas básicas que se puede hacer con ella.

#!/usr/bin/python

import sys
import poppler

def dump_props(fileuri):
	try:
		doc = poppler.document_new_from_file(fileuri, "")
	except Exception, ex:
		print "Error:", ex
		return

	print "Title: %s\nVersion: %s\nAuthor: %s\nCreated using: %s, %s" %\
		(doc.get_properties("title")[0], \
		doc.get_properties("format")[0], \
		doc.get_properties("author")[0], \
		doc.get_properties("producer")[0], \
		doc.get_properties("creator")[0])

if __name__ == "__main__":
	if len(sys.argv) > 1:
		dump_props(sys.argv[1])
	else:
		print "Usage: %s <URI>" % sys.argv[0]
		exit(-1)

La salida para una corrida de prueba sería:

./poppertest.py file:///home/ale/Downloads/GLSLangSpec.4.00.7.pdf

Title: The OpenGL Shading Language
Version: PDF-1.4
Author: John Kessenich
Created using: OpenOffice.org 2.0, Writer

Espero que a alguien le sirva! Happy Poppler-ing!

Inmediatamente esto me llamó la atención, debido a que el proceso estaba siendo configurado en modo “easy”, que deshabilita que se planifiquen jugadas durante el turno del usuario. Para peor, invocando gnuchess manualmente desde la terminal no provocaba este efecto.

Definitivamente se trataba de un tema a investigar en detalle.

Tras probar distintas invocaciones y parámetros, pude determinar que el problema resultó ser en la forma en que se creaba el subproceso.

Nuestra invocación era realizada aproximadamente de la siguiente forma:

from subprocess import Popen, PIPE
...
#Mal!!:
proc = Popen(args=["-e", "-x"], executable="/ruta/absoluta/a/gnuchess-linux", stdin=PIPE, stdout=PIPE, close_fds=True)

Resulta ser una sutileza, pero no se está brindando la ruta al ejecutable como primer argumento y si bien la llamada funciona de todos modos y el proceso es creado, tras comenzar a escribirle en su entrada estándar (stdin), éste comienza a utilizar el 100% del procesador.

Cambiar la llamada a Popen de forma tal que incluya el ejecutable como primer elemento de la lista args misteriosamente resuelve este problema.

Al probar el cambio sobre la XO, no solo se nota que el desempeño de la aplicación es mucho mejor (la interfaz de usuario tiene ahora más tiempo de CPU disponible), sino que además se solucionó un problema con un molesto icono que quedaba trancado en la vista home de Sugar.

Los cambios ya se encuentran commitieados al repositorio y próximamente estaremos actualizando las versiones disponibles en Algorithmia y el sitio oficial del CeibalJam.

Cada elemento en el campo de vectores es representado visualmente por un cuadrado (piensa en una baldoza) y una flecha (que representa la dirección). Cada cuadrado se forma con dos triángulos y cada flecha con tres, por lo cual para un campo de vectores de tan solo 16×16 estaríamos dibujando 1.280 triángulos, mientras que para un campo más grande de 64×64 estaríamos trabajando con un total de 20.480 triángulos.

Logo de PyOpenGL

La diferencia en desempeño fue increible. Con un mediano trabajo de refactoring logré obtener una aceleración que permitía redibujar la escena mucho más rápido, tanto más que no me alcanza el refresh rate del monitor para dibujar todos los cuadros que son generados por segundo.

Convertir el código de rendering de Modo Inmediato de OpenGL a VBO’s no fue tarea sencilla sin embargo. El problema fundamental consistió en que para trabajar con VBO’s se deben realizar transferencias de porciones de memoria RAM a buffers en memoria de video, por lo cual es necesario realizar un manejo bastante importante de punteros. Manejar punteros no es problema desde un lenguaje como C o C++, pero se puede llegar a complicar cuando se está trabajando en Python.

El primer problema consistía en convertir las listas de vertices y colores de listas Python a arrays contínuos en memoria. Para esto (y mucho a mi pesar) debí utilizar NumPy.array, lo cual solucionó el problema, pero al costo de agregar una nueva dependencia al código: numpy. Lo bueno es que teniendo un NumPy array, resulta sencillo generar los tipos adecuados para que los datos lleguen correctamente a la memoria de video. El siguiente snippet muestra la llamada a la función de copia de memoria:

from OpenGL.GL import *
from OpenGL.arrays import ArrayDatatype as ADT
import numpy
...
array = numpy.array(vertices_and_colors, dtype=numpy.float32)
glBufferData(GL_ARRAY_BUFFER, ADT.arrayByteCount(array), ADT.voidDataPointer(array), GL_STATIC_DRAW)

El segundo problema que tuve consitió en cómo indicarle a PyOpenGL los offsets dentro del buffer. El buffer de memoria que estoy utilizando está cargado tanto con datos de vértices como de colores, por lo cual debía poder especificar dónde empiezan los vértices y dónde empiezan los colores (en offset de bytes) a la API. Si bien esto parecía sencillo utilizando ctypes, se complicó bastante debido a un bug en PyOpenGL 3.0. La solución fué descargar el código de la Beta de PyOpenGL 3.0.1, compilarlo y hacer uso de ésta biblioteca en vez de la versión disponible en los repositorios de Ubuntu y Macports (actualmente ambas presentan este bug).

Una vez actualizada la biblioteca, crear un puntero genérico (void *) resultó trivial, como se muestra a continuación.

from ctypes import c_void_p
...
glColorPointer(3, GL_FLOAT, 0, c_void_p(colors_offset))

Quiero mencionar que cuando escribí en la lista de usuarios de PyOpenGL preguntando por este último problema, quien me respondió que en realidad se trataba de un bug en la biblioteca no fué ni más ni menos que el autor de la misma (!)

La presentación comenzó con una introducción al por qué iniciar un nuevo proyecto, las ventajas desde el punto de vista del desarrollador de hacer que este sea Software Libre u Open Source, y luego continuamos presentando distintas herramientas para el desarrollo. Dentro de este marco se habló de wikis, Software de gestión de la configuración (svn, hg), Issue Trackers y lenguajes de programación, en particular se realizó una pequeña introducción a Python (aunque nada cerca de la gran presentación de Marcelo Ramos en el Anfiteatro).

Durante la parte interactiva de la presentación se desarrollaron varios scripts que pueden resultar de utilidad a alguien que recién esté comenzando en python y le interese la parte de gráficos 2D con PyGame y 3D con OpenGL.

Los ejemplos, junto con las trasparencias de la presentación pueden descargarse del siguiente enlace:

http://www.algorithmia.net/software/download.py?dl=flisol09.zip

Dentro del archivo se incluyen los siguientes ejemplos:

• penguin.py – ejemplo sencillo que muestra como crear una ventana con PyGame y dibujar un png sobre ella.
• demo.py – ejemplo sencillo 2D de animación basada en el tiempo (gracias a Gabriel Eirea).
• holamundo.py – ejemplo intermedio que muestra como dibujar texto con PyGame.
• gl.py – ejemplo avanzado que muestra como integrar OpenGL con PyGame para dibujar una priámide 3D y animarla.