Casita de madera

   

Esta es la caseta de madera que he estado haciendo los últimos 5 meses. Tuve la suerte de encontrarme por Navidades bastante madera machihembrada, y me la llevé toda arriba la terraza. El tiempo me diría más tarde que la cantidad de madera que recogí fue casi la que necesité, sólo tuve que comprar meses más tarde algunos tablones para acabar el tejado. Era madera de pino de buena calidad, aunque estaba sucia y llena de clavos.

Lo primero que hice fue subir la electricidad arriba la terraza: 30 metros de cable eléctrico. Instalé dos enchufes en un extremo de la terraza, y dos más en el otro extremo.

Como se ve en las fotos, la terraza hace un rincón donde se ha ubicado la caseta, de manera que no se pierde superficie útil de la terraza. La primera tarea fue nivelar lo que sería el suelo de la caseta, pues como es piso de terraza hay un desnivel para el desagüe. Construí una estructura básica de jaula, que definía las dimensiones generales que tendría la caseta. Al final son 3,5m2 de superficie. Poca cosa, pero teniendo en cuenta el preu a que va el m2 en Barcelona, pues ya puedo estar contento.

Una vez hecha la jaula ya se puede empezar a poner, fijar y clavar los tablones. Me fue de perlas la sierra circular, que estrenaba, y los dos tornavises eléctricos de que disponía (suerte que tenía dos, pues los dos no me duraban una mañana intensa de trabajo). Al final fueros unos 700 tornillos. Primero se hizo el suelo, y después se iban subiendo las paredes, dejando una abertura para las puertas y las dos ventanitas.

Cuando acabé de subir las paredes, fue el momento de cubrir el tejado. Acabé lol últimos tablones que me quedaban. O sea que tube que calcular la madera que me faltaría. Para economizar al máximo encontré tablones de 3 cm de grosor y 2 metros de largo a 1 euro, todo un saldo, que se tuvieron que cortar transversalmente, convirtiéndose en dos tablones de 1,5cm. Toda una faena.


A medida que iba cubriendo el tejado se tenía que poner la tela asfáltica y fijarla con clavos y soplete. Esto de los clavos fue un error, pues a la primera lluvia vi que habían goteras. Y es que construir esta caseta ha sido todo un ejercicio continua de tomar decisiones, a menudo acertadas, a veces no. Por tanto, fue preciso una nueva capa de tela asfáltica para impermeabilizar correctamente la cubierta.

Una vez acabado el tejado, se pusieron la puerta y las ventanas. Varnizar toda la superficie exterior, y mirar que las juntas del suelo quedasen lo mejor posible, cosa difícil dado que el machihembrado original estaba en mal estado. Entonces se llevó la electricidad dentro de la caseta, se hizo todo un anillo de estanterías, y finalmente dos mesas hechas a medida y con madera reciclada encontrada en la calle.

Antes de dar por inaugurada la caseta era preciso pintar toda la terraza y dejarlo arreglado, pues estaba en un estado realmente deplorable. Además, limpiar y fregar mucho el suelo. Tareas duras teniendo en cuenta que de golpe y porrazo ha venido el calor del verano. Se encuentra mucho a faltar, ahora y en el futuro, tener agua corriente en la terraza.

Ahora que ya se puede dar por acabada la caseta hicimos la inauguración como se merece con Rita, Maria y Pere, con una cena al fresco (sentándonos en el suelo de la terraza, la caseta no da para tanto!).

Resumiendo, el gasto de la caseta han sido unos 250e, teniendo en cuenta que la mayoría del material que se ha utiltizado son maderas y otro reciclaje. y muchas horas de trabajo. Un chollo teniendo en cuenta el presupuesto de hacer una caseta de madera. Además, ahora que aprieta el calor se nota que la madera aísla muy bien, al contrario de otras soluciones comerciales como casetas de resina o de plancha de hierro. ¿Y qué se hará dentro? Pues básicamente la idea es meter dentro de la caseta una máquina CNC para hacer trabajos con madera, metacrilato y hacer cirucuitos impresos, pero esto será otra historia. I además poder trabajar arriba en la terraza con las tareas sucias que no se pueden hacer en casa o en una oficina.

diatonicbaixos v1.0: ayuda para los bajos del acordeón diatónico

Maria está estudiando el acordeón diatónico (y de paso yo también me he enganchado). Una de las cosas que siempre he encontrado difíciles es la coordinación de la mano derecha (con la que tocamos la melodía) y la mano izquierda (los bajos). Igual que pasa con el piano, que siempre me ha parecido difícil tocar con las dos mans al mismo tiempo.

