Click for my Processing source code with all its kludges and betaness.

I have divided the code in three files:

lightTable.pde  -  containing setup(), draw(), midi control and some general routines
fixture.pde – containing the class with my virtual fixture
dmx.pde – containing the  failed dmx receiving routines (some of which are still needed for the program to run)

lightTable.pde

import com.juanjo.openDmx.*;

import rwmidi.*;
MidiInput input;

Minim minim;
import ddf.minim.*;
AudioInput audioInn;

int nImg=1;
PImage[] img= new PImage[nImg];
int testDmxChannel=4;

  int shapeX;
  int shapeY;

ArrayList fixtures;
int dmx[] = new int[512];
boolean connected;
color[] palette= new color[16];

void setup() {
  img[0]=loadImage("gobo1.png");
  size(800, 600, P2D);
  frameRate(30);
  noCursor();
  minim = new Minim(this);
  audioInn = minim.getLineIn(Minim.STEREO, width);
  int ofs=16;
  dmx[0+ofs]=255; //int intensityOffs=0;
  dmx[1+ofs]=110; //int rotationOffs=1;
  dmx[2+ofs]=50; //int quantityOffs=2;
  dmx[3+ofs]=50; //int diameterOffs=3;
  dmx[4+ofs]=50; //int spreadOffs=4;
  dmx[5+ofs]=0; //int colorOffs=5;
  dmx[15+ofs]=2*10; //int effectOffs=15;

  dmx[15]=4*10;  

  palette[0]=color(255, 255, 255);
  palette[1]=color(255, 0, 0);
  palette[2]=color(0, 255, 0);
  palette[3]=color(0, 0, 255);
  palette[4]=color(255, 255, 0);
  palette[5]=color(255, 0, 255);
  palette[6]=color(0, 255, 255);
  palette[7]=color(255, 128, 128);
  palette[8]=color(128, 255, 128);
  palette[9]=color(128, 128, 255);
  palette[10]=color(255, 255, 128);
  palette[11]=color(255, 128, 255);
  palette[12]=color(128, 255, 255);
  palette[13]=color(255, 255, 255);
  palette[14]=color(255, 255, 255);
  palette[15]=color(255, 255, 255);
  connected=OpenDmx.connect(OpenDmx.OPENDMX_RX);
  if (!connected) {
    println("Open Dmx widget not detected!");
  }
  else {
    System.out.println("Open Dmx widget up running!");
  }

  // Create an empty ArrayList
  fixtures = new ArrayList();

  // Start by adding one element
  for (int i=0; i<nFixtures; i++) {
    fixtures.add(new Fixture(i*chPrFixture+dmxAdress));
    Fixture fixture = (Fixture) fixtures.get(i);
    fixture.initDott();
  }
  println(RWMidi.getInputDevices());
  input = RWMidi.getInputDevices()[8].createInput(this);  

  initDmxInfo();
  //initDmxStart();
  loadDmx();
}

void controllerChangeReceived(rwmidi.Controller cntrl){
 int cc=cntrl.getCC();
 int val=cntrl.getValue();
 //println("cc recieved:"+cc+":"+val);
 dmx[cc]=val*2;
}

void keyPressed() {
  if (key=='S') {
    saveDmx();
    println("DMX saved");
  }
  if (key=='r') {
    loadDmx();
    println("All DMX reset to last saved values");
  }
  if (key=='i') {
    initDmxStart();
  }
  if (key=='R') {
    for (int fn=0; fn<nFixtures; fn++) {
      for (int ch=0; ch<chPrFixture; ch++) {
        dmx[dmxAdress+chPrFixture*fn+ch]=int(random(256));
      }
      dmx[dmxAdress+chPrFixture*fn+15]=int(random(6)*10+10);
      dmx[dmxAdress+chPrFixture*fn]=255;
    }
  }
  if (keyCode==LEFT) {
    if (testDmxChannel>0) {
      testDmxChannel--;
      println(channelName[testDmxChannel] + ":" +dmx[testDmxChannel]);
    }
  }
  if (keyCode==RIGHT) {
    if (testDmxChannel<512) {
      testDmxChannel++;
      println(channelName[testDmxChannel] + ":" +dmx[testDmxChannel]);
    }
  }
  if (keyCode==UP) {
    if (dmx[testDmxChannel]<255) {
      dmx[testDmxChannel]++;
    }
  }
  if (keyCode==DOWN) {
    if (dmx[testDmxChannel]>0) {
      dmx[testDmxChannel]--;
    }
  }

}

