REPORTERO CIUDADANO

CLIC AQUI PARA DESCARGAR LAS PANTALLAS

AIR GUITAR PD: Códigos fuente

Para la realización de AIR GUITAR PD, un proyecto que simula una guitarra aérea con sonido, se programó comunicación UDP en localHost entre los programas processing y pureData, aprovechando las ventajas de los mensajes OSC, se hizo un tracking de tres colores en processing, y las variables de posición de estos track fueron enviadas a pureData, en donde modifican una serie de parámetros que crean distintas melodías y tonos. El proyecto de PD puede descargarlo haciendo clic en este enlace.

A continuación, la parte correspondiente al código programado en processing:

/*tracking de color creado originalmente por Golan Levin

modificado en primera instancia por Allesandro Valli para mejorar captura

modificafo por Enrique Copete para que pueda capturar más de un color a la vez

Tracking de Color para capturar tres colores, para el proyecto Air GuitarPD

JUAN MANUEL ANDRADE 2011

captura tres colores diferentes desde la camara, toma sus posiciones y evalúa su

presencia, estos datos son enviados a PureData a através de las librerías

oscP5 y netP5

*/

import processing.video.*;

import oscP5.*;

import netP5.*;

color black = color(0);

color white = color(255);

//HSB del primer color 1 rojo

float t1 = 320; //hue

float t2 = 44; //saturation

float t3 = 98; //brightness

//HSB del segundo color 2 naranja/verde

float tt1 = 135; //hue

float tt2 = 39; //saturation

float tt3 = 79; //brightness

//HSB del tercer color 3 azul/naranja

///***********************

float ttt1 = 219; //hue

float ttt2 = 58; //saturation

float ttt3 = 96; //brightness

///***********************

float w1=10; //10 cual es mas importante de los representantes de arriba( hue, saturation, brightness)

float w2=10;

float w3=10;

//variables del reconocimiento de color rojo,

//las que se usan para determinar la escala y el nivel del wah wah

int posX;

int posY;

//variables de la posición horizontal de cada identificador

//para saber si está ausente o no

//la posicion del segundo es la misma posX

int posUno;

int posTres;

//variable que se enviara a PD, dependiendo de la presencia de los colores

int melodia;

boolean tag1;

boolean tag2;

boolean tag3;

float radius = 80;

float colorUno (float c1, float c2, float c3) //sacando la distancia del color 1

{

return sqrt(w1*pow(c1-t1,2)+w2*pow(c2-t2,2)+w3*pow(c3-t3,2));

}

float colorDos (float c1, float c2, float c3) //sacando la distancia del color 2

{

return sqrt(w1*pow(c1-tt1,2)+w2*pow(c2-tt2,2)+w3*pow(c3-tt3,2));

}

///***********************

float colorTres (float c1, float c2, float c3) //sacando la distancia del color 3

{

return sqrt(w1*pow(c1-ttt1,2)+w2*pow(c2-ttt2,2)+w3*pow(c3-ttt3,2));

}

///***********************

//variables globales

int numPixels;

Capture video;

OscP5 oscP5;

NetAddress conexion;

////////////////////////////////////////////////////////////////////////////////////////

void setup() {

size(320, 240,P2D);

oscP5 = new OscP5(this, 5000);

//creación del puerto para enviar mensajes

conexion = new NetAddress("localHost", 5001);

colorMode(HSB, 360, 100, 100);

strokeWeight(5);

// Uses the default video input, see the reference if this causes an error

video = new Capture(this, width, height, 30);

numPixels = video.width * video.height;

smooth();

noStroke ();

}

///////////////////////////////////////////////////////////////////////////////

void draw() {

if (video.available()) {

video.read();

image (video, 0, 0);

video.loadPixels();

//si se desea hacer track de menos de tres, alguno de estos se puede deshabilitar

//color 1

track (0);

//color 2

track (1);

///***********************

//color 3

track (2);

///***********************

video.updatePixels ();

//no es necesario que se vea el video, aunque se se desea:

// image (video, 0, 0);

}

}

//método que divide el track en los 3 colores, referenciados arriba

