Archivo de la etiqueta: processing

Electrónica creativa con Arduino y Processing (40h)

Así comenzamos nuestra andadura como docentes para la Escuela de formación Cultural de Andalucía en su departamento de Estudios Escénicos. Un espacio único, en el que durante un mes, con horario intensivo de tardes, nuestras docentes Marta Verde a la programación con Processing y Pilu Caballero en electrónica, arquitectura de sensores y micro-controladores y 14 alumnos han tenido la oportunidad de adentrarse en el mundo de la computación física e inteligencia artificial, mediante herramientas intuitivas, con mucha práctica y un entusiasmo más que demostrado. Las imágenes hablan por si solas:

1. Empezamos los básicos de programación con Processing, a la docencia Marta Verde :

558659_10151911942689218_788209726_n

2. Tuvimos la gran suerte de contar con una clase magistral sobre la construcción de Hologramas, tanto como para la realización de branding como para su posible construcción escenográfica, con el experto, Alvaro Gálvez de Aluzinarte Audiovisuales.

2013-10-08 15.57.57

3. A continuación pasamos por el aprendizaje del proceso I+D+D en interacción:

1374965_10151926745799218_1287079810_n

Interacción analógica básica y otros procesos de Investigación, diseño y desarrollo :

1382967_10151926746774218_132033787_n 1382125_10151926745464218_1448701553_n 1238223_10151941672524218_2142237225_n

1380203_10151941674874218_1508024232_n 537268_10151941674439218_1873588640_n 1385832_10151926746239218_1693175164_n 1374297_10151926746004218_1440469488_n

 

Desde aquí nuestro especial agradecimiento por vuestra atención, ganas y entusiasmo. Gracias a todos por hacernos vivir una experiencia única e inolvidable.1385464_10151941676974218_1798503955_n

Anuncios

Sobre las aguas