void mousePressed() { //only for testing
}

void draw() {
  receiveDmx();
  printDmxInfo();
  background(0);

  for (int i = 0; i<nFixtures; i++) {
    Fixture fixture = (Fixture) fixtures.get(i);
    fixture.move();
  }
  //println(frameRate);
}

void imageOut(int n, int x, int y){
  pushMatrix();
  rotate(1);
  image(img[n],x-(img[n].width/2),y-(img[n].height/2));
  popMatrix();
}

void setChName(int i, String s){
  channelName[i]=channelName[i]+s;
}

int dmxOld[] = new int[512];
String channelName[] = new String[512];
void initDmxInfo() {
  for (int i=0; i<512; i++) {
    channelName[i]="Ch."+str(i+1)+" ";
  }
  for (int i=0; i<nFixtures; i++) {
    setChName(i*chPrFixture+dmxAdress+intensityOffs,"Intensity");
    setChName(i*chPrFixture+dmxAdress+speedOffs,"Speed");
    setChName(i*chPrFixture+dmxAdress+quantityOffs,"Quantity");
    setChName(i*chPrFixture+dmxAdress+diameterOffs,"Diameter");
    setChName(i*chPrFixture+dmxAdress+spreadOffs,"Spread");
    setChName(i*chPrFixture+dmxAdress+colorOffs,"Color");
    setChName(i*chPrFixture+dmxAdress+panOffs,"Pan");
    setChName(i*chPrFixture+dmxAdress+tiltOffs,"Tilt");
    setChName(i*chPrFixture+dmxAdress+effectOffs,"Effect");
  }
}

void printDmxInfo() {
  boolean change=false;
  for (int i=0; i<512; i++) {
    if (dmx[i]!=dmxOld[i]) {
      print(channelName[i]+':'+dmx[i]+"   ");
      change=true;
      dmxOld[i]=dmx[i];
    }
  }
  if (change) {
    println();
  }
}

color fade(color c, int fader) {
  return color(fader*red(c)/255, fader*green(c)/255, fader*blue(c)/255);
}

fixture.pde

int intensityOffs=0;
int speedOffs=1;
int panOffs=2;
int tiltOffs=3;
int spreadOffs=4;
int quantityOffs=5;
int diameterOffs=6;
int colorOffs=7;
int effectOffs=8;

int nFixtures=8;
int chPrFixture=12;
int dmxAdress=0;
int nEffects=8;

class Fixture {
  int dmxAddr;

  int intensity;
  float rotation;
  int quantity;
  int diametr;
  int spread;
  int speed;
  int colr;
  int pan;
  int tilt;
  int effect;

  Fixture(int da) {
    dmxAddr=da;
  }

  void move() {
    colr=dmx[dmxAddr+colorOffs]/8;
    pan=dmx[dmxAddr+panOffs]*width/255+shapeX;
    tilt=(255-dmx[dmxAddr+tiltOffs])*height/255+shapeY;
    intensity=dmx[dmxAddr+intensityOffs];

    effect=dmx[dmxAddr+effectOffs]*nEffects/255+1;
    if (effect==1) {gobo();}
    if (effect==2) {dott();}
    if (effect==3) {wall();}
    if (effect==4) {wave();}
    if (effect==5) {soundWave();}
    if (effect==6) {strobe();}
    if (effect==7) {shaper();}
    if (effect==8) {goboImage();}
  }

  ////////////////////////////////////////////////////////////////////////// GOBO EFFECT
  void gobo() {
    rotation=rotation+(128-dmx[dmxAddr+speedOffs])/800.0;
    quantity=dmx[dmxAddr+quantityOffs]/10;
    if (intensity>0)
      drawGobo();
  }