void track (int cualColor) {

float sumx=0;

float sumy=0;

float sumn=0;

float colorr = 0;

for (int y = 0; y <>

for (int x = 0; x <>

int i = x+y*width;

//track de cada uno de los colores

switch (cualColor) {

//color 1

case 0:

colorr = colorUno (hue(video.pixels[i]),saturation(video.pixels[i]),brightness(video.pixels[i]));

break;

//color 2

case 1:

colorr = colorDos (hue(video.pixels[i]),saturation(video.pixels[i]),brightness(video.pixels[i]));

break;

///***********************

//color 3

case 2:

colorr = colorTres (hue(video.pixels[i]),saturation(video.pixels[i]),brightness(video.pixels[i]));

///***********************

}

if (colorr

sumx+=x;

sumy+=y;

sumn+=1.0;

}

} //cierra el for de x

}

if(sumn>0)

{

//tracking para cada color

//para cada caso se comparten las variables de cálculo

//pero cada una captura un color diferente

int tracking_x = (int)(sumx/sumn);

int tracking_y = (int)(sumy/sumn);

colorMode (RGB, 255, 255, 255);

switch (cualColor) {

//color 1

case 0:

fill (255, 0, 0);

ellipse (tracking_x, tracking_y,10,10);

posUno = tracking_x;

break;

//color 2

case 1:

fill (0,255,0);

ellipse (tracking_x, tracking_y,10,10);

posX = tracking_x;

posY = tracking_y;

///***********************

//color 3

case 2:

fill (0,0,255);

ellipse (tracking_x, tracking_y,10, 10);

posTres = tracking_x;

///***********************

break;

}

colorMode(HSB, 360, 100, 100);

//valores a enviar

}

sendM();

//println("posicion en X "+posX);

}

//método para determinar qué valor enviar a PD, de acuerdo

//a la asusencia o presencia de los colores

void notas(){

if(posUno == 0){

melodia = 1;

}

if(posX == 0){

melodia = 2;

}

if(posTres == 0){

melodia = 3;

}

if(posUno == 0 && posX == 0){

melodia = 4;

}

if(posUno == 0 && posTres == 0){

melodia = 5;

}

if(posX == 0 && posTres == 0){

melodia = 6;

}

if(posX == 0 && posUno == 0 && posTres == 0){

melodia = 7;

}

if(posX != 0 && posUno != 0 && posTres != 0){

melodia = 8;

}

}

//método para enviar los mensajes a PureData

void sendM(){

notas();

//crear un nuevo mensaje Osc con un identificador

OscMessage mensaje1 = new OscMessage("/posX");

//adicionar valores enteros al mensaje

mensaje1.add((int)posX);

mensaje1.add((int)posY);

mensaje1.add((int)melodia);

//enviarlo a una direccion remota

oscP5.send(mensaje1, conexion);

//println("enviando "+posUno);

}

MODELO CONCEPTUAL: AIR GUITAR PD

INTERACCIÓN HOMBRE COMPUTADOR 2

PRIMERO PROYECTO INDIVIDUAL

PD AIR GUITAR

Juan Manuel Andrade / 06212064

PRIMERA PRE ENTREGA

En ésta pre entrega:

MODELO CONCEPTUAL

REQUERIMIENTOS

MAPPING

MODELO CONCEPTUAL AIR GUITAR PD

Aplicación interactiva que permite al usuario crear y manipular sonidos con los dedos de una mano, realizando movimientos en el aire, como si se tratase de una guitarra real. Aprovechar la metáfora de la guitarra aérea, que es usada comúnmente cuando se escucha una canción o se quiere simular la creación de sonido pro medio de las manos en el aire. El usuario podrá conocer los cambios que afectan el sonido, conforme mueve los dedos, así como conocer cuáles son los dedos que en determinado momento realizan dichos cambios, y obtener un control global del sonido que está creando. Estas características hacen que los usuarios puedan ir camino al virtuosismo, perfeccionando la forma en que manipulan la música por medio de sus dedos.

El sistema debe ser fácil de aprender, permitiendo al usuario realizar micro variaciones en el sonido conforme va usando la aplicación. La aplicación debe recoger la información que el usuario suministra por medio de sus dedos, y debe encargue también de traducirla en variaciones de sonido.

La aplicación debe permitir al usuario un manejo consistente con el instrumento que se está emulando tocar dentro de la experiencia. Debe permitir además variaciones medias en los diferentes sonidos que pueda emitir, y debe contener una variación estructural en su uso e implementación.

REQUERIMIENTOS AIR GUITAR PD