Aquí va un pequeño programa para ayudar a poner la mano izquierda en el acordeón diatónico. Mientras suena la melodía (se necesita el fichero midi de la melodía), por pantalla se muestran las posiciones de los bajos que se han de tocar (en el acordeón diatónico hay 8 botones para los bajos/acordes, que suenan diferente si abres o cierras el fuelle). Cuando se muestra un botón en color verde significa que hay que cerrar el fuelle; en color rojo hay que abrirlo.

Para la interficie gráfica se ha utilizado la librería ncurses, que es la primera vez que programaba en esta llibrería (y estoy muy contento del resultat obtenido). El programa es un cliente de JACK (el servidor de audio para Linux, www.jackaudio.org), y de hecho es el time master, es decir, controla el transporte. Para utilizar la aplicación lo mejor es lanzar el script bash que se proporciona, diatonicbaixos.sh, donde se pone de manifiesto toda la cadena de programas que se utilizan.

Primero de todo se cambia el tempo deseado al fichero midi mediante el script change_tempo_smf (se proporciona el código fuente). Luego se arranca el servidor JACK, y el sintetizador fluidsynth, que es el que hará sonar la melodía. Después arrancamos la utilitat jack-smf-player, que se encargará de hacer sonar la melodía. También arranco el klick, que es un metrónomo cliente de JACK. Finalmente ya puedo lanzar mi aplicación, diatonicbaixos. El resultado, com se ve en el video, es que suena la melodía mientras se van mostrando las posiciones de los bajos. Se puede cambiar el tempo, se puede habilitar o no el metrónomo, y hay otro parámetro que permite mostrar el siguiente bajo que se tendrá que pulsar.

Para hacerse una idea del funcionamiento del programa lo mejor es ver el video:

Descargar diatonicbaixos v1.0

50 ways… #6. Editores de partituras: Lilypond

En el anterior post creamos un soundfont para acordeón diatónico, castagnari.sf2, y con sus sonidos tocamos mi canción preferida: Una Plata d’Enciam, dentro del proyecto 50 ways to play Una Plata d’Enciam. Vamos a ver ahora cómo con el editor de partituras Lilypond podemos crear una partitura muy correcta, que responda a los retos que nos plantea la notación para el acordeón. Lo que haremos en este post no es nada del otro mundo. En el blog amigo Scores of Beauty, http://lilypondblog.org/, se lleva al extremo las posibilidades de lilypond.

Básicamente lo que queremos es visualizar correctamente la melodía, los acordes, y cómo se han de tocar los bajos/acordes de la mano izquierda (es decir, el acompañamiento). La idea es crear unas partituras didácticas que ayuden a mi hija a poner los dedos de la mano izquierda.

Lo primero que haremos es crear la melodía, pondremos encima de las notas los acordes en la forma habitual, y mostraremos cuándo se ha de tocar un bajo (b) o un acorde (a) con la mano izquierda. Esto último lo haremos con \\lyrics, como si fuese la letra de una canción.

\\version «2.12.1»
\\header {
title = «Una Plata d’Enciam»
composer = «tradicional catalana»
}

baixosnotacio = \\chordmode {
c4 c f c f g g c c c f c f g g c
c4 c f c f g g c c c f c f g g c
}

partitura = \\relative c’
<<
\ew ChordNames {
\t\\set chordChanges = ##t
\t\\baixosnotacio
}

\ew Staff = «veu 1»
{
\\clef treble
\\key c \\major
\\time 2/4
\\tempo 4=80

\te8 f g g a a g4 \\times 2/3 { a8 a g } f f \\times 2/3 { f f f } g e e f g g a a g4 \\times 2/3 { a8 a g } f f f g e4
\te8 f g g a a g4 \\times 2/3 { a8 a g } f f \\times 2/3 { f f f } g e e f g g a a g4 \\times 2/3 { a8 a g } f e f g e4
}
\\addlyrics {
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
}

>>

\\score {
\\partitura
\\layout { }
\\midi { }
}

Ahora vamos a poner los bajos. Si lo hacemos en la forma habitual funciona, pero queda una partitura que no és útil para su lectura. Además, no es correcta, pues como se ha explicado en el anterior post la asociación entre los acordes CM, DM,… y las notas midi 24, 26,… fue una decisión arbitria. Quedaría de la siguiente manera:

\\version «2.12.1»
\\header {
title = «Una Plata d’Enciam»
composer = «tradicional catalana»
}

baixosnotacio = \\chordmode {
c4 c f c f g g c c c f c f g g c
c4 c f c f g g c c c f c f g g c
}

partitura =
<<
\ew ChordNames {
\t\\set chordChanges = ##t
\t\\baixosnotacio
}