  void drawGobo() {
    diametr=dmx[dmxAddr+diameterOffs];
    spread=dmx[dmxAddr+spreadOffs];
    color c=fade(palette[colr%16], intensity);
    //  fill(c);
    if (colr>15) {fill(c);} else {noFill();}
    stroke(c);
    for (int i=0; i<quantity; i++) {
      int x=pan+int(spread*sin(i*2*PI/quantity+rotation));
      int y=tilt+int(spread*cos(i*2*PI/quantity+rotation));
      ellipse(x, y, diametr, diametr);
      ellipse(x+1, y, diametr, diametr);
      ellipse(x, y+1, diametr, diametr);
      ellipse(x+1, y+1, diametr, diametr);
    }
  }

  /////////////////////////////////////////////////////////////////////// DOTT EFFECT
  void dott(){
    quantity=dmx[dmxAddr+quantityOffs]/10;
    speed=dmx[dmxAddr+speedOffs];
    diametr=dmx[dmxAddr+diameterOffs];
    if (intensity>0) {drawDott();}
  }

  float dottX[]=new float[200];
  float dottY[]=new float[200];
  float dottXV[]=new float[200];
  float dottYV[]=new float[200];
  color dottC[]=new color[200];
  void initDott(){
    for (int i=0; i<199; i++){
      float a=random(2*PI);
      float v=100;
      dottX[i]=random(width);
      dottY[i]=random(height);
      dottXV[i]=v*sin(a);
      dottYV[i]=v*cos(a);
      dottC[i]=color(random(256),random(256),random(256));
    }
  }

  void drawDott(){
    for (int i=0; i<quantity; i++){
      color c=fade(palette[colr%16],intensity);
      if (colr>15) {fill(c);} else {noFill();}
      stroke(c);
      ellipse(dottX[i],dottY[i],diametr,diametr);
      ellipse(dottX[i]+1,dottY[i],diametr,diametr);
      ellipse(dottX[i],dottY[i]+1,diametr,diametr);
      ellipse(dottX[i]+1,dottY[i]+1,diametr,diametr);

      dottX[i]=dottX[i]+dottXV[i]*(128-speed)/600;
      dottY[i]=dottY[i]+dottYV[i]*(128-speed)/600;
      if (dottX[i]>width+diametr/2) {dottX[i]=dottX[i]-width-diametr/2;}
      if (dottX[i]<-diametr/2) {dottX[i]=dottX[i]+width+diametr/2;}
      if (dottY[i]>height+diametr/2) {dottY[i]=dottY[i]-height-diametr/2;}
      if (dottY[i]<-diametr/2) {dottY[i]=dottY[i]+height+diametr/2;}

    }

  }

  /////////////////////////////////////////////////////////////////////// WALL EFFECT
  void wall(){
    diametr=dmx[dmxAddr+diameterOffs]/10; // thickness of wall
    if (intensity>0) {drawWall();}
  }

  void drawWall(){
    color c=fade(palette[colr%16],intensity);
    fill(c);
    noStroke();
    if ((pan>5)&&(pan<width-5)) {rect(pan-diametr,0,diametr,height);}
    if ((tilt>5)&&(tilt<height-5)) {rect(0,tilt-diametr,width,diametr);}
  }

  /////////////////////////////////////////////////////////////////////// WAWE EFFECT
  float wavePhase;
  void wave(){
    spread=dmx[dmxAddr+spreadOffs]/2;
    diametr=dmx[dmxAddr+diameterOffs]; // thickness of wall
    wavePhase=wavePhase+0.002*(128-dmx[dmxAddr+speedOffs]);

    if (intensity>0) {drawWave();}
  }

  void drawWave(){
    color c=fade(palette[colr%16],intensity);
    noFill();
    stroke(c);
    if ((tilt>5)&&(tilt<height-5)) {
      for (int i=0; i<width; i++){
        float yy=spread*sin(i*2*PI*3/width+wavePhase);
        yy=yy+spread*0.5*sin(i*2*PI*4/width+wavePhase*sin(wavePhase*0.01));
        yy=yy+tilt;
        for (int j=0; j<3; j++) {
          point(i,yy+j);
        }
      }
    }
    if ((pan>5)&&(pan<width-5)) {
      for (int i=0; i<height; i++){
        float xx=spread*sin(i*2*PI*3/height+wavePhase);
        xx=xx+spread*0.5*sin(i*2*PI*4/height+wavePhase*sin(wavePhase*0.01));
        xx=xx+pan;
        for (int j=0; j<3; j++) {
          point(xx+j,i);
        }
      }
    }

  }