REQUERIMIENTOS FUNCIONALES

El sistema permitirá al usuario manipular sonidos por medio del movimiento de sus dedos.

El sistema permitirá diferentes formas de alterar la onda de sonido, conforme los movimientos de los dedos. Mientras unos alterarán prolongación, otros frecuencia o tono.

El usuario podrá determinar, antes de comenzar la interacción, el nivel o rango de sonidos que quiere manipular, o hasta el cual quiere llegar.

El sistema proporcionará retroalimentación visual al usuario de los que está haciendo con el movimiento de sus dedos.

El sistema medirá la presencia o ausencia de determinados códigos de colores en la información que recoja del usuario. Esta ausencia o presencia determinará la manipulación del sonido.

El sistema transformará los datos que entregue el usuario por medio del sensor en sonido. Diferentes movimientos determinarán diferentes formas de alterar la onda de sonido.

La prolongación de un sonido, el tono, la reverberación, y el nivel de envolvente, serán las variables que el usuario podrá manipular en el sonido que emita.

El sistema permitirá al usuario emitir sonidos por medio del movimiento de sus manos, y aplicarles las diferentes modificaciones en tiempo real, conforme mueve sus dedos.

Nombre	Tipo	Tamaño	Persistencia	Editable	Obligatorio	Ejemplo
Tag de color R	Booleano		no	Sí	Sí	True = visible
						False = No visible
Tag de color G	Booleano		no	Sí	Sí	True = visible
						False = No visible
Tag de color B	Booleano		no	Sí	Sí	True = visible
						False = No visible
Velocidad	Numérico	máximo 10	no	Sí	Sí	0 - 10
Posicion tag color en X R	Numérico	máximo 320	no	sí	sí	0 - 320
Posicion tag color en Y R	Numérico	máximo 240	no	sí	sí	0 - 240
Posicion tag color en X G	Numérico	máximo 320	no	sí	sí	0 - 320
Posicion tag color en Y G	Numérico	máximo 240	no	sí	sí	0 - 240
Posicion tag color en X B	Numérico	máximo 240	no	sí	sí	0 - 320
Posicion tag color en Y B	Numérico	máximo 240	no	sí	sí	0 - 240
Número de Tag visibles	Numérico	máximo 3	no	no	sí	0 - 3

La tabla anterior muestra los REQUERIMIENTOS DE DATOS

REQUERIMIENTOS DE CONTEXTO

Contexto físico

Preferiblemente, la aplicación debe utilizarse en espacios con iluminación plana, en donde un foco de luz muy intenso no interfiera la recopilación de datos[1].

Requiere de un espacio no muy cerrado, en el que el usuario pueda mover sus manos sin elementos en la habitación en donde se utilice la aplicación.

Preferiblemente el espacio en el que se utiliza la aplicación no debe ser interferido por movimientos ajenos al de las manos con los códigos de colores, de la persona que manipula los sonidos.

Contexto social

La aplicación no requiere más de un jugador, la misma persona que manipula los sonidos con el movimiento de sus dedos es la encargada de determinar los niveles que desea utilizar previamente.

La aplicación recogerá directamente los datos del usuario, no se requieren intermediarios entre el usuario y los sensores.

Contexto técnico

La aplicación funcionará en un computador con cualquier sistema operativo, capaz de recoger información a través de una cámara de video y procesarla correctamente

Se recomienda contar con mínimo 1GB de RAM para la correcta ejecución de la aplicación

La aplicación requiere comunicarse desde una cámara web convencional hasta el programa Processing para hacer el tracking de color.

La información recogida por el tracking de color será enviada a pure data para el procesamiento de onda de sonido.

El juego requiere una cámara web convencional y se recomiendan altavoces para que los audífonos no interfieran en el movimiento del usuario.

REQUERIMIENTOS DE USUARIO

Se recomienda sea utilizado por usuarios mayores de 10 años.

No es necesaria la formación en música o haber interpretado música con una guitarra real con anterioridad

Se recomienda no ser utilizada por personas con problemas de túnel carpiano en cualquiera de sus manos.

El usuario no debe conocer ampliamente pure data para la elección del rango inicial, ni tampoco de Processing, basta con ejecutar el programa.

El computador en el que se ejecuta el programa debe tener preinstalado el plugin que permite a Processing comunicarse con la cámara web conectada.

