Archivo de la etiqueta: jitter

Diseño videográfico Interactivo: (50h)

En nuestro curso Diseño Videográfico Interactivo con Max/Jitter nuestros alumnos aprenden todo lo necesario para empezar a desarrollar gráfico interactivo, por medio de la programación orientada a objetos, base fundamental del Software en el que les instruimos.

¿ Qué cositas podemos hacer con Max/msp Jitter ?

Gráficos 3D que visualizan sonidos y datos para generar geometrías interactivas

Creación de tus propios mundos con luces, materiales y múltiples cámaras

Combinación de gráficos con efectos de imagen

Dar vida a nuestras geometrías con física

Diseñar de forma sencilla nuestros propios efectos de vídeo

Puedes usar los vizzie módulos para la creación rápida de instrumentos únicos de vídeo

Puedes transformar sonido en vídeo y viceversa con una matriz de Jitter

Puedes generar y animar visuales con herramientas gráficas generativas interactivas

Puedes trabajar con vídeo de alta calidad y muchas más cosas con tu vídeo a tiempo real

Puedes conectar sensores y componentes electrónicos para la realización de aplica-ciones basadas en la computación artificial y los medios interactivos

Puedes mezclar controladores MIDI, OSC o con cualquier Hardware personalizado

Indice de Contenidos:
Introducción Curso Diseño video – gráfico
-Referentes
-Tendencias
Otras herramientas de generación gráfica
-Processing, vvvv, OpenFrameworks
Introducción a Max – Jitter
Generación de gráficos en tiempo real con Jitter Interacción video-gráfica
Comunicación :
Protocolos DMX para control de iluminación interactiva -Enttec
-Work

Art Net

OSC

Warping y Mapping, el proyector y la multiproyección

 -Definición
 -Referentes
 -Tipologías de videomapping: interior y exterior
 -Aplicaciones del videomapping
 -Explicación del Software y Hardware
 -Necesidades técnicas/hardware (proyectores, sensores, etc)

-Programas para creación de contenido (AfterEffects, Cinema 4D) -Programas de videodirecto (VDMX, Resolume Arena)
-Programas de mappeo (Madmapper, IR Mapio)
-Syphon, Quartzcomposer, Soundflower y otros programas puente

* Ejercicio práctico de los alumnos sobre el manejo del software. En casa preparar material para una estructura y proyecto que se hará a la semana siguiente.

Proyecto de videomapping
-Realizar un proyecto de videomapping
-Medición de la estructura
-Distribución de las superficies de proyección
-Configuración del software de videodirecto
-Configuración de MIDI para manejo del programa
-Introducción de sensores de sonido, movimiento, etc
-Puesta en marcha del proyecto

Anuncios

codeFolkers () { presentación en cocorocó

El pasado Jueves 21 de Mayo, nuestros amigos de cocorocó en Granada, nos dieron la oportunidad de presentarnos como plataforma abierta, mostrar los cursos para adultos que empezamos a impartir en abril en su espacio y ya de paso, tomarnos unas cervezas mientras explicábamos a la gente las técnicas con las que trabajamos, a través de distintas muestras de dispositivos básicos.

522536_350773291697878_1338452338_n

420358_350773251697882_1895930607_n

268072_350773301697877_1286135466_n

313441_350773355031205_1868740700_n

Nuestro agradecimiento a todos los asistentes y en especial a Marcelo y Ángel Miguel Cebrián por las fotos. Larga vidaaaaaa!!! 🙂

313746_350773368364537_776242478_n

empanada de bits 1.0

Con motivo de la convocatoria al LPM (Live Performers meeting) de Roma del 2011 nos propusimos idear una aplicación interactiva visual y sonora, otra vez con Kinect Sensor y Max/msp- jitter pero esta vez pensada para realizar “liveCode”, si si, programación a tiempo real. Indispensable gente con ganas de sudar delante de la cámara :). La empanada de bits detecta los movimientos de la persona situada frente al rango del sensor y produce sonidos a través del cuerpo.La empanada de bits 1.0 se dejó pasar por InusualProject en Barcelona en Junio del 2011.

emanadabits1empanadabits3 

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();
}