Hablando un día en L ´estruch sobre una idea que trataba sobre la lluvía se nos ocurrió experimentar con el sensor Kinect recién hackeado, Kinect Core Vision ( desarrollada entonces por el amable Patricio González Vivo http://www.patriciogonzalezvivo.com/blog/?p=364 ), TUIO y Processing. Muy divertido y relajante 😉 logramos este suelo interactivo.

Los primeros pasos de este experimento estuvieron en probar las comunicaciones serial entre OpenNi, TUIO y Jitter.

Después pasamos a experimentar con la App de Patricio que la podeis descargar en GitHub (https://github.com/patriciogonzalezvivo/KinectCoreVision).

kinectcore1kinectcoreProcessing Sketch

 
import TUIO.*;
TuioProcessing tuioClient;

// these are some helper variables which are used
// to create scalable graphical feedback
float cursor_size = 15;
float object_size = 60;
float table_size = 760;
float scale_factor = 1;
PFont font;

void setup()
{
//size(screen.width,screen.height);
size(640,480);
noStroke();
fill(0);

loop();
frameRate(30);
//noLoop();

hint(ENABLE_NATIVE_FONTS);
font = createFont(“Arial”, 18);
scale_factor = height/table_size;

// we create an instance of the TuioProcessing client
// since we add “this” class as an argument the TuioProcessing class expects
// an implementation of the TUIO callback methods (see below)
tuioClient = new TuioProcessing(this);
}

// within the draw method we retrieve a Vector (List) of TuioObject and TuioCursor (polling)
// from the TuioProcessing client and then loop over both lists to draw the graphical feedback.
void draw()
{
background(255);
textFont(font,18*scale_factor);
float obj_size = object_size*scale_factor;
float cur_size = cursor_size*scale_factor;

Vector tuioObjectList = tuioClient.getTuioObjects();
for (int i=0;i<tuioObjectList.size();i++) {
TuioObject tobj = (TuioObject)tuioObjectList.elementAt(i);
stroke(0);
fill(0);
pushMatrix();
translate(tobj.getScreenX(width),tobj.getScreenY(height));
rotate(tobj.getAngle());
rect(-obj_size/2,-obj_size/2,obj_size,obj_size);
popMatrix();
fill(255);
text(“”+tobj.getSymbolID(), tobj.getScreenX(width), tobj.getScreenY(height));
}

Vector tuioCursorList = tuioClient.getTuioCursors();
for (int i=0;i<tuioCursorList.size();i++) {
TuioCursor tcur = (TuioCursor)tuioCursorList.elementAt(i);
Vector pointList = tcur.getPath();

if (pointList.size()>0) {
stroke(0,0,255);
TuioPoint start_point = (TuioPoint)pointList.firstElement();;
for (int j=0;j<pointList.size();j++) {
TuioPoint end_point = (TuioPoint)pointList.elementAt(j);
line(start_point.getScreenX(width),start_point.getScreenY(height),end_point.getScreenX(width),end_point.getScreenY(height));
start_point = end_point;
}

stroke(192,192,192);
fill(192,192,192);
ellipse( tcur.getScreenX(width), tcur.getScreenY(height),cur_size,cur_size);
fill(0);
text(“”+ tcur.getCursorID(), tcur.getScreenX(width)-5, tcur.getScreenY(height)+5);
}
}

}

// these callback methods are called whenever a TUIO event occurs

// called when an object is added to the scene
void addTuioObject(TuioObject tobj) {
println(“add object “+tobj.getSymbolID()+” (“+tobj.getSessionID()+”) “+tobj.getX()+” “+tobj.getY()+” “+tobj.getAngle());
}

// called when an object is removed from the scene
void removeTuioObject(TuioObject tobj) {
println(“remove object “+tobj.getSymbolID()+” (“+tobj.getSessionID()+”)”);
}

// called when an object is moved
void updateTuioObject (TuioObject tobj) {
println(“update object “+tobj.getSymbolID()+” (“+tobj.getSessionID()+”) “+tobj.getX()+” “+tobj.getY()+” “+tobj.getAngle()
+” “+tobj.getMotionSpeed()+” “+tobj.getRotationSpeed()+” “+tobj.getMotionAccel()+” “+tobj.getRotationAccel());
}

// called when a cursor is added to the scene
void addTuioCursor(TuioCursor tcur) {
println(“add cursor “+tcur.getCursorID()+” (“+tcur.getSessionID()+ “) ” +tcur.getX()+” “+tcur.getY());
}

// called when a cursor is moved
void updateTuioCursor (TuioCursor tcur) {
println(“update cursor “+tcur.getCursorID()+” (“+tcur.getSessionID()+ “) ” +tcur.getX()+” “+tcur.getY()
+” “+tcur.getMotionSpeed()+” “+tcur.getMotionAccel());
}

// called when a cursor is removed from the scene
void removeTuioCursor(TuioCursor tcur) {
println(“remove cursor “+tcur.getCursorID()+” (“+tcur.getSessionID()+”)”);
}

// called after each message bundle
// representing the end of an image frame
void refresh(TuioTime bundleTime) {
redraw();
}

Búrbujas

bombolles1

Dispositivo de Interacción visual, sonora y lumínico. Con IR sensor LED, Max/ msp y Processing, comunicación serial vía OSC.

*Análisis de Audio:
con Max/MSP/Jitter detectamos la frecuencia, duración y volumen de cada nota que sale de la trompeta, pasamos esta información por OSC (Open Sound Control) a Processing que dibuja las burbujas según estos mismos parámetros (frecuencia/color, duración/tamaño volumen/ transpa-rencia)
. Max object: Pitch~ de Tristan Jehan
. Processing: librería Física de Ricard Marxer

*Captura de Movimiento:
con la visión infrarroja de la Kinect y un punto reflectante a la salida de la campana de la trompeta, visualizamos y seguimos por toda la escena el punto desde donde saldrán las burbujas.
. Max objects: CV.jit de Jean-Marc Pelletier

** Mencionado en Kinect Hacks Network:

http://www.dashhacks.com/kinect/kinect-hacks/max/msp/jitter-audio-bubbles-with-kinect-motion-tracking.html

kinecthacks.com/kinect-and-musical-bubbles-bombolles/

Lo que más nos gustó del desarrollo de este proyecto es que vivimos y participamos de todo el furor Kinect Xbox allá cuando salió a finales de 2010. Las noticias de que ladyAda ofrecía 3000 dólares a quien hackeara este periférico, nos hacían estar pendientes en todo momento de la apertura de dicho sistema. Un orgullo además para todos los españoles de la comunidad, ver que era logrado por un español Hector Martín en 7h con solo 20 añitos. http://www.elmundo.es/blogs/elmundo/mundoplayer/2010/11/11/un-espanol-el-primero-en-hackear-kinect.html ).

Fotos procesos

bombollesprocessbombollesprocss

Captura de pantalla 2011-03-09 a las 11.23.21Captura de pantalla 2011-03-07 a las 13.07.35Captura de pantalla 2011-03-10 a las 17.51.44

Curso de Programación creativa con Processing

processing

El uso de ordenadores para fines creativos empezó con la aparición de las primeras computadoras de propósito general, hacia la década de 1950-60.

El desarrollo de la electrónica y de las tecnologías digitales propició, a lo largo del siglo pasado, la evolución de las disciplinas artísticas ya existentes, gracias a las nuevas herramientas disponibles, como por ejemplo, la música con la síntesis de nuevos sonidos y las herramientas de composición y producción.

Y por otro lado, las nuevas formas de creación han dado lugar a nuevas disciplinas , como el net-art, el software art, o la evolución del arte conceptual y generativo hacia formas de expresión más computacionales.

En la actualidad es imprescindible para un artista el conocimiento de la programación que, si bien no desemboca necesariamente en todos los casos en el uso de esta de forma creativa como (única) herramienta, sí permite comprender los mecanismos y técnicas de un artefacto, el ordenador, que pocos pueden dejar de utilizar en una forma u otra. El conocimiento de estas técnicas es enriquecedor en sí mismo, más allá del uso que de ellas se haga.

DIRIGIDO A

Todos aquellos artistas gráficos, diseñadores, programadores, curiosos, performers y todo aquel interesado en conocer nuevas herramientas de gene-ración gráfica e interacción, así como todo aquel que sin tener conocimientos previos de programación deseen adentrarse en este mundo.

Generative graphics

OBJETIVOS

Asumir conocimientos para el uso de la herramienta de generación gráfica Processing.

Introducción a los primeros conceptos de programación y asentamiento de los adquiridos de forma fácil y rápida.

Adquirir una base para poder profundizar en la creación visual o gráfica generativa.

Instruir en la búsqueda de recursos on-line.

Perder el miedo a la programación.

Lograr objetivos prácticos a corto plazo.

METODOLOGÍA

Las primeras sesiones se dedican a situar la programación creativa en los contextos artístico y tecnológico actuales y a la introducción de las técnicas básicas de programación con Processing.

Las siguientes sesiones se centran en el aprendizaje y aplicación técnicas mediante ejemplos y casos prácticos, entender los ejemplos que después se utilizarán como punto de partida para desarrollar un pequeño proyecto creativo.

Los ejemplos harán énfasis en las técnicas que distinguen la programación de otras herramientas:

animación, simulación, uso del azar, tratamiento computacional del color…

Para finalizar cada alumno trabajará asesorado en todo momento para realizar un proyecto final individual o en grupo.

NECESIDADES TÉCNICAS

1 Ordenador por alumno

Instalación Software Libre Processing

1 Proyector para explicaciones del docent