  /////////////////////////////////////////////////////////////////////// SOUNDWAVE EFFECT
  void soundWave(){
    spread=dmx[dmxAddr+spreadOffs]*2;
    diametr=dmx[dmxAddr+diameterOffs]; // thickness of wall

    if (intensity>0) {drawSoundWave();}
  }

  void drawSoundWave(){
    color c=fade(palette[colr%16],intensity);
    noFill();
    stroke(c);
    if (colr<16) {// Line wave
      if ((tilt>5)&&(tilt<height-5)) {
        for (int i=0; i<audioInn.bufferSize()-1; i++) {
          line(i, tilt + audioInn.left.get(i)*spread, i, tilt + audioInn.left.get(i+1)*spread);
          line(i, tilt + audioInn.left.get(i)*spread+1, i+1, tilt + audioInn.left.get(i+1)*spread+1);
        }
      }
      if ((pan>5)&&(pan<width-5)) {
        for (int i=0; i<audioInn.bufferSize()-1; i++) {
          line(pan + audioInn.left.get(i)*spread, i, pan + audioInn.left.get(i+1)*spread,i);
          line(pan + audioInn.left.get(i)*spread, i+1, pan + audioInn.left.get(i+1)*spread,i+1);
        }
      } 

    }
    else { // Circle wave
      float  sx=pan;
      float  sy=tilt+(audioInn.left.get(0)*spread+diametr)*cos(0);
      float px=sx;
      float py=sy;
      for (int i=1; i<audioInn.bufferSize()-1; i++) {
        float x=pan+(audioInn.left.get(i)*spread+diametr)*sin(i*2*PI/audioInn.bufferSize());
        float y=tilt+(audioInn.left.get(i)*spread+diametr)*cos(i*2*PI/audioInn.bufferSize());
        line(x,y,px,py);
        line(x+1,y,px+1,py);
        line(x,y+1,px,py+1);
        line(x+1,y+1,px+1,py+1);
        px=x;
        py=y;
      }
      line(sx,sy,px,py);
      line(sx+1,sy,px+1,py);
      line(sx,sy+1,px,py+1);
      line(sx+1,sy+1,px+1,py+1);
    }
  }

   /////////////////////////////////////////////////////////////////////// STROBE EFFECT
  void strobe(){
    spread=dmx[dmxAddr+spreadOffs];  //audio sense. 0=no audio, use speed instead.
    speed=(255-dmx[dmxAddr+speedOffs])/10;
    if (intensity>0) {drawStrobe();}
  }

  int strobeCounter=0;
  boolean strobing=false;
  void drawStrobe(){
    color c=fade(palette[colr%16],intensity);
    if (spread<10) {  // SPEED CONTROLLED STROBE
    if (strobeCounter<speed) {
        strobeCounter++;}
      else {
        strobeCounter=0;
        background(c);
      }
    } else { // SOUND ACTIVATED STROBE
      int peak=0;
      for (int i=0; i<audioInn.bufferSize()-1; i++) {
        int a=int(255*audioInn.right.get(i));
        if (a>peak) {peak=a;}
      }
      if (peak>spread) {
        if (!strobing) {
          background(c);
          strobing=true;
        }
      } else {strobing=false;}

    }
  }

  /////////////////////////////////////////////////////////////////////// GLOBAL SHAPE AFFECTING PAN AND TILT
  float shapePhase=0;
  void shaper(){
    shapePhase=shapePhase+0.002*(128-dmx[dmxAddr+speedOffs]);
    shapeX=int(intensity*2*sin(shapePhase));
    shapeY=int(intensity*2*cos(shapePhase));
  }

  /////////////////////////////////////////////////////////////////////// GOBO IMAGE EFFECT
  void goboImage(){
    if (intensity>0) {drawGoboImage();}
  }

  void drawGoboImage(){
    color c=fade(palette[colr%16],intensity);
    //imageOut(0,pan,tilt);
  }

}

dmx.pde