REQUERIMIENTOS DE USABILIDAD

El sistema tendrá pasos obligatorios: ejecutar ambas plataformas de programación, escoger el rango de sonidos deseado, y comenzar a manipular el sonido con los dedos frente a la cámara.

La aplicación mostrará lo que está recogiendo por medio de la cámara, para guiar al usuario en caso de que no esté realizando los movimientos correctamente, o la información no se esté recogiendo de forma satisfactoria.

Un usuario puede pasar desde pocos segundos hasta una buena cantidad de tiempo en la aplicación.

La fase de elección de niveles no debería tardar más de 30 segundos en ejecutarse.

Se espera que la mayoría de los usuarios conozcan la metáfora de la guitarra aérea para la ejecución del juego.

Mientras se ejecuta la aplicación se puede cambiar los niveles que se programaron inicialmente.

MAPPING AIR GUITAR PD

Las variables que recoja la cámara, a través del movimiento de los dedos y posición de la mano el usuario, serán las variables humanas, que deberán ser procesadas correctamente para que la manipulación del sonido sea correcta. Para este proyecto, se plantea el siguiente Mapping.

Variable humana: Movimiento de los dedos.

Ésta es la variable más complicada de manejar, pues contempla varias características, que serán empleadas para la ejecución de la aplicación. En primer lugar, los tags de colores estarán ubicados en la parte externa de los dedos, específicamente en la articulación que une la segunda y la tercera falange de los dedos índice, anular y corazón.

El usuario simulará tocar una guitarra, por lo que dispondrá su mano izquierda como si se tratase de sujetar el mástil. Al cerrar completamente su mano, la cámara no captará ningún tag de color, y al mover sus dedos, acercándolos y alejándolos de su muñeca, la cámara captará el número de tags disponibles y su código de color.

La ausencia o presencia de determinado tag será interpretada por Processing como un valor booleano. Si dos booleanos de determinado color están presentes a la vez, se enviará un dato numérico a pure data, indicando que se realice la modificación en el sonido predeterminada para este grupo de tags.

Si los tres tags están disponibles a la vez, el sonido que se generará será el más fuerte, la ausencia de los tres tags al tiempo indicará silencio. Cada aparición de nuevo de determinado tag significará una nueva nota, este valor booleano será enviado desde Processing a pure data, en donde activará un bang, que será el encargado de crear una nueva nota.

Variable humana: posición de la mano

La mano llevará consigo los tres códigos de colores que se emplearán para el manejo de la aplicación. En la metáfora de la guitarra aérea, los usuarios, además de simular punteos con su mano izquierda, también imitan los arpegios y diferentes notas, subiendo y bajando en el mástil. Aprovechando estas variables, la aplicación subirá o disminuirá el tono de los sonidos que se producen evaluando la posición en X de los tags de color en la pantalla. Asimismo, la altura en la que se encuentren los tags captados por la pantalla (posición en Y) determinará la intersección de las notas (que el cambio de nota de acuerdo al movimiento de los dedos sea abrupto o por el contrario se entremezclen conforme se cambia).

Estas variables serán manejables únicamente con la presencia de los tres tags en la aplicación. Cuando los tags se encuentren en el extremo de origen de la pantalla (lado izquierdo) se interpretará la nota más grave, conforme vaya avanzando en el eje horizontal, las notas se volverán más agudas. De la misma forma, si la mano se encuentra en el punto más alto de la pantalla en el origen, las notas se entremezclarán y en el punto más bajo habrá un cambio repentino cada vez que se agregue una nueva.

La posición que recoja Processing en pantalla, será interpretada en Pure Data manipulando un par de sliders horizontal y verticalmente, cada uno de ellos encargado de aumentar o disminuir el tono de la nota o de determinar el nivel de entre mezcla entre las notas.

Estas características serán aprovechadas, pues la oscilación rápida del movimiento vertical, dará el efecto que da un pedal wah wah en la distorsión de las notas de una guitarra eléctrica.

---

[1] Aunque la recopilación de datos por parte del sensor fotográfico, contempla únicamente el reconocimiento de códigos de color específicos, muchas veces un buen tracking puede verse alterado pro un foco de luz directa que tenga una intensidad muy fuerte. En los planteamientos de éste ejercicio se garantiza la correcta programación del reconocimiento de tags de colores.