Introducción a PyGegl

Aclaremos que esto es una introducción porque yo me estoy introduciendo en esto y no porque sepa mucho.
Con esto aclarado, arranco.
Lo primero es tener compilado pygegl. Esto se hace entrando en la carpeta

dondetegamosbajadogegldegit/bindings/pygegl

y hacer el viejo y querido

$ ./autogen.sh
$ make
$ sudo make install

Si todo salió bien, tenemos pygegl listo para usar.
Lo primero es asegurarnos que funciona bien, esto lo podemos hacer probando los ejemplos que hay en la carpeta samples o corriendo Idle y haciendo import Gegl. Si python no chilla, podemos empezar.

Lo que hay que saber de Gegl ( que es lo que se yo hasta ahora ) es que trabaja sobre la base de que es un grafo acíclico. Esto significa que las operaciones son nodos que se van uniendo para armar dicho gráfico, que luego se procesa para generar la salida.
Uno de los samples nos genera un html con todas las operaciones que soporta nuestra compilación de gegl.
Por ejemplo, yo quería usar las fotos del modelo de origami del post anterior, pero no pude, porque no compilé el soporte para jpg, así que tuve que usar un png.

A continuación el código comentado:

# -*- coding: utf-8 -*-

#importamos gegl para poder trabajar
import Gegl

# lo primero es pedir un nodo, que va a ser la representacion 

# de nuestro grafo
gegl = Gegl.Node()

# el primer nodo, que creamos con new_child, es la operacion

# para abrir un archivo.
# pygegl me reporto un metodo "gegl:png-load" que intente

# usar al principio,
# pero sin exito.
nodo_entrada = gegl.new_child("gegl:load", path="test.png")

# el nodo de salida que va a guardar la imagen
nodo_salida = gegl.new_child("gegl:png-save", path="test2.png")

# conectamos los nodos y formamos el grafo
nodo_entrada >> nodo_salida

# procesamos el nodo de salida, que a su vez va a procesar 

# los nodos relacionados.
# esta process() solo se llama en algunos tipos de nodos.
nodo_salida.process()

Este sencillo ejemplo abre una imagen y la vuelve a guardar.
Para la próxima, un ejemplo más complejo y si no tengo tanta fiaca, veo de poner resaltado de sintaxis.

Haciendo andar Gegl

Por esas cosas de la vida se me ocurrio probar la libreria GEGL. La idea era jugar con python y ver que salia.
Gegl parte un concepto interesante, que es el de procesar imagenes de manera no destructiva usando un modelo de grafo aciclico para encadenar las operaciones.
Es la base a partir de la cual se esta refactorizando Gimp.

Lo primero que hice y ante la falta de binarios para Windows, arranque Ubuntu y me propuse compilarlo desde las fuentes.
1 - Bajar los fuentes con Git:

$ git clone git://git.gnome.org/babl
$ git clone git://git.gnome.org/gegl

La principal dependencia es Babl, que es una libreria para transformar formatos de bitmap.

Ademas de esto tiene varias dependencias mas que les van a ir saltando. Yo fui instalando a medida que me pedia hasta que logre una instalacion minima que me dejo compilar.
Hacia tiempo que no compilaba nada desde fuente, creo que desde que Slackware 7 era nuevo, Ubuntu y Debian lo malcrian a uno.

El proceso es casi el mismo, parecen haber mejorado un poco las herramientas.

$ ./autogen.sh
$ make
$ sudo make install

Un consejo, la hora de compilar gegl, usen el siguiente comando para configurar

./autogen.sh BABL_LIBS=~/desarrollo/babl/babl/.libs/libbabl-0.1.so.0.104.1 CFLAGS="-O0" --disable-docs

Por un lado le decimos donde esta la libreria babl que compilamos antes, no lo dije pero supongo que lo habran supuesto y por el otro deshabilitamos los docs. Si no los deshabilitamos, tira error que no encuentra unos png y no me dieron ganas de renegar con eso.

Una vez compilados babl y gegl, hay que hacer lo mismo con pygegl. Los fuentes estan adentro de gegl, asi que hay que ir a la carpeta /bindings/pygegl y otra vez el show de autogen y make y make install.

Ahi queda andando la cosa. Probe los ejemplos que vienen en la carpeta samples, solo uno me genero algo.

Asi que ahora estoy viendo de armar algo yo y que si no me da fiaca, lo pongo en otro post.