int identifyDmxStart[] = new int[3];
int maxChannel=32;
int tDmx[]= new int[512];
void receiveDmx(){
  if (connected) {
    for (int i=0; i<512; i++) {
      tDmx[i]=OpenDmx.getValue(i);
    }
    int offset=-1;
    for (int i=0; i<100; i++) {
      if ((tDmx[i]==identifyDmxStart[1])&&(tDmx[i+1]==identifyDmxStart[2])){
        offset=i;
      }
    }
    if (offset>=0) {
      for (int i=0; i<maxChannel; i++) {
        dmx[i]=tDmx[i+offset];
        //print(dmx[i]+"  ");
      }
     // println();
    }
  }
}

void initDmxStart(){
  if (connected) {
    println("Identifying");
    while ((identifyDmxStart[0]!=0)||(identifyDmxStart[1]==0) || (identifyDmxStart[2]==0)) {
      identifyDmxStart[0]=OpenDmx.getValue(0);
      identifyDmxStart[1]=OpenDmx.getValue(1);
       identifyDmxStart[2]=OpenDmx.getValue(2);
    }
    println(identifyDmxStart[1]);
    println("Found!");
  }
}

void loadDmx(){
  String[] lines;
  lines = loadStrings("dmx.txt");
  for (int i=0; i<dmx.length; i++) {
    dmx[i]=int(lines[i]);
  }
}

void saveDmx(){
    String[] lines = new String[dmx.length];
  for (int i = 0; i < dmx.length; i++) {
    lines[i] = str(dmx[i]);
  }
  saveStrings("dmx.txt", lines);
}

As the trolley moved along videos of bizarre situations should be displayed on the wall of the building.

I needed some way to sync the projected image with my movement so all the action would appear to stand still on the wall while the view port was moving. I was planning to connect a wheel to an optical fork, connected to an Arduino calculating the movement and sending it to the PC trough the USB- serial port. It ended up A LOT simpler; a large Lego wheel connected straight into the scrolling wheel of a mouse. Easy to make, easy to interface.

Foto: Dag Jensen

To display the more then 15 videos on the right place I made a patch in Processing begin able to start, stop and wall-sync up to 30 videos simultaneously.  To keep frame rates up I started and stopped the videos as the entered and left the view port. Most of the videos had no sound, so suiting clips where played from Reason controlled from the Processing patch trough midi.

The plan worked out quite ok, but far from perfect. The problem the wheel sync is that it does not account for changes in projector angle or bumps in the sidewalk. My trolley also got far to heavy and was hard to control. I ended up making cue marks with chalk on the sidewalk where I stopped my trolley and pushed a key to resync the viewport position to the next cue. Hard to explain really but it did help a lot.

Footage is taken of the whole performance, but I doubt I’ll ever get finished mixing it down to a decent Youtube video to show around. Andy, I need you! To many projects and to little time!

And .. eh .. should write more details but I’ll just publish it now. Cheers!

A bit like this: http://www.chrisoshea.org/out-of-bounds but with the projector moving on a trolley to cover the whole building.

The idea is very much inspired by Luca, the Italian artist contributing to Stedsans Porsgrunn and other GF events.

The time is short and the road is long and winding. Godspeed myself.

(by the way, the new “white” layout is awful… I want Chuck back! )

The Lamp Forest is a grid of old worn indoor lamps individually controlled from a laptop. This makes it possible to make the lamp dim and twinkle in interesting patterns, or to let the lamps interact with the audience or actors.

At the fall of 2010 the Lamp Forest was set up for the first time for Stedsans Porsgrunn. It consisted of 64 lamps in a 8 by 8 grid in the park. Add some rain and we probably set the record for Porsgrunns ground fault of the year 2010!

Anyway it all went well with no dead actresses or technicians, and this year we will try again at Stedsans Drammen. I have still not discussed the matter with Mario, my programmer for the last year lamp forest (hatted gentleman below), and I still do not know what to change and what to keep. I’ll keep you updated! (maybe.. or maybe I just fall into prolonged uselessness again…)
E, Norwegian/Technical department.

My two years of infrared investigation were rendered obsolete with the arrival of the Kinect. And I think that’s ok, because this toy is so much more fun. The games I have tried are really lame, but hacking into its data streams opens up new ways to do interactivity.

So we are entering a stage of technological artistic development where the object easily can engage in a cybernetic relationship with the observer. This feedback process opens up a series of real possibilities, in contrast to the optical illusions from the history of painting.

REMASTERPIECES is an attempt to add something to painting in the 21th century. Using Kinect to set up a space where the spectator (usually a reflexive figure standing still) is turned into an actor. With a broad range of small programs we dissect the body of painting and recreate it as vulgar entertainment.

From scribbling cave walls to aid our hunting, illustrating the lives of our saints, discovering the properties of space and perspective, creating tools that copy reality into images, to the breakdown of the exterior and the outer manifestations of inner life…the time has come to reanimate the figure of the distant bourgeois observer.

What would happen if treated a painting as a game and decoded its message into a playful one?

Hacking a PS3 and Kinect together for the ultimate FrankenConsole™

Demodrama’s department of prototypes tried to develop our recent success with La Noche en Blanco where we sampled the audience before the show. The faces of the spectators would then become part of the performance.  People really seem to like having their photo taken and seeing it projected on the wall instantly. So what would happen if we extended the interaction? What if people would get together with some music and a beer for free improvisation in something we called Cara-o-ke (Cara is Spanish for face)? Not much really…

There is an old tobacco factory in Lavapies, it should have been a new and shiny center for visual arts, but there is a crisis and the Cultural Department has no money. In the meantime the neighbors and artists have started moving in and organizing activities.

I have received another grant and this time I bought Max 5. This means that I could start working on my first patch for the EEG machine. It will be a straight brain wave to sound wave, only multiplying the frequencies into audible ones, much like a theremin. First of all the IBVA is fast, very fast at low resolution, but with only 3 sensors it’s a bit limited in the sampling area. I guess to really work with the P300 signals you need a full EEG helmet to capture all the parts. An Argentinian friend reminded me of the differences between this and Magnetic Resonance Imaging where you look inside the brain, EEG are signals going out of the cranium and can in a way be interpreted as a thermin. I suspect that working with IBVA live on a performer can quickly generate noise-only with its cable from sensors to the bluetooth sender. There are other systems, cheaper and more suited for a live setting, we hacked both the Jedi Trainer and Neurosky Mindset a time back when I helped develop this project:

The Mexican Standoff removes the link between the persons thoughts and actions; people are directly thinking about what they are doing – creating a hyper-reality. Two people use their minds via EEG headsets to fire their guns in a Mexican Standoff realized in an ultra-violent first person shooter (FPS). To trigger the EEG interface the person needs to relax. When this is detected the avatar will begin to shoot the other.

So here I am hooking myself up before the morning coffee. Looking, listening and feeling as it enters me. Often with headache as the result, staring into my brain doing nothing but mind flexing is tiring. These are the first steps in a larger project, it is the old impress – express. A video will form a base upon where the patients get their head information recorded. These data once stored and analyzed are later used in Max to control machines, sound and video in the performance space. When I discovered that the EEG laboratory at Gaustad was financed by CIA’s MKULTRA it was the last piece of the puzzle that I needed to make this into a performance project.

I have been teaching the second year students in Digital Design at IED Madrid. The workshop was called Alternative Interfaces and we were using MouseMan to interact with animations that the students would make in Flash.

The exhibition opened last Thursday and will run for one more month. From the 17th of May two new and improved versions of Mapping Madrid are also scheduled next door. Nice.

Our loosely based affinity group Demodrama has just launched its on-line platform and during the research I found the video above. I predict this will happen again and again in the future: small low/no budget groups reinventing and developing work that was done 10 years earlier by big institutions with a lot of money. As cameras and projectors become cheaper,  computers more powerful and open source is widely used, this type of technology will be for everyone. We still need some more rounds on the code before it’s ready for release though.

What have we done? What do you need? First of all hacking a PS3 Eye camera, they are cheap and fast. Then a tracking software, we use Open CCV 1.3 (formerly tBeta and originally made for multi-touch screens), that will communicate with Processing through TUIO. In order to handle the complex setup with scenes, backgrounds, masks and sounds we use the Eclipse integrated development environment.