\\relative c’
\ew Staff = «veu 1»
{
\\clef treble
\\key c \\major
\\time 2/4
\\tempo 4=80
\t%notes amb valors relatius
\te8 f g g a a g4 \\times 2/3 { a8 a g } f f \\times 2/3 { f f f } g e e f g g a a g4 \\times 2/3 { a8 a g } f f f g e4
\te8 f g g a a g4 \\times 2/3 { a8 a g } f f \\times 2/3 { f f f } g e e f g g a a g4 \\times 2/3 { a8 a g } f e f g e4
}
\\addlyrics {
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
}

\ew Staff = «baixosnotes»
{
\\key c \\major
\t%notes amb valors absoluts
\tc,8. r16 c,,8 r f,8. r16 c,,8 r f,8. r16 g,,8 r g,8. r16 c,,8 r
\tc,8. r16 c,,8 r f’8. r16 c,,8 r f,8. r16 g,,8 r g,8. r16 c,,8 r
\tc,8. r16 c,,8 r f,8. r16 c,,8 r f,8. r16 g,,8 r g,8. r16 c,,8 r
\tc,8. r16 c,,8 r f,8. r16 c,,8 r f,8. r16 g,,8 r g,8. r16 c,,8 r
}
>>

\\score {
\\partitura
\\layout { }
\\midi { }
}

Aquí es importante remarcar que se ha utilizado la notación relativa para la melodía, y la notación absoluta para los bajos, que simplifica mucho escribir la alternancia entre bajos y acordes. Esta partitura no es correcta para su impresión, pero el fichero midi que produce sí que es correcto. ¿Hay una manera de solucionarlo? Sí. Se puede definir un \\score para ser impreso, y otro \\score para generar el fichero midi. El resultado queda de la siguiente manera: la partitura para imprimir es correcta (no aparecen las notas de los bajos, sólo las posiciones donde hemos de poner los dedos de la mano izquierda); y el fichero midi resultante también es correcto:

\\version «2.12.1»
\\header {
title = «Una Plata d’Enciam»
composer = «tradicional catalana»
}

baixosnotacio = \\chordmode {
c4 c f c f g g c c c f c f g g c
c4 c f c f g g c c c f c f g g c
}

partitura = \\relative c’
<<
\ew ChordNames {
\t\\set chordChanges = ##t
\t\\baixosnotacio
}

\ew Staff = «veu 1»
{
\\clef treble
\\key c \\major
\\time 2/4
\\tempo 4=80
\te8 f g g a a g4 \\times 2/3 { a8 a g } f f \\times 2/3 { f f f } g e e f g g a a g4 \\times 2/3 { a8 a g } f f f g e4
\te8 f g g a a g4 \\times 2/3 { a8 a g } f f \\times 2/3 { f f f } g e e f g g a a g4 \\times 2/3 { a8 a g } f e f g e4
}
\\addlyrics {
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
}
>>

fitxermidi =
<<
\\relative c’
\ew Staff = «veu 1»
{
\\clef treble
\\key c \\major
\\time 2/4
\\tempo 4=80
\t%notes amb valors relatius
\te8 f g g a a g4 \\times 2/3 { a8 a g } f f \\times 2/3 { f f f } g e e f g g a a g4 \\times 2/3 { a8 a g } f f f g e4
\te8 f g g a a g4 \\times 2/3 { a8 a g } f f \\times 2/3 { f f f } g e e f g g a a g4 \\times 2/3 { a8 a g } f e f g e4
}

\ew Staff = «baixosnotes»
{
\\key c \\major
\t%notes amb valors absoluts
\tc,8. r16 c,,8 r f,8. r16 c,,8 r f,8. r16 g,,8 r g,8. r16 c,,8 r
\tc,8. r16 c,,8 r f’8. r16 c,,8 r f,8. r16 g,,8 r g,8. r16 c,,8 r
\tc,8. r16 c,,8 r f,8. r16 c,,8 r f,8. r16 g,,8 r g,8. r16 c,,8 r
\tc,8. r16 c,,8 r f,8. r16 c,,8 r f,8. r16 g,,8 r g,8. r16 c,,8 r
}
>>

\\score {
\\partitura
\\layout { }
}

\\score {
\\fitxermidi
\\midi { }
}

Finalmente podemos escuchar la canción Una Plata d’Enciam tal como quedaría con un acordeón diatónico:

Una Plata d’Enciam by joanillo

Referencias:

50 ways… #5. Cómo hacer un soundfont para acordeón

Mi hija está aprendiendo a tocar el acordeón diatónico. Se trata de un acordeón de botones de la marca Castagnari, modelo Studio, con dos hileras de botones en la mano derecha (afinadas en Sol y en Do), y los 8 botones de la mano izquierda son los bajos, divididos en 4 bajos y 4 acordes. Este es el tipo de acordeones que sonaban en les fiestas mayores de los pequeños pueblos del Pirineo. Cuando todavía no había carreteras para llegar a estos pueblos, en el siglo XIX y hasta entrado el siglo XX, los músicos habían de subir a los pueblos a pie o en mula. Por tanto era necesario acarrear instrumentos transportables. Muchas veces un acordeón y un violín animaban el baile en la plaza del pueblo.

En esta ocasión, ya que dispongo de un instrumento nuevo para mi, quiero hacer la práctica de crear un soundfont desde cero, y de esta manera podré utilizar el sonido de este instrument en diferents proyectos. Evidentmente, se ha de empezar mostreando todas las notas. Para hacerlo se utilizará un micrófono de una calidad óptima, intentando que no haya ruidos de fondo. Se grabará a un volumen adecuado, notas largas, y sin producir saturación, en un solo canal. Las muestras se van grabando de forma ordenada y utilizando un nombre de fichero adecuado de manera que no hi haya confusión posible. Para grabar las muestras he utilizado un Ubuntu 12.04 32 bits, interfície Edirol UA-25EX y un micrófono Beyerdynamic TG I5d2d. Se ha utilizado el siguiente comando:

arecord -r 44100 -f cd -t wav -D plughw:UA25EX accordion_C4.wav

Deberemos tener cuidado al samplear los bajos y los acordes, que son botones especiales. Una vez tengamos todas las muestras, con el Audacity editamos los ficheros de onda. Cogemos una parte significativa de la muestra sampleada, intentando que la envolvente sea periódica, y evidentmente no coger los extremos del fichero de onda. Nos aseguramos de que la muestra no tenga saturación, y amplificamos la muestra a un nivel razonable, de manera que todas las muestras tengan un volumen similar. El resultado de las muestras es el siguiente:

Samples Accordion Castagnari Studio by joanillo

Samples Accordion Castagnari Studio (Bass and chords) by joanillo

Entonces ya podemos empezar a utilizar el Polyphone, que será el entorno gráfico que utilizaremos para construir el soundfont. Lo primero que haremos es importar todas las muestras, y diremos cuál es la nota raíz de cada nota, de manera que ya le estamos asignando una frecuencia. Entonces creamos un instrument nuevo (por ejemplo Accordion), que será el único instrumento que contendrá este soundfont. Ahora es cuando tenemos que asociar cada muestra a una nota midi del instrumento que estamos editando. Por ejemplo, para la muestra accordion_C4.wav pondremos:

    \t

  • root key = 60
  • \t

  • key range = 60-60
  • \t

  • attack = 0,2s
  • \t

  • release = 0,2 s

Las notas de los bajos que se hacen con la mano izquierda se corresponden con las siguientes notas midi:

    \t

  • Bajo C = 36 (C2)
  • \t

  • Bajo D = 38 (D2)
  • \t

  • Bajo E = 40 (E2)
  • \t

  • Bajo F = 41 (F2)
  • \t

  • Bajo G = 43 (G2)
  • \t

  • Bajo A = 45 (A2)

Y un caso especial son los acordes que se hacen con la mano izquierda, que se asocian por convenio a las siguientes notas midi.

    \t

  • Acorde CM = 24 (C1)
  • \t

  • Acorde DM = 26 (D1)
  • \t

  • Acorde EM = 28 (E1)
  • \t

  • Acorde FM = 29 (F1)
  • \t

  • Acorde GM = 31 (G1)
  • \t

  • Acorde Am = 33 (A1)

Y es importante recalcar que esta asociación es un convenio. Cuando toque la nota midi 24 se disparará el sonido sampleado que corresponde al acorde CM.

Para los bajos y acordes se ha fijado los valores de attack y release a 0,6s.

Para acabar de definir el soundfont hemos de crear un nuevo preset asociado a este instrumento, de manera que el sonido de acordeón lo tendremos en el banco=0 y canal=0 (000:000). Finalmente ya puedo guardar el soundfont, castagnari.sf2, y ya lo puedo testear, en este caso con fluidsynth, haciendo sonar mi canción preferida: Una Plata d’Enciam, tocada a la manera cómo se hace con el diatónico: la melodía con la mano derecha, y alternando los bajos y los acordes con la mano izquierda.

/usr/bin/fluidsynth -s -l -j -a jack -m jack ./accordion_castagnari_studio.sf2 ./una_plata_denciam.midi

Una Plata d’Enciam by joanillo

En el siguiente post explicaremos cómo se ha generado el fichero midi que acabamos de tocar a partir del editor de partituras lilypond. Tenía ganas de hacer un post sobre lilypond, y concretament ahora que mi hija esta aprendiendo el diatónico, cómo se puede utilizar lilypond para la notación de acordeón.

Referencias:

Solución portátil para un saxo electrónico: Raspberry PI + soft o hard sinte

EWI-USB and Raspberry Pi

EWI-USB and Raspberry Pi

Para tocar el controlador de viento EWI-USB normalmente me conecto al portátil. Ejecuto el fluidsynth o cualquier otro soft sinte. Por tanto, la solución para practicar es EWI-USB + portátil + auriculares. Existe una solución más portable y autónoma? Definitivamente sí utilizando la Raspberry Pi, buscando una solución puramente consola y totalment desatendida: enchufar y tocar. En esta ocasión no utilizo JACK, es una solución purament ALSA. Se trata de instalar fluidsynth, algún soundfont que suene bien y que no pese demasiado, configurar el usuario pi con prioridad realtime, desinstalar cualquier servicio que no tenga que utilizar.

Con un script en /etc/udev/rules.d/ewiusb.rules conseguimos que en el momento que conecto el EWI-USB por el puerto USB se ejecuten los comandos que me permitirán tocar automáticamente: ejecutar fluidsynth y conectar la salida midi del EWI-USB a la entrada midi del fluidsynth. He tenido bastantes problemas con la letencia, pero el script que se muestra más abajo a mi em funciona bien sin latencia.

Además, con un poco de electrónica simple y utilizando los pins GPIO se podría cambiar fácilmente el programa midi y poder escoger entre diferentes instrumentos: saxo, midi, flauta,…

Otra posibilidad, como se ve en la fotografía, es utilizar un sinte hardware com el Roland JV-1010. Como la entrada del JV-1010 es puramente midi se necesita un cable conversor USB2MIDI (por ej, http://www.amazon.com/dp/B0017H4EBG), que muestra sus puertos a ALSA. Con esta solución no has de temer por la latencia, es una magnífica experiencia de usuario, y podemos escoger entre centenares de sonidos.

/etc/udev/rules.d/ewiusb.rules

#/etc/udev/rules.d/ewiusb.rules
ACTION==»add», SUBSYSTEMS==»usb», ATTRS{product}==»EWI-USB», RUN+=»/home/pi/ewiscript.sh»

/home/pi/ewiscript.sh

#!/bin/sh
#/home/pi/ewiscript.sh
#script que s’ha d’executar quan connectem el EWI-USB. Dos casos: a) synth hardware (roland); b) synth software (fluidsynth)

#mirem si tenim connectat el cable usb-midi
if [ -z `/usr/bin/aconnect -iol | grep USB2.0-MIDI | awk ‘/client/{print $1}’` ]; then

#no està connectat: b) synth software (fluidsynth)
if [ -z `pidof -s fluidsynth` ]; then
screen -d -m -S fluidsynth -t «fluidsynth» /usr/bin/fluidsynth -a alsa -m alsa_seq -g 1 -c 4 -z 256 -r 48000 /home/pi/Natural_Oboe.sf2
/bin/sleep 3
/usr/bin/amixer set Master 40%+ > /dev/null
/bin/sleep 2
FLUIDSYNTH=$(/usr/bin/aconnect -o -l | awk ‘/FLUID/{print $2.»0″}’)
/bin/sleep 2
#echo $FLUIDSYNTH
EWIUSB=$(/usr/bin/aconnect -o -l | awk ‘/client/’ | awk ‘/EWI-USB/{print $2.»0″}’)
/bin/sleep 2
/usr/bin/aconnect $EWIUSB $FLUIDSYNTH
/bin/sleep 2
fi
else
#a) synth hardware (roland)
USBMIDI=$(/usr/bin/aconnect -o -l | awk ‘/client/’ | awk ‘/USB2.0/{print $2.»0″}’)
/usr/bin/aconnect EWI-USB:0 $USBMIDI
/bin/sleep 2
fi

Más información, aunque en catalán, en la wiki

RPIJERS: Raspberry Pi Internet Jazz European Radio Stations


Quieres escuchar jazz todo el santo día? En Internet tienes bastante para escoger, por ejemplo, http://www.listenlive.eu/jazz.html. En este proyecto hemos indexado todas estas estaciones de radio para escucharlas de una forma simple y con una interfaz mínima. Y esto lo hemos conseguido con la Blackberry Pi. Sólo necesitamos alimentarla, enchufarla a un cable de red, conectarla a un amplificador, y un botón que nos sirve para arrancar el servicio mpd (Music Player Daemon) y para seleccionar hasta 40 canales.

Puedes descargarte de la wiki (http://wiki.joanillo.org/index.php/Raspberry_Pi:_Internet_Ràdio) el bash script i el fichero con la lista de todas las emisoras. Si quieres que el sistema funcione de forma totalmente desatendida tienes que hacer que el script arranque en el inicio del sistema. La electrónica necesaria es mínima, creo que en el video quedan claras las conexiones, y si no en la wiki hay más información (aunque en catalán).

Os deseo un feliz 2013 y mucho jazz! Aquí va el vídeo:

Programando con GIMP II. Pintar pixels en la pantalla

La verdad es que no hay mucha información y ejemplos para programar plugins con GIMP. Pero lo cierto es que la librería está bien documentada y se entiende bastante rápido si uno está familiarizado con la programación de otras APIs y con los conceptos de GIMP (capas, brushes,…).

GIMP Library Reference Manual:

A modo de ejemplo vamos a hacer lo que consideramos más básico: pintar pixels individuales sobre la pantalla. Del anterior enlace haremos un repaso a las diferentes posibilidades que nos ofrece la librería y nos fijamos en la siguiente entrada:

gimppixelfetcher — Functions for operating on pixel regions:

y aquí tenemos unas pocas funciones, concretamente la que necesitaremos para pintar pixels es

void gimp_pixel_fetcher_put_pixel (GimpPixelFetcher *pf,
gint x,
gint y,
const guchar *pixel);

el primer argumento es un puntero a un objeto GimpPixelFetcher que hemos inicializado previamente.

\tGimpPixelFetcher *pf;
\tpf = gimp_pixel_fetcher_new (drawable,FALSE);

Se inicializa a partir del drawable, que representa la capa sobre la que queremos pintar. Por tanto este puntero nos da un espacio de memoria que podem asociar a un pixel de una capa.

Los argumentos x, y son evidenmente las coordenadas donde queremos escribir el pixel.

Finalmente el puntero *pixel contiene la información del pixel, concretamente los 3 componentes del color.

Seguidamente mostramos la función principal pintar_pixel() de nuestro plugin, que lo que hace es pintar 5 pixels por pantalla, en las posiciones (20,0),…, (24,0). El código (fitxer gimp_pixel_fetcher_put_pixel.c) lo puedes descargar de la wiki, aunque está un poco sucio. El primer pixel tendrá el mismo color que el foreground que tengo seleccionado en ese momento; para el segundo pixel establezco un color con la función gimp_rgb_set(); el tercer pixel será igual que el pixel de la posición (0,0), utilizo la función gimp_pixel_fetcher_get_pixel(); para los cuarto y quinto pixel pongo directamente las coordenadas RGB del color.

Para compilar:

$ gimptool-2.0 –install gimp_pixel_fetcher_put_pixel.c

y el código:

static void pintar_pixel (GimpDrawable *drawable)
{
\tGimpPixelFetcher *pf;
\tgint x1, y1;
\tguchar *px; //pixel is an array of bpp bytes.
\tGimpRGB color;

\tx1=0;
\ty1=0;

\tpf = gimp_pixel_fetcher_new (drawable,FALSE);
\tpx = g_new (guchar, 1);

\t//1. escribo un pixel con el color del foreground
\tgimp_context_get_foreground (&color);
\t//g_message («%d,%d,%d»,(int)(&color)->r,(int)(&color)->g,(int)(&color)->b);
\tpx[0] = 255*(&color)->r; //rojo (0-255)
\tpx[1] = 255*(&color)->g; //verde (0-255)
\tpx[2] = 255*(&color)->b; //azul (0-255)
\tgimp_pixel_fetcher_put_pixel (pf, x1+20, y1, px);

\t//2. escribo un pixel y digo qué color quiero con la función gimp_rgb_set
\tgimp_rgb_set (&color, 0.0, 1.0, 1.0);
\tpx[0] = 255*(&color)->r; //rojo (0-255)
\tpx[1] = 255*(&color)->g; //verde (0-255)
\tpx[2] = 255*(&color)->b; //azul (0-255)
\tgimp_pixel_fetcher_put_pixel (pf, x1+21, y1, px);

\t//3. escribo un pixel igual que el de la posición (0,0)
\tgimp_pixel_fetcher_get_pixel (pf,x1, y1, px);
\t//g_message («%d,%d,%d»,(int)px[0],(int)px[1],(int)px[2]); //puedo obtener información del pixel (componentes RGB)
\tgimp_pixel_fetcher_put_pixel (pf, x1+22, y1, px);

\t//4. escribo un pixel y digo qué color quiero
\tpx[0] = 255; //rojo (0-255)
\tpx[1] = 0; //verde (0-255)
\tpx[2] = 0; //azul (0-255)
\tgimp_pixel_fetcher_put_pixel (pf, x1+23, y1, px);
\t// o bé
\t*px=0; //rojo (0-255)
\t*(px+1)=0; //verde (0-255)
\t*(px+2)=255; //azul (0-255)
\tgimp_pixel_fetcher_put_pixel (pf, x1+24, y1, px);

\tg_free (px);

\tgimp_pixel_fetcher_destroy (pf);

\tgimp_drawable_flush (drawable);
\tgimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
\tgimp_drawable_update (drawable->drawable_id,20,0,5,1);

}

Programando con GIMP I. Ejecutar plugins desde la consola

Con este artículo quiero empezar una serie de posts sobre la programación con GIMP. No es un tutorial para aprender a programar GIMP, tan sólo es poner en orden unas cuantas ideas enfocadas a un futuro proyecto, que básicamente es desarrollar un framework para poder explicar historias mientras dibujas sobre la pantalla con una wacom, y donce se suceden múltiples efectos visuales y sonoros. Si esta serie de posts se acaba, en el último podremos ver cómo se toca una melodía donde el pentagrama está dibujado sobre el GIMP y las notes las dibujo con el ratón o la wacom.
Ante todo necesitamos las librerías de desarrollo del GIMP:

$ sudo apt-get install libgimp2.0-dev

y aprendemos a programar un plugin a partir de un tutorial que si buscas por Google seguro que encuentras:

Con este tutorial, que implementa un blur (difuminador) aprendemos los conceptos básicos de la programación con GIMP. Nuestros plugins los programaremos en lenguage C. Para compilar el plugin haremos:

$ gimptool-2.0 –install myblur.c

Para ejecutar el plugin lo haremos des de dentro del GIMP con Filtros > Difumina > My Blur. O también lo podemos hacer con un script Script-Fu: Filtros > Script-Fu > Consola

(plug-in-myblur run-mode image drawable)

donde sustituimos run-mode, image i drawable por los valores correctos. Por ejemplo:

(plug-in-myblur RUN-NONINTERACTIVE 1 2)

Pero a mi lo que me interesa es ejecutar plugins desde fuera del GIMP, desde la consola. La primera manera de hacerlo es con el lenguatge de script propio del GIMP, el lenguaje Scheme.

example_script.scm:

(
define (example-script inputFilename outputFileName)
(
let* (
(image (car (gimp-file-load RUN-NONINTERACTIVE inputFilename inputFilename)))
(drawable (car (gimp-image-get-active-layer image)))
)
(plug-in-myblur RUN-NONINTERACTIVE image drawable)
(gimp-file-save RUN-NONINTERACTIVE image drawable outputFileName outputFileName)
)
)

Los scripts los he de guardar en la carpeta de scripts del GIMP: ~/.gimp-2.6/scripts. Para ejecutarlo puedo invocar al GIMP en modo comando (opción -b):

$ gimp -i -b «(example-script \\»confirmacion.jpg\\» \\»confirmacion_out.jpg\\»)» -b «(gimp-quit 0)»
batch command executed successfully

Pero todavía no me convence esta manera de hacer. Yo lo que quiero es poder aplicar un plugin a una imagen abierta del GIMP, ejecutando el plugin desde la consola, no desde dentro del GIMP. I la clave está en saber que el GIMP tiene un servidor, el servidor Script-Fu, que trabaja por defecte por el puerto 10008 i que escucha las peticiones TCP que le llegan de la red (socket). Primero de todo hemos de arrancar el servidor:

Filtres > Script-Fu > Inicia el servidor

y efectivamente puedo conectarme al servidor:

$ telnet localhost 10008

pero esto no sirve de nada si no sé el protocolo para comunicarme con este servidor. Este protocolo está explicado en este enlace:

no es un protocolo difícil de entender o implementar. Por suerte, en Google encontramos el script servertest.py que implementa este protocolo. Por ejemplo lo podemos encontrar en uno de estos enlaces:

Ahora ya puedo ejecutar mi plugin desde la consola:

$ python servertest.py
Trying ::1.
Trying 127.0.0.1.
Script-Fu-Remote – Testclient
> (plug-in-myblur RUN-NONINTERACTIVE 1 2)
(OK): Success
>

servertest.py trabaja de forma interactiva. No me convence. Hago una modificación de manera que pueda trabajar de forma totalment desatendida: script servertest_v2.py (http://wiki.joanillo.org/index.php/Programaci%C3%B3_GIMP#Servidor_Script-Fu)

$ python servertest_v2.py localhost 10008 «(plug-in-myblur RUN-NONINTERACTIVE 1 2)»
HOST: localhost
PORT: 10008
COMMAND: (plug-in-myblur RUN-NONINTERACTIVE 1 2)
Trying ::1.
Trying 127.0.0.1.
(plug-in-myblur RUN-NONINTERACTIVE 1 2)
(OK): Success

Es decir, ejecuto el anterior comando desde la consola, y de forma mágica la imagen que tengo abierta en el GIMP queda difuminada.

Ahora sólo falta ejecutar esta comando no desde la consola, sino desde un ejecutable de C, que es mi lenguaje de referencia para desarrollar futuros proyectos:

// gcc -o execute_blur execute_blur.c
int main(int argc, char *argv[])
{
\tsystem(«python servertest_v2.py localhost 10008 \\»(plug-in-myblur RUN-NONINTERACTIVE 1 2)\\»»);
}

$ ./execute_blur

HOST: localhost
PORT: 10008
COMMAND: (plug-in-myblur RUN-NONINTERACTIVE 1 2)
Trying ::1.
Trying 127.0.0.1.
(plug-in-myblur RUN-NONINTERACTIVE 1 2)
(OK): Success

y la imagen que tengo abierta en el GIMP queda difuminada.

Interficie Wii Rockband drumset

El otro día compré en el Cash Converter, por 18e, una batería Wii de segunda mano, con la idea de hacerla sonar en mi Ubuntu. Estas baterías salieron al mercado en 2007, hace ya cinco años. Evidentemente hay gente que ha llevado estas consolas al entorno Linux, y me he beneficiado del código que he encontrado por aquí y por allá. Sin embargo, el codi que he encontrado no era para mi modelo (también existen versiones para PS2, PS3 y X360), así que he tenido que averiguar los códigos que envía el drumset (con la dificultad que cuando tocas las dos baquetas a la vez, o las dos baquetas y el bombo, se envían otros códigos). No tenía experiencia previa en la programación de la librería libusb. Utilizando esta librería ha estado la única forma posible de detectar la fuerza con que golpeo la baqueta, y por tanto hacer un poco de control de volumen, aunque con poca resolución.

Para hacer sonar la batería se necesita generar mensajes MIDI y enviarlos a un sintetizador. He utilizado Hydrogen como sintetizador de sonidos de batería. He programado cuatro presets diferentes que se acceden con los botones de la consola (los típicos botones 1, 2, A y B de la Wii). Se han hecho dos versiones del código, una que utiliza ALSA de forma nativa, y otra para el servidor de audio JACK. Puedes descargarte el código del proyecto:
jrbdrum project

Stop motion: puzzle de 1000 piezas

Només hi ha una època en la vida on fer puzzles és interessant: quan ets nen. Com el Pere, que disfruta fent el puzzle de pirates de 40 peces. Quan ets adult fer puzzles és una autèntica pèdua de temps. Dit això, jo tenia l’espina clavada doncs en el seu dia no vaig poder acabar un puzzle que corria per casa de 750 peces. M’ho devia. Així que un dia que vaig entrar al Cash&Converter vaig agafar un puzzle per 5 euros (no vaig poder triar la foto, però m’era ben bé igual), i em vaig posar a fer el puzzle a estones, igual que un nen.

Stop motion. Quantes fotos s’han de fer a mida que desmunto el puzzle? Quantes peces trec entre foto i foto? Anem a fer el petit càlcul. Si el puzzle és de 1000 peces i trec dues peces entre foto i foto són 500 fotos, que seran 500 frames del video. Si vull muntar un video a 20 fps (20 frames cada segon), sortirà un vídeo de 500f/20fps = 25 segons.

Amb un script es pot muntar el video. Primer de tot es renombren les fotos de manera que la primera passi a ser la última, i la última la primera. De manera que la última és la foto que es diu 99999.JPG. Després es tornen a renombrar de manera que la primera passi a ser la 00000.JPG, etc. I seguidament es munta el video concatenant totes les fotos. Finalment, amb l’editor de video Open Shot es posa la portada, la contraportada, la música i es fan les foses.

#!/bin/bash
#rename files in reverse
START=99999 #allows for an hour of jpegs
i=$START
for f in *.JPG
do
mv $f $i.JPG
i=$(($i -1))
echo $i
done

c=0;
for i in *.JPG;
do mv «$i» «`printf %05d $c`.JPG»;
c=$((c+1));
done

ffmpeg -r 20 -sameq -i %05d.JPG output.mp4

El resultat final: