Difference between revisions of "Team:NYU Shanghai/Code"

Line 448: Line 448:
 
     <br>}
 
     <br>}
  
−
   int instrument(int n){
+
   <br><br>int instrument(int n){
−
     int h=int(hue(color(colors[n][0],colors[n][1],
+
     <br>int h=int(hue(color(colors[n][0],colors[n][1],
−
     colors[n][2]))%6);
+
     <br><br>colors[n][2]))%6);
−
     if (h==0){return 38;}
+
     <br>if (h==0){return 38;}
−
    else if (h==1){return 103;}
+
  <br>else if (h==1){return 103;}
−
     else if (h==2){return 112;}
+
     <br>else if (h==2){return 112;}
−
     else if (h==3){return 113;}
+
     <br>else if (h==3){return 113;}
−
     else if (h==4){return 117;}
+
     <br>else if (h==4){return 117;}
−
     else {return 124;}
+
     <br>else {return 124;}
−
   }
+
   <br>}
 
    
 
    
−
   int noteVal(int n){
+
   <br><br>int noteVal(int n){
−
     int h=int(hue(color(colors[n][0],colors[n][1],
+
     <br>int h=int(hue(color(colors[n][0],colors[n][1],
−
     colors[n][2]))%6);
+
     <br>colors[n][2]))%6);
−
     if (h==0){return 14;}
+
     <br>if (h==0){return 14;}
−
     else if (h==1){return 20;}
+
     <br>else if (h==1){return 20;}
−
     else if (h==2){return 24;}
+
     <br>else if (h==2){return 24;}
−
     else if (h==3){return 60;}
+
     <br>else if (h==3){return 60;}
−
     else if (h==4){return 96;}
+
     <br>else if (h==4){return 96;}
−
     else {return 60;}
+
     <br>else {return 60;}
−
   }
+
   <br>}
  
−
     void volume_up() {
+
     <br><br>void volume_up() {
−
       volume=constrain(volume+5, 0, 127);
+
       <br>volume=constrain(volume+5, 0, 127);
−
     }
+
     <br>}
  
−
     void volume_down() {
+
     <br><br>void volume_down() {
−
       volume=constrain(volume-5, 0, 127);
+
       <br>volume=constrain(volume-5, 0, 127);
−
     }
+
     <br>}
−
   }
+
   <br>}
  
−
//step sequencer
+
<br><br>//step sequencer
−
class Sequencer {
+
<br>class Sequencer {
  
−
   boolean[] empty;
+
   <br><br>boolean[] empty;
−
   float[] rgb_list;
+
   <br>float[] rgb_list;
−
   int grid_num;
+
   <br>int grid_num;
−
   int grid_size;
+
   <br>int grid_size;
−
   int interval;
+
   <br>int interval;
  
−
   SoundCipher sc;
+
   <br><br>SoundCipher sc;
−
   boolean select=false;
+
   <br>boolean select=false;
−
   int a, b;
+
   <br>int a, b;
−
   int volume=0;
+
   <br>int volume=0;
−
   boolean on=true;
+
   <br>boolean on=true;
−
   float red=0;
+
   <br>float red=0;
−
   float green=0;  
+
   <br>float green=0;  
−
   float blue=0;
+
   <br>float blue=0;
−
   int[] notes = {
+
   <br>int[] notes = {
−
     96, 93, 91, 89, 86, 84, 81, 79, 77, 74, 72, 69, 67, 65, 62, 60
+
     <br>96, 93, 91, 89, 86, 84, 81, 79, 77, 74, 72, 69, 67, 65, 62, 60
−
   };
+
   <br>};
−
   boolean[] sequence;
+
   <br>boolean[] sequence;
  
−
   Sequencer(SoundCipher _sc,  
+
   <br><br>Sequencer(SoundCipher _sc,  
−
   int _grid_num, int _grid_size, int _interval, int _a, int _b) {
+
   <br>int _grid_num, int _grid_size, int _interval, int _a, int _b) {
−
     sc=_sc;
+
     <br>sc=_sc;
−
    grid_num=_grid_num;
+
  <br>grid_num=_grid_num;
−
     grid_size=_grid_size;
+
     <br>grid_size=_grid_size;
−
     interval=_interval;
+
     <br>interval=_interval;
  
−
     a=_a;
+
     <br><br>a=_a;
−
     b=_b;
+
     <br>b=_b;
  
  
−
     sequence=new boolean[grid_num*grid_num];
+
     <br><br>sequence=new boolean[grid_num*grid_num];
−
     for (int i=0; i<sequence.length; i++) {
+
     <br>for (int i=0; i<sequence.length; i++) {
−
       sequence[i]=false;
+
       <br>sequence[i]=false;
−
     }
+
     <br>}
  
−
     empty=new boolean[grid_num*grid_num];
+
     <br><br>empty=new boolean[grid_num*grid_num];
−
     for (int i=0; i<sequence.length; i++) {
+
     <br>for (int i=0; i<sequence.length; i++) {
−
       empty[i]=false;
+
       <br>empty[i]=false;
−
     }
+
     <br>}
−
   }
+
   <br>}
  
−
   void get_sequence(boolean[] _sequence) {
+
   <br><br>void get_sequence(boolean[] _sequence) {
−
     sequence=_sequence;
+
     <br>sequence=_sequence;
−
   }
+
   <br>}
  
−
   void get_color(float[] _rgb_list) {
+
   <br><br>void get_color(float[] _rgb_list) {
−
     rgb_list=_rgb_list;
+
     <br>rgb_list=_rgb_list;
−
     red=rgb_list[0];
+
     <br>red=rgb_list[0];
−
     green=rgb_list[1];
+
     <br>green=rgb_list[1];
−
     blue=rgb_list[2];
+
     <br>blue=rgb_list[2];
−
   }
+
   <br>}
  
−
   void draw_grid() {
+
   <br><br>void draw_grid() {
−
     pushMatrix();
+
     <br>pushMatrix();
−
     translate(a, b);
+
     <br>translate(a, b);
−
     rectMode(CORNER);
+
     <br>rectMode(CORNER);
−
     int x=0;
+
     <br>int x=0;
−
     int y=0;
+
     <br>int y=0;
 
      
 
      
−
    //black background
+
  <br><br>//black background
−
     noStroke();
+
     <br>noStroke();
−
     fill(0);
+
     <br>fill(0);
−
     rect(-interval, -interval, (grid_size+interval)*grid_num+interval*2,  
+
     <br>rect(-interval, -interval, (grid_size+interval)*grid_num+interval*2,  
−
     (grid_size+interval)*grid_num+interval*2);
+
     <br>(grid_size+interval)*grid_num+interval*2);
 
      
 
      
−
     for (int i=0; i<sequence.length; i++) {
+
     <br><br>for (int i=0; i<sequence.length; i++) {
−
       x=(grid_size+interval)*(i%grid_num);
+
       <br>x=(grid_size+interval)*(i%grid_num);
−
       y=(grid_size+interval)*(i/grid_num);
+
       <br>y=(grid_size+interval)*(i/grid_num);
−
       if (sequence[i]) {
+
       <br>if (sequence[i]) {
−
         fill(red, green, blue);
+
         <br>fill(red, green, blue);
−
       } else {
+
       <br>} else {
−
         if (select){fill(100);}
+
         <br>if (select){fill(100);}
−
         else {fill(70);}
+
         <br>else {fill(70);}
−
       }
+
       <br>}
−
       rect(x, y, grid_size, grid_size);
+
       <br>rect(x, y, grid_size, grid_size);
−
     }
+
     <br>}
  
−
     popMatrix();
+
     <br><br>popMatrix();
−
   }
+
   <br>}
  
−
   void glow(int n) {
+
   <br><br>void glow(int n) {
−
     pushMatrix();
+
     <br>pushMatrix();
−
     translate(a, b);
+
     <br>translate(a, b);
−
     rectMode(CORNER);
+
     <br><br>rectMode(CORNER);
−
     for (int m=0; m<grid_num; m++) {
+
     <br>for (int m=0; m<grid_num; m++) {
−
       if (sequence[m*grid_num+n]) {
+
       <br>if (sequence[m*grid_num+n]) {
−
         for (int p=-1; p<2; p++) {
+
         <br>for (int p=-1; p<2; p++) {
−
           for (int q=-1; q<2; q++) {
+
           <br>for (int q=-1; q<2; q++) {
−
             if (n+p>=0&&n+p<grid_num&&m+q>=0&&
+
             <br>if (n+p>=0&&n+p<grid_num&&m+q>=0&&
−
               m+q<grid_num) {
+
               <br>m+q<grid_num) {
−
               noStroke();
+
               <br>noStroke();
−
               fill(255, 255, 255, 20);
+
               <br>fill(255, 255, 255, 20);
−
              rect((n+p)*(interval+grid_size), (m+q)*(interval+grid_size),  
+
            <br>rect((n+p)*(interval+grid_size), (m+q)*(interval+grid_size),  
−
               grid_size, grid_size);
+
               <br>grid_size, grid_size);
−
             }
+
             <br>}
−
             if (p==0&&q==0){
+
             <br>if (p==0&&q==0){
−
               fill(red, green, blue);
+
               <br>fill(red, green, blue);
−
               rect(n*(interval+grid_size)-interval/2, m*(interval+grid_size)-interval/2,  
+
               <br>rect(n*(interval+grid_size)-interval/2, m*(interval+grid_size)-interval/2,  
−
               grid_size+interval, grid_size+interval);
+
               <br>grid_size+interval, grid_size+interval);
−
               fill(255, 255, 255, 30);
+
               <br>fill(255, 255, 255, 30);
−
               rect(n*(interval+grid_size)-interval/2, m*(interval+grid_size)-interval/2,  
+
               <br>rect(n*(interval+grid_size)-interval/2, m*(interval+grid_size)-interval/2,  
−
               grid_size+interval, grid_size+interval);
+
               <br>grid_size+interval, grid_size+interval);
−
             }
+
             <br>}
−
           }
+
           <br>}
−
         }
+
         <br>}
−
       }
+
       <br>}
−
     }
+
     <br>}
−
     popMatrix();
+
     <br>popMatrix();
−
   }
+
   <br>}
  
  
−
   void play_sounds(int n) {
+
   <br><br>void play_sounds(int n) {
−
     float noteVal;
+
     <br>float noteVal;
−
     float[] noteVals=new float[0];
+
     <br>float[] noteVals=new float[0];
  
−
     for (int i=0; i<grid_num; i++) {
+
     <br><br>for (int i=0; i<grid_num; i++) {
  
−
       // if the data text file has a "1" play note
+
       <br><br>// if the data text file has a "1" play note
−
       if (sequence[i*grid_num+n]) {
+
       <br>if (sequence[i*grid_num+n]) {
−
         noteVal = float(notes[i]);
+
         <br>noteVal = float(notes[i]);
−
         noteVals=append(noteVals, noteVal);
+
         <br>noteVals=append(noteVals, noteVal);
−
       }
+
       <br>}
 
        
 
        
−
     }
+
     <br><br>}
−
     sc.instrument(instrument());
+
     <br>sc.instrument(instrument());
−
     sc.playChord(noteVals, volume, 0.25);
+
     <br>sc.playChord(noteVals, volume, 0.25);
−
   }
+
   <br>}
 
    
 
    
−
   int instrument(){
+
   <br><br>int instrument(){
−
     int h=int(hue(color(red,green,blue))%8);
+
     <br>int h=int(hue(color(red,green,blue))%8);
−
     if (h==0){return 2;}
+
     <br>if (h==0){return 2;}
−
     else if (h==1){return 3;}
+
     <br>else if (h==1){return 3;}
−
     else if (h==2){return 38;}
+
     <br>else if (h==2){return 38;}
−
     else if (h==3){return 46;}
+
     <br>else if (h==3){return 46;}
−
     else if (h==4){return 47;}
+
     <br>else if (h==4){return 47;}
−
     else if (h==5){return 55;}
+
     <br>else if (h==5){return 55;}
−
     else if (h==6){return 116;}
+
     <br>else if (h==6){return 116;}
−
     else {return 120;}
+
     <br>else {return 120;}
−
   }
+
   <br>}
  
−
   void select(boolean _select) {
+
   <br><br>void select(boolean _select) {
−
     select=_select;
+
     <br>select=_select;
−
   }
+
   <br>}
  
−
   void set_volume(int _volume) {
+
   <br><br>void set_volume(int _volume) {
−
     volume=constrain(_volume, 0, 127);
+
     <br>volume=constrain(_volume, 0, 127);
−
   }
+
   <br>}
  
−
   void delete() {
+
   <br><br>void delete() {
−
     sequence=empty;
+
     <br>sequence=empty;
−
   }
+
   <br>}
−
}
+
<br>}
−
//step sequencer video
+
<br>//step sequencer video
−
class Sequencer_video {
+
<br>class Sequencer_video {
−
   Capture video;
+
   <br>Capture video;
−
   SoundCipher sc;
+
   <br>SoundCipher sc;
−
   BlobDetection theBlobDetection;
+
   <br>BlobDetection theBlobDetection;
−
   boolean newFrame=false;
+
   <br>boolean newFrame=false;
−
   PImage img;
+
   <br>PImage img;
−
   int a, b;
+
   <br>int a, b;
−
   int grid_size;
+
   <br>int grid_size;
−
   int grid_num;
+
   <br>int grid_num;
−
   int interval;
+
   <br>int interval;
−
   int block_size;
+
   <br>int block_size;
−
   int volume=0;
+
   <br>int volume=0;
−
   float[][] blob_color;
+
   <br>float[][] blob_color;
−
   float[] avg_color=new float[3];
+
   <br>float[] avg_color=new float[3];
−
   float[][] blobs;
+
   <br>float[][] blobs;
−
   float[][][] raw_color;  
+
   <br>float[][][] raw_color;  
−
   float threshold=0.5;
+
   <br>float threshold=0.5;
−
   boolean draw_grid=false;
+
   <br>boolean draw_grid=false;
−
   boolean[] sequence;
+
   <br>boolean[] sequence;
−
   int[] notes = {
+
   <br>int[] notes = {
−
     96, 93, 91, 89, 86, 84, 81, 79, 77, 74, 72, 69, 67, 65, 62, 60
+
     <br>, 93, 91, 89, 86, 84, 81, 79, 77, 74, 72, 69, 67, 65, 62, 60
−
   };
+
   <br>};
−
   int radius=180;
+
   <br>int radius=180;
  
−
   Sequencer_video(Capture _video, SoundCipher _sc, int _grid_num,  
+
   <br><br>Sequencer_video(Capture _video, SoundCipher _sc, int _grid_num,  
−
   int _grid_size,int _interval) {
+
   <br>int _grid_size,int _interval) {
−
     colorMode(RGB, 255, 255, 255, 100);
+
     <br>colorMode(RGB, 255, 255, 255, 100);
−
     video=_video;
+
     <br>video=_video;
−
     sc=_sc;
+
     <br>sc=_sc;
−
     grid_num=_grid_num;
+
     <br>grid_num=_grid_num;
−
     grid_size=_grid_size;
+
     <br>grid_size=_grid_size;
−
     interval=_interval;
+
     <br>interval=_interval;
−
     block_size=(interval+grid_size)*grid_num;
+
     <br>block_size=(interval+grid_size)*grid_num;
 
      
 
      
−
     sequence=new boolean[grid_num*grid_num];
+
     <br>sequence=new boolean[grid_num*grid_num];
−
     img = new PImage(grid_num*(grid_size+interval)-interval,
+
     <br>img = new PImage(grid_num*(grid_size+interval)-interval,
−
     grid_num*(grid_size+interval)-interval);
+
     <br>grid_num*(grid_size+interval)-interval);
−
     theBlobDetection = new BlobDetection(img.width, img.height);
+
     <br>theBlobDetection = new BlobDetection(img.width, img.height);
−
     theBlobDetection.setPosDiscrimination(true);
+
     <br>theBlobDetection.setPosDiscrimination(true);
−
   }
+
   <br>}
  
−
   void threshold_up() {
+
   <br><br>void threshold_up() {
−
     threshold=constrain(threshold+0.02, 0, 1);
+
     <br>threshold=constrain(threshold+0.02, 0, 1);
−
     println(threshold);
+
     <br>println(threshold);
−
   }
+
   <br>}
  
−
   void threshold_down() {
+
   <br><br>void threshold_down() {
−
     threshold=constrain(threshold-0.02, 0, 1);
+
     <br>threshold=constrain(threshold-0.02, 0, 1);
−
     println(threshold);
+
     <br>println(threshold);
−
   }
+
   <br>}
  
−
   void position(int _a, int _b) {
+
   <br><br>void position(int _a, int _b) {
−
     a=_a;
+
     <br>a=_a;
−
     b=_b;
+
     <br>b=_b;
−
   }
+
   <br>}
  
−
   void grid_on() {
+
   <br><br>void grid_on() {
−
     draw_grid=true;
+
     <br>draw_grid=true;
−
   }
+
   <br>}
 
    
 
    
−
   void grid_off(){
+
   <br><br>void grid_off(){
−
     draw_grid=false;
+
     <br>draw_grid=false;
−
   }
+
   <br>}
  
−
   void bd() {
+
   <br><br>void bd() {
−
     if (video.available()) {
+
     <br>if (video.available()) {
−
       theBlobDetection.setThreshold(threshold);
+
       <br>theBlobDetection.setThreshold(threshold);
−
       video.read();
+
       <br>video.read();
−
       img.copy(video, (video.width-video.height)/2, 0, video.height,
+
       <br>img.copy(video, (video.width-video.height)/2, 0, video.height,
−
      video.height, 0, 0, img.width, img.height);
+
    <br>video.height, 0, 0, img.width, img.height);
−
       image(img, a, b, img.width+interval, img.height+interval);
+
       <br>image(img, a, b, img.width+interval, img.height+interval);
−
       fastblur(img, 2);
+
       <br>fastblur(img, 2);
−
       theBlobDetection.computeBlobs(img.pixels);
+
       <br>theBlobDetection.computeBlobs(img.pixels);
−
       save_blob();
+
       <br>save_blob();
−
       blob_color();
+
       <br>blob_color();
−
       convert();
+
       <br>convert();
−
     }
+
     <br>}
−
   }
+
   <br>}
  
−
   void bd_draw(int n) {
+
   <br>void bd_draw(int n) {
−
     if (draw_grid) {
+
     <br>if (draw_grid) {
 
        
 
        
−
       draw_grid();
+
       <br>draw_grid();
−
       glow(n);
+
       <br>glow(n);
−
       play_sounds(n);
+
       <br>play_sounds(n);
−
     } else {
+
     <br>} else {
−
       drawBlobsAndEdges(true, false);
+
       <br>drawBlobsAndEdges(true, false);
−
     }
+
     <br>}
−
   }
+
   <br>}
  
−
   void blob_color() {
+
   <br><br>void blob_color() {
−
     float red=0;
+
     <br>float red=0;
−
     float blue=0;
+
     <br>float blue=0;
−
     float green=0;
+
     <br>float green=0;
−
     int total=theBlobDetection.getBlobNb ();
+
     <br>int total=theBlobDetection.getBlobNb ();
−
     for (int n=0; n<total; n++) {
+
     <br>for (int n=0; n<total; n++) {
  
−
       //get the color
+
       <br><br>//get the color
−
       blob_color=new float[total][3];
+
       <br><br><br>blob_color=new float[total][3];
−
       int centerX = int(blobs[n][0]+0.5*blobs[n][2]);
+
       <br><br><br><br>int centerX = int(blobs[n][0]+0.5*blobs[n][2]);
−
       int centerY = int(blobs[n][1]+0.5*blobs[n][3]);
+
       <br>int centerY = int(blobs[n][1]+0.5*blobs[n][3]);
  
−
       color c = get(centerX+a, centerY+b);
+
       <br><br>color c = get(centerX+a, centerY+b);
−
       blob_color[n][0] = red(c);
+
       <br>blob_color[n][0] = red(c);
−
       blob_color[n][1] = green(c);
+
       <br><br>blob_color[n][1] = green(c);
−
       blob_color[n][2] = blue(c);
+
       <br>blob_color[n][2] = blue(c);
 
    
 
    
−
       red+=blob_color[n][0];
+
       <br><br>red+=blob_color[n][0];
−
       green+=blob_color[n][1];
+
       <br>green+=blob_color[n][1];
−
       blue+=blob_color[n][2];
+
       <br>blue+=blob_color[n][2];
 
            
 
            
  
−
     }
+
     <br>}
−
     avg_color[0]=constrain(red/total*1.2,0,255);
+
     <br>avg_color[0]=constrain(red/total*1.2,0,255);
−
     avg_color[1]=constrain(green/total*1.2,0,255);
+
     <br>avg_color[1]=constrain(green/total*1.2,0,255);
−
     avg_color[2]=constrain(blue/total*1.2,0,255);
+
     <br>avg_color[2]=constrain(blue/total*1.2,0,255);
  
−
   }
+
   <br>}
  
−
   void drawBlobsAndEdges(boolean drawBlobs, boolean drawEdges) {
+
   <br><br>void drawBlobsAndEdges(boolean drawBlobs, boolean drawEdges) {
−
     pushMatrix();
+
     <br>pushMatrix();
−
     translate(a, b);
+
     <br><br>translate(a, b);
−
     noFill();
+
     <br><br><br>noFill();
−
     rectMode(CORNER);
+
     <br><br><br><br>rectMode(CORNER);
−
     Blob b;
+
     <br>Blob b;
−
     EdgeVertex eA, eB;
+
     <br>EdgeVertex eA, eB;
 
      
 
      
−
     for (int n=0; n<theBlobDetection.getBlobNb (); n++)
+
     <br><br>for (int n=0; n<theBlobDetection.getBlobNb (); n++)
−
     {
+
     <br>{
−
       b=theBlobDetection.getBlob(n);
+
       <br>b=theBlobDetection.getBlob(n);
−
       if (b!=null)
+
       <br>if (b!=null)
−
       {
+
       <br>{
−
         // Edges
+
         <br>// Edges
−
         if (drawEdges)
+
         <br>if (drawEdges)
−
         {
+
         <br>{
−
           strokeWeight(3);
+
           <br>strokeWeight(3);
−
           stroke(0, 255, 0);
+
           <br><br>stroke(0, 255, 0);
−
           for (int m=0; m<b.getEdgeNb (); m++)
+
           <br>for (int m=0; m<b.getEdgeNb (); m++)
−
           {
+
           <br>{
−
             eA = b.getEdgeVertexA(m);
+
             <br>eA = b.getEdgeVertexA(m);
−
             eB = b.getEdgeVertexB(m);
+
             <br>eB = b.getEdgeVertexB(m);
−
             if (eA !=null && eB !=null)
+
             <br>if (eA !=null && eB !=null)
−
               line(
+
               <br>line(
−
               eA.x*block_size, eA.y*block_size,  
+
               <br><br>eA.x*block_size, eA.y*block_size,  
−
               eB.x*block_size, eB.y*block_size
+
               <br><br><br>eB.x*block_size, eB.y*block_size
−
                 );
+
                 <br>);
−
           }
+
           <br>}
−
         }
+
         <br>}
  
−
         // Blobs
+
         <br><br>// Blobs
−
         if (dist(block_size/2,block_size/2,b.xMin*block_size,
+
         <br>if (dist(block_size/2,block_size/2,b.xMin*block_size,
−
         b.yMin*block_size)<radius
+
         <br>b.yMin*block_size)<radius
−
         &&drawBlobs&&b.w*block_size>5&&b.w*block_size<25&&
+
         <br>&&drawBlobs&&b.w*block_size>5&&b.w*block_size<25&&
−
         b.h*block_size>5&&b.h*block_size<25)
+
         <br>b.h*block_size>5&&b.h*block_size<25)
−
         {
+
         <br>{
−
           strokeWeight(3);
+
           <br>strokeWeight(3);
−
           stroke(255, 0, 0);
+
           <br>stroke(255, 0, 0);
 
          
 
          
−
           rect(
+
           <br><br>rect(
−
           b.xMin*block_size, b.yMin*block_size,  
+
           <br><br><br>b.xMin*block_size, b.yMin*block_size,  
−
           b.w*block_size, b.h*block_size
+
           <br><br><br><br>b.w*block_size, b.h*block_size
−
             );
+
             <br>);
−
         }
+
         <br>}
−
       }
+
       <br>}
−
     }
+
     <br>}
−
    popMatrix();
+
  <br>  popMatrix();
−
   }
+
   <br><br>}
  
−
   void fastblur(PImage img, int radius)
+
   <br><br>void fastblur(PImage img, int radius)
−
   {
+
   <br>{
−
     if (radius<1) {
+
     <br>if (radius<1) {
−
       return;
+
       <br>return;
−
     }
+
     <br>}
−
     int w=img.width;
+
     <br>int w=img.width;
−
     int h=img.height;
+
     <br>int h=img.height;
−
     int wm=w-1;
+
     <br>int wm=w-1;
−
     int hm=h-1;
+
     <br>int hm=h-1;
−
     int wh=w*h;
+
     <br>int wh=w*h;
−
     int div=radius+radius+1;
+
     <br>int div=radius+radius+1;
−
     int r[]=new int[wh];
+
     <br>int r[]=new int[wh];
−
     int g[]=new int[wh];
+
     <br>int g[]=new int[wh];
−
     int b[]=new int[wh];
+
     <br>int b[]=new int[wh];
−
     int rsum, gsum, bsum, x, y, i, p, p1, p2, yp, yi, yw;
+
     <br>int rsum, gsum, bsum, x, y, i, p, p1, p2, yp, yi, yw;
−
     int vmin[] = new int[max(w, h)];
+
     <br>int vmin[] = new int[max(w, h)];
−
     int vmax[] = new int[max(w, h)];
+
     <br>int vmax[] = new int[max(w, h)];
−
     int[] pix=img.pixels;
+
     <br>int[] pix=img.pixels;
−
     int dv[]=new int[256*div];
+
     <br>int dv[]=new int[256*div];
−
     for (i=0; i<256*div; i++) {
+
     <br>for (i=0; i<256*div; i++) {
−
       dv[i]=(i/div);
+
       <br>dv[i]=(i/div);
−
     }
+
     <br>}
  
−
     yw=yi=0;
+
     <br><br>yw=yi=0;
  
−
     for (y=0; y<h; y++) {
+
     <br><br>for (y=0; y<h; y++) {
−
       rsum=gsum=bsum=0;
+
       <br>rsum=gsum=bsum=0;
−
       for (i=-radius; i<=radius; i++) {
+
       <br>for (i=-radius; i<=radius; i++) {
−
         p=pix[yi+min(wm, max(i, 0))];
+
         <br>p=pix[yi+min(wm, max(i, 0))];
−
         rsum+=(p & 0xff0000)>>16;
+
         <br>rsum+=(p & 0xff0000)>>16;
−
         gsum+=(p & 0x00ff00)>>8;
+
         <br>gsum+=(p & 0x00ff00)>>8;
−
         bsum+= p & 0x0000ff;
+
         <br>bsum+= p & 0x0000ff;
−
       }
+
       <br>}
−
       for (x=0; x<w; x++) {
+
       <br>for (x=0; x<w; x++) {
  
−
         r[yi]=dv[rsum];
+
         <br><br>r[yi]=dv[rsum];
−
         g[yi]=dv[gsum];
+
         <br>g[yi]=dv[gsum];
−
         b[yi]=dv[bsum];
+
         <br>b[yi]=dv[bsum];
  
−
        if (y==0) {
+
      <br><br>if (y==0) {
−
           vmin[x]=min(x+radius+1, wm);
+
           <br>vmin[x]=min(x+radius+1, wm);
−
          vmax[x]=max(x-radius, 0);
+
        <br>vmax[x]=max(x-radius, 0);
−
         }
+
         <br>}
−
         p1=pix[yw+vmin[x]];
+
         <br>p1=pix[yw+vmin[x]];
−
         p2=pix[yw+vmax[x]];
+
         <br><br>p2=pix[yw+vmax[x]];
  
−
         rsum+=((p1 & 0xff0000)-(p2 & 0xff0000))>>16;
+
         <br><br>rsum+=((p1 & 0xff0000)-(p2 & 0xff0000))>>16;
−
         gsum+=((p1 & 0x00ff00)-(p2 & 0x00ff00))>>8;
+
         <br>gsum+=((p1 & 0x00ff00)-(p2 & 0x00ff00))>>8;
−
         bsum+= (p1 & 0x0000ff)-(p2 & 0x0000ff);
+
         <br><br><br>bsum+= (p1 & 0x0000ff)-(p2 & 0x0000ff);
−
         yi++;
+
         <br>yi++;
−
       }
+
       <br>}
−
       yw+=w;
+
       <br>yw+=w;
−
    }
+
  <br> }
  
−
     for (x=0; x<w; x++) {
+
     <br><br>for (x=0; x<w; x++) {
−
       rsum=gsum=bsum=0;
+
       <br>rsum=gsum=bsum=0;
−
       yp=-radius*w;
+
       <br>yp=-radius*w;
−
       for (i=-radius; i<=radius; i++) {
+
       <br>for (i=-radius; i<=radius; i++) {
−
         yi=max(0, yp)+x;
+
         <br>yi=max(0, yp)+x;
−
         rsum+=r[yi];
+
         <br>rsum+=r[yi];
−
         gsum+=g[yi];
+
         <br>gsum+=g[yi];
−
         bsum+=b[yi];
+
         <br>bsum+=b[yi];
−
         yp+=w;
+
         <br>yp+=w;
−
       }
+
       <br>}
−
       yi=x;
+
       <br>yi=x;
−
       for (y=0; y<h; y++) {
+
       <br>for (y=0; y<h; y++) {
−
         pix[yi]=0xff000000 | (dv[rsum]<<16) | (dv[gsum]<<8) | dv[bsum];
+
         <br>pix[yi]=0xff000000 | (dv[rsum]<<16) | (dv[gsum]<<8) | dv[bsum];
−
         if (x==0) {
+
         <br>if (x==0) {
−
           vmin[y]=min(y+radius+1, hm)*w;
+
           <br>vmin[y]=min(y+radius+1, hm)*w;
−
           vmax[y]=max(y-radius, 0)*w;
+
           <br>vmax[y]=max(y-radius, 0)*w;
−
         }
+
         <br>}
−
         p1=x+vmin[y];
+
         <br>p1=x+vmin[y];
−
         p2=x+vmax[y];
+
         <br>p2=x+vmax[y];
  
−
         rsum+=r[p1]-r[p2];
+
         <br><br>rsum+=r[p1]-r[p2];
−
         gsum+=g[p1]-g[p2];
+
         <br>gsum+=g[p1]-g[p2];
−
         bsum+=b[p1]-b[p2];
+
         <br>bsum+=b[p1]-b[p2];
  
−
         yi+=w;
+
         <br><br>yi+=w;
−
       }
+
       <br>}
−
     }
+
     <br>}
−
   }
+
   <br>}
  
−
   void save_blob() {
+
   <br><br>void save_blob() {
  
−
     Blob b;
+
     <br><br>Blob b;
−
     blobs=new float[theBlobDetection.getBlobNb ()][4];
+
     <br>blobs=new float[theBlobDetection.getBlobNb ()][4];
−
     for (int n=0; n<theBlobDetection.getBlobNb (); n++)
+
     <br>for (int n=0; n<theBlobDetection.getBlobNb (); n++)
−
     {
+
     <br>{
−
       b=theBlobDetection.getBlob(n);
+
       <br>b=theBlobDetection.getBlob(n);
−
       if (dist(block_size/2,block_size/2,b.xMin*block_size,
+
       <br>if (dist(block_size/2,block_size/2,b.xMin*block_size,
−
         b.yMin*block_size)<radius
+
         <br>b.yMin*block_size)<radius
−
       &&b.w*block_size>5&&b.w*block_size<25&&
+
       <br>&&b.w*block_size>5&&b.w*block_size<25&&
−
       b.h*block_size>5&&b.h*block_size<25){
+
       <br>b.h*block_size>5&&b.h*block_size<25){
−
       blobs[n][0]=b.xMin*block_size;
+
       <br>blobs[n][0]=b.xMin*block_size;
−
       blobs[n][1]=b.yMin*block_size;
+
       <br>blobs[n][1]=b.yMin*block_size;
−
       blobs[n][2]=b.w*block_size;
+
       <br>blobs[n][2]=b.w*block_size;
−
       blobs[n][3]=b.h*block_size;
+
       <br>blobs[n][3]=b.h*block_size;
−
     }
+
     <br>}
−
     }
+
     <br>}
−
   }
+
   <br>}
  
−
   void convert() {
+
   <br><br>void convert() {
−
     int row, col, i;
+
     <br>int row, col, i;
−
     for (int n=0; n<sequence.length; n++) {
+
     <br>for (int n=0; n<sequence.length; n++) {
−
       sequence[n]=false;
+
       <br>sequence[n]=false;
−
     }
+
     <br>}
−
     for (int n=0; n<blobs.length; n++) {
+
     <br>for (int n=0; n<blobs.length; n++) {
−
       row=int(blobs[n][0]+blobs[n][2]*0.5)/grid_size;
+
       <br>row=int(blobs[n][0]+blobs[n][2]*0.5)/grid_size;
−
       col=int(blobs[n][1]+blobs[n][3]*0.5)/grid_size;
+
       <br>col=int(blobs[n][1]+blobs[n][3]*0.5)/grid_size;
−
       i=row+col*grid_num;
+
       <br>i=row+col*grid_num;
−
      if (i>0&&i<grid_num*grid_num) {
+
    <br>if (i>0&&i<grid_num*grid_num) {
−
         sequence[i]=true;
+
         <br>sequence[i]=true;
−
       }
+
       <br>}
−
     }
+
     <br>}
−
   }
+
   <br>}
  
−
   void draw_grid() {
+
   <br><br>void draw_grid() {
−
     pushMatrix();
+
     <br>pushMatrix();
−
     translate(a, b);
+
     <br>translate(a, b);
−
     rectMode(CORNER);
+
     <br>rectMode(CORNER);
−
     int x=0;
+
     <br>int x=0;
−
     int y=0;
+
     <br>int y=0;
−
     noStroke();
+
     <br>noStroke();
−
     fill(0);
+
     <br>fill(0);
−
     rect(-interval,-interval,(grid_size+interval)*grid_num+interval*2,
+
     <br>rect(-interval,-interval,(grid_size+interval)*grid_num+interval*2,
−
     (grid_size+interval)*grid_num+interval*2);
+
     <br>(grid_size+interval)*grid_num+interval*2);
−
     for (int i=0; i<sequence.length; i++) {
+
     <br>for (int i=0; i<sequence.length; i++) {
−
       x=(grid_size+interval)*(i%grid_num);
+
       <br>x=(grid_size+interval)*(i%grid_num);
−
       y=(grid_size+interval)*(i/grid_num);
+
       <br>y=(grid_size+interval)*(i/grid_num);
  
−
         noStroke();
+
         <br><br>noStroke();
 
        
 
        
−
       if (sequence[i]) {
+
       <br><br>if (sequence[i]) {
−
         fill(avg_color[0], avg_color[1], avg_color[2]);
+
         <br>fill(avg_color[0], avg_color[1], avg_color[2]);
−
       } else {
+
       <br>} else {
−
        fill(70);
+
      <br>fill(70);
−
       }
+
       <br>}
−
       rect(x, y, grid_size, grid_size);
+
       <br>rect(x, y, grid_size, grid_size);
−
     }
+
     <br>}
−
     popMatrix();
+
     <br>popMatrix();
−
   }
+
   <br>}
  
−
   void glow(int n) {
+
   <br><br>void glow(int n) {
−
     pushMatrix();
+
     <br>pushMatrix();
−
     translate(a, b);
+
     <br>translate(a, b);
−
     rectMode(CORNER);
+
     <br>rectMode(CORNER);
−
     for (int m=0; m<grid_num; m++) {
+
     <br>for (int m=0; m<grid_num; m++) {
−
       if (sequence[m*grid_num+n]) {
+
       <br>if (sequence[m*grid_num+n]) {
−
         for (int p=-1; p<2; p++) {
+
         <br>for (int p=-1; p<2; p++) {
−
           for (int q=-1; q<2; q++) {
+
           <br>for (int q=-1; q<2; q++) {
−
             if (n+p>=0&&n+p<grid_num&&m+q>=0&&
+
             <br>if (n+p>=0&&n+p<grid_num&&m+q>=0&&
−
               m+q<grid_num) {
+
               <br>m+q<grid_num) {
−
               noStroke();
+
               <br>noStroke();
−
               fill(255, 255, 255, 20);
+
               <br><br>fill(255, 255, 255, 20);
−
               rect((n+p)*(interval+grid_size), (m+q)*(interval+grid_size),  
+
               <br>rect((n+p)*(interval+grid_size), (m+q)*(interval+grid_size),  
−
               grid_size, grid_size);
+
               <br><br>grid_size, grid_size);
−
             }
+
             <br>}
−
             if (p==0&&q==0){
+
             <br>if (p==0&&q==0){
−
               fill(255, 255, 255, 30);
+
               <br>fill(255, 255, 255, 30);
−
               rect(n*(interval+grid_size), m*(interval+grid_size),  
+
               <br>rect(n*(interval+grid_size), m*(interval+grid_size),  
−
               grid_size, grid_size);
+
               <br>grid_size, grid_size);
−
             }
+
             <br>}
−
           }
+
           <br>}
−
         }
+
         <br>}
−
       }
+
       <br>}
−
     }
+
     <br>}
−
     popMatrix();
+
     <br>popMatrix();
−
   }
+
   <br>}
  
−
  void play_sounds(int n) {
+
<br>  void play_sounds(int n) {
−
     float noteVal;
+
     <br>float noteVal;
−
     float[] noteVals=new float[0];
+
     <br>float[] noteVals=new float[0];
−
     for (int i=0; i<grid_num; i++) {
+
     <br>for (int i=0; i<grid_num; i++) {
−
       if (sequence[i*grid_num+n]) {
+
       <br>if (sequence[i*grid_num+n]) {
−
         noteVal = float(notes[i]);
+
         <br>noteVal = float(notes[i]);
−
         noteVals=append(noteVals, noteVal);
+
         <br>noteVals=append(noteVals, noteVal);
−
       }
+
       <br>}
−
     }
+
     <br>}
−
   sc.instrument(instrument());
+
   <br>sc.instrument(instrument());
−
   sc.playChord(noteVals, volume, 0.25);
+
   <br>sc.playChord(noteVals, volume, 0.25);
−
   }
+
   <br>}
  
−
   float[] grid_color() {
+
   <br><br>float[] grid_color() {
−
     float[] color_return=new float[3];
+
     <br>float[] color_return=new float[3];
−
     arrayCopy(avg_color, color_return);
+
     <br>arrayCopy(avg_color, color_return);
−
     return color_return;
+
     <br>return color_return;
−
   }
+
   <br>}
  
−
   boolean[] sequence() {
+
   <br><br>boolean[] sequence() {
−
     boolean[] to_return=new boolean[sequence.length];
+
     <br>boolean[] to_return=new boolean[sequence.length];
−
     arrayCopy(sequence, to_return);
+
     <br>arrayCopy(sequence, to_return);
−
     return to_return;
+
     <br>return to_return;
−
   }
+
   <br>}
  
−
   int instrument(){
+
   <br><br><br>int instrument(){
−
     int h=int(hue(color(avg_color[0],avg_color[1],
+
     <br>int h=int(hue(color(avg_color[0],avg_color[1],
−
     avg_color[2]))%8);
+
     <br>avg_color[2]))%8);
−
     if (h==0){return 2;}
+
     <br>if (h==0){return 2;}
−
     else if (h==1){return 3;}
+
     <br>else if (h==1){return 3;}
−
     else if (h==2){return 38;}
+
     <br>else if (h==2){return 38;}
−
     else if (h==3){return 46;}
+
     <br>else if (h==3){return 46;}
−
     else if (h==4){return 47;}
+
     <br>else if (h==4){return 47;}
−
     else if (h==5){return 55;}
+
     <br>else if (h==5){return 55;}
−
     else if (h==6){return 116;}
+
     <br>else if (h==6){return 116;}
−
     else {return 120;}
+
     <br>else {return 120;}
−
   }
+
   <br>}
 
    
 
    
−
   void set_volume(int _volume) {
+
   <br><br>void set_volume(int _volume) {
−
     volume=constrain(_volume, 0, 127);
+
     <br>volume=constrain(_volume, 0, 127);
−
   }
+
   <br>}
−
}
+
<br>}
−
 
+
−
 
+
−
 
+
−
 
+
−
 
+
  
 
<br><br>Source: blob detection  
 
<br><br>Source: blob detection  

Revision as of 06:30, 10 September 2015

Code

//main
import processing.video.*;
import arb.soundcipher.*;
import blobDetection.*;

Capture video_sequencer, video_rack;
SoundCipher sc = new SoundCipher(this);

int grid_size=20;
int grid_num=16;
int window_size;
int window_height;
int block_number=3;

int interval=4;
int margin;
int n=0;//iterator for play()

boolean[] camera= new boolean[block_number];
boolean[] music=new boolean[block_number];
boolean tube=false;
int[] volume=new int[block_number];

Sequencer[] sequencer= new Sequencer[block_number];
Sequencer_video sequencer_video;
Rack rack;

void setup() {
volume[0]=0;
volume[1]=0;
volume[2]=0;
window_size=displayWidth;
window_height=displayHeight;

margin=(window_size-(grid_num*(grid_size+interval)+interval)
*block_number)/(block_number+1);
size(window_size, window_height);

//empty tracks
for (int i=0; icamera[i]=false;
music[i]=false; }

make_empty();

String[] cameras = Capture.list();

video_sequencer = new Capture(this, cameras[0]);
video_sequencer.start();
sequencer_video=new Sequencer_video(video_sequencer, sc, grid_num, grid_size, interval);

video_rack = new Capture(this, cameras[15]);
video_rack.start();
rack=new Rack(video_rack, sc, window_size, window_height,
window_height-margin-grid_num*(grid_size+interval));

frameRate(4); }

void draw() {
background(0);
if (tube) {
rack.get_color();
rack.draw_rack();
rack.glow(n);
rack.play_sounds(n); }

for (int i=0; isequencer[i].draw_grid();
if (camera[i]&&!music[i]) {
sequencer_video.position(pos_x(i), margin);
sequencer_video.grid_off();
sequencer_video.bd();
sequencer_video.bd_draw(n);
} else if (camera[i]&&music[i]) {
sequencer_video.position(pos_x(i), margin);
sequencer_video.grid_on();
sequencer_video.bd();
sequencer_video.bd_draw(n);
} else if (!camera[i]&&music[i]) {
sequencer[i].set_volume(volume[i]);
sequencer[i].play_sounds(n);
sequencer[i].glow(n);
}
}

n++;
if (n>=grid_num) {
n=0;
}
}

void keyPressed() {
//track 1
if (key=='q'||key=='Q') {
if (camera[0]==false &&camera[1]==false &&camera[2]==false) { camera[0]=true;
}
} else if (key=='w'||key=='W') {
camera[0]=false;
if (music[0]) {
sequencer[0].get_sequence(sequencer_video.sequence());
sequencer[0].get_color(sequencer_video.grid_color());
}
} else if (key=='e'||key=='E') {
music[0]=true;
} else if (key=='r'||key=='R') {
music[0]=false;
sequencer[0].delete();
} else if (key=='t'||key=='T') {
if (music[0]) {

if (camera[0]) {
sequencer_video.set_volume(volume[0]);
} else {
sequencer[0].set_volume(volume[0]);
}
}
} else if (key=='y'||key=='Y') {
if (music[0]) {
volume[0]=constrain(volume[0]+5, 0, 127);
if (camera[0]) {
.set_volume(volume[0]);
} else {
sequencer[0].set_volume(volume[0]);
}
}
}
//track 2
else if (key=='a'||key=='A') {
if (camera[0]==false &&camera[1]==false &&camera[2]==false) { camera[1]=true;
}
} else if (key=='s'||key=='S') {
camera[1]=false;
if (music[1]) {
sequencer[1].get_sequence(sequencer_video.sequence());
sequencer[1].get_color(sequencer_video.grid_color());
}
} else if (key=='d'||key=='D') {
music[1]=true;
} else if (key=='f'||key=='F') {
music[1]=false;
sequencer[1].delete();
} else if (key=='g'||key=='G') {
if (music[1]) {
volume[1]=constrain(volume[1]-5, 0, 127);
if (camera[1]) {
sequencer_video.set_volume(volume[1]);
} else {
sequencer[1].set_volume(volume[1]);
}
}
} else if (key=='h'||key=='H') {
if (music[1]) {
volume[1]=constrain(volume[1]+5, 0, 127);
if (camera[1]) {
sequencer_video.set_volume(volume[1]);
} else {
sequencer[1].set_volume(volume[1]);
}
}
}
//track 3
else if (key=='z'||key=='Z') {
if (camera[0]==false &&camera[1]==false &&camera[2]==false) {
camera[2]=true;
}
} else if (key=='x'||key=='X') {
camera[2]=false;
if (music[2]) {
sequencer[2].get_sequence(sequencer_video.sequence());
sequencer[2].get_color(sequencer_video.grid_color());
}
} else if (key=='c'||key=='C') {
music[2]=true;
} else if (key=='v'||key=='V') {
music[2]=false;
sequencer[2].delete();
} else if (key=='b'||key=='B') {
if (music[2]) {
volume[2]=constrain(volume[2]-5, 0, 127);
if (camera[2]) {
sequencer_video.set_volume(volume[2]);
} else {
sequencer[2].set_volume(volume[2]);
}
}
} else if (key=='n'||key=='N') {
if (music[2]) {
volume[2]=constrain(volume[2]+5, 0, 127);
if (camera[2]) {
sequencer_video.set_volume(volume[2]);
} else {
sequencer[2].set_volume(volume[2]);
}
}
} else if (key=='o'||key=='O') {
tube=true;
} else if (key=='p'||key=='P') {
tube=false;
} else if (key==CODED) {
if (keyCode==LEFT) {
sequencer_video.threshold_down();
} else if (keyCode==RIGHT) {
sequencer_video.threshold_up();
} else if (keyCode==UP) {
rack.volume_up();
} else if (keyCode==DOWN) {
rack.volume_down();
}
}
}

void make_empty() {
for (int i=0; iint x= pos_x(i);
int y=margin;
sequencer[i]=new Sequencer(sc, grid_num, grid_size, interval, x, y);
}
}

int pos_x(int i) {
int x=margin+(grid_num*(grid_size+interval)+interval+margin)*i;
return x;
}

//tube rack
class Rack {
Capture video;
int tube_number=8;
int space_height;
float[][] colors;
SoundCipher sc;
int white=150;
float bright=1.5;
int volume=100;
int rack_width;
int rack_height;
int window_size;
int window_height;
int tube_height;
int tube_width;
int rack_x;
int rack_y;
int margin;

Rack(Capture _video, SoundCipher _sc, int _window_size,
int _window_height, int _space_height) {
video=_video;
window_size=_window_size;
window_height=_window_height;
space_height=_space_height;
sc=_sc;
rack_width=int(window_size*0.75);
rack_height=space_height/2;
tube_height=int(space_height*0.6);
tube_width=int(rack_width/(tube_number*3));
rack_x=(window_size-rack_width)/2;
rack_y=int(space_height*0.3);
margin=(rack_width-tube_number*tube_width)/(tube_number+1);
}

void play(int n) {
get_color();
draw_rack();
glow(n);
play_sounds(n);
}

void get_color() {
if (video.available()) {
video.read();
video.loadPixels();
colors=new float[tube_number][3];
float[] loc_x = {0.1,0.215,0.333,0.45,0.569,0.705,0.823,0.941};
for (int i = 0; i < tube_number; i++) {
// Begin loop for rows

// Where are we, pixel-wise?
int x = int(width*loc_x[i]) ;

int y = int(video.height*0.7);
int loc = x + y*video.width;

colors[i][0] = red(video.pixels[loc]);
colors[i][1]= green(video.pixels[loc]);
colors[i][2]= blue(video.pixels[loc]);
}
}
}

void draw_rack() {
if (colors!=null) {
pushMatrix();
translate(0, window_height-space_height);
noFill();
stroke(255);
strokeWeight(3);
rect(rack_x, rack_y,
rack_width, rack_height, rack_height/10);
pushMatrix();
translate(rack_x, rack_y);
for (int i = 0; i < tube_number; i++) {
pushMatrix();
translate(margin*(i+1)+tube_width*i, -rack_y*0.6);
if ((colors[i][0]+colors[i][1]+colors[i][2])/3noStroke();
fill(constrain(colors[i][0]*1.1,0,255),
constrain(colors[i][1]*1.1,0,255),
constrain(colors[i][2]*1.1,0,255));
rect(0, 0, tube_width, tube_height,tube_width/2);
} else {
noFill();
stroke(255);
strokeWeight(3);
rect(0, 0, tube_width, tube_height,tube_width/2);
}

popMatrix();
}
popMatrix();
popMatrix();
}
}

void glow(int n) {
n=n%tube_number;
if (colors!=null) {
pushMatrix();
translate(0, window_height-space_height);
if ((colors[n][0]+colors[n][1]+colors[n][2])/3pushMatrix();
translate(rack_x, rack_y);
pushMatrix();
translate(margin*(n+1)+tube_width*n, -rack_y*0.6);
fill(255, 255, 255, 40);
noStroke();
rect(0, 0, tube_width, tube_height,tube_width/2);
popMatrix();
popMatrix();
}
popMatrix();
}
}

void play_sounds(int n) {
n=n%tube_number;
if (colors!=null) {
float noteVal;
float[] noteVals=new float[0];
boolean play;
if ((colors[n%tube_number][0]+colors[n%tube_number][1]
+colors[n%tube_number][2])/3play=true;
} else {
play=false;
}
if (play) {
noteVal = noteVal(n);
noteVals=append(noteVals, noteVal);
}
sc.instrument(instrument(n));
println(instrument(n));
sc.playChord(noteVals, volume, 0.25);
}
}

int instrument(int n){
int h=int(hue(color(colors[n][0],colors[n][1],

colors[n][2]))%6);
if (h==0){return 38;}
else if (h==1){return 103;}
else if (h==2){return 112;}
else if (h==3){return 113;}
else if (h==4){return 117;}
else {return 124;}
}

int noteVal(int n){
int h=int(hue(color(colors[n][0],colors[n][1],
colors[n][2]))%6);
if (h==0){return 14;}
else if (h==1){return 20;}
else if (h==2){return 24;}
else if (h==3){return 60;}
else if (h==4){return 96;}
else {return 60;}
}

void volume_up() {
volume=constrain(volume+5, 0, 127);
}

void volume_down() {
volume=constrain(volume-5, 0, 127);
}
}

//step sequencer
class Sequencer {

boolean[] empty;
float[] rgb_list;
int grid_num;
int grid_size;
int interval;

SoundCipher sc;
boolean select=false;
int a, b;
int volume=0;
boolean on=true;
float red=0;
float green=0;
float blue=0;
int[] notes = {
96, 93, 91, 89, 86, 84, 81, 79, 77, 74, 72, 69, 67, 65, 62, 60
};
boolean[] sequence;

Sequencer(SoundCipher _sc,
int _grid_num, int _grid_size, int _interval, int _a, int _b) {
sc=_sc;
grid_num=_grid_num;
grid_size=_grid_size;
interval=_interval;

a=_a;
b=_b;

sequence=new boolean[grid_num*grid_num];
for (int i=0; isequence[i]=false;
}

empty=new boolean[grid_num*grid_num];
for (int i=0; iempty[i]=false;
}
}

void get_sequence(boolean[] _sequence) {
sequence=_sequence;
}

void get_color(float[] _rgb_list) {
rgb_list=_rgb_list;
red=rgb_list[0];
green=rgb_list[1];
blue=rgb_list[2];
}

void draw_grid() {
pushMatrix();
translate(a, b);
rectMode(CORNER);
int x=0;
int y=0;

//black background
noStroke();
fill(0);
rect(-interval, -interval, (grid_size+interval)*grid_num+interval*2,
(grid_size+interval)*grid_num+interval*2);

for (int i=0; ix=(grid_size+interval)*(i%grid_num);
y=(grid_size+interval)*(i/grid_num);
if (sequence[i]) {
fill(red, green, blue);
} else {
if (select){fill(100);}
else {fill(70);}
}
rect(x, y, grid_size, grid_size);
}

popMatrix();
}

void glow(int n) {
pushMatrix();
translate(a, b);

rectMode(CORNER);
for (int m=0; mif (sequence[m*grid_num+n]) {
for (int p=-1; p<2; p++) {
for (int q=-1; q<2; q++) {
if (n+p>=0&&n+p=0&&
m+qnoStroke();
fill(255, 255, 255, 20);
rect((n+p)*(interval+grid_size), (m+q)*(interval+grid_size),
grid_size, grid_size);
}
if (p==0&&q==0){
fill(red, green, blue);
rect(n*(interval+grid_size)-interval/2, m*(interval+grid_size)-interval/2,
grid_size+interval, grid_size+interval);
fill(255, 255, 255, 30);
rect(n*(interval+grid_size)-interval/2, m*(interval+grid_size)-interval/2,
grid_size+interval, grid_size+interval);
}
}
}
}
}
popMatrix();
}

void play_sounds(int n) {
float noteVal;
float[] noteVals=new float[0];

for (int i=0; i
// if the data text file has a "1" play note
if (sequence[i*grid_num+n]) {
noteVal = float(notes[i]);
noteVals=append(noteVals, noteVal);
}

}
sc.instrument(instrument());
sc.playChord(noteVals, volume, 0.25);
}

int instrument(){
int h=int(hue(color(red,green,blue))%8);
if (h==0){return 2;}
else if (h==1){return 3;}
else if (h==2){return 38;}
else if (h==3){return 46;}
else if (h==4){return 47;}
else if (h==5){return 55;}
else if (h==6){return 116;}
else {return 120;}
}

void select(boolean _select) {
select=_select;
}

void set_volume(int _volume) {
volume=constrain(_volume, 0, 127);
}

void delete() {
sequence=empty;
}
}
//step sequencer video
class Sequencer_video {
Capture video;
SoundCipher sc;
BlobDetection theBlobDetection;
boolean newFrame=false;
PImage img;
int a, b;
int grid_size;
int grid_num;
int interval;
int block_size;
int volume=0;
float[][] blob_color;
float[] avg_color=new float[3];
float[][] blobs;
float[][][] raw_color;
float threshold=0.5;
boolean draw_grid=false;
boolean[] sequence;
int[] notes = {
, 93, 91, 89, 86, 84, 81, 79, 77, 74, 72, 69, 67, 65, 62, 60
};
int radius=180;

Sequencer_video(Capture _video, SoundCipher _sc, int _grid_num,
int _grid_size,int _interval) {
colorMode(RGB, 255, 255, 255, 100);
video=_video;
sc=_sc;
grid_num=_grid_num;
grid_size=_grid_size;
interval=_interval;
block_size=(interval+grid_size)*grid_num;
sequence=new boolean[grid_num*grid_num];
img = new PImage(grid_num*(grid_size+interval)-interval,
grid_num*(grid_size+interval)-interval);
theBlobDetection = new BlobDetection(img.width, img.height);
theBlobDetection.setPosDiscrimination(true);
}

void threshold_up() {
threshold=constrain(threshold+0.02, 0, 1);
println(threshold);
}

void threshold_down() {
threshold=constrain(threshold-0.02, 0, 1);
println(threshold);
}

void position(int _a, int _b) {
a=_a;
b=_b;
}

void grid_on() {
draw_grid=true;
}

void grid_off(){
draw_grid=false;
}

void bd() {
if (video.available()) {
theBlobDetection.setThreshold(threshold);
video.read();
img.copy(video, (video.width-video.height)/2, 0, video.height,
video.height, 0, 0, img.width, img.height);
image(img, a, b, img.width+interval, img.height+interval);
fastblur(img, 2);
theBlobDetection.computeBlobs(img.pixels);
save_blob();
blob_color();
convert();
}
}
void bd_draw(int n) {
if (draw_grid) {
draw_grid();
glow(n);
play_sounds(n);
} else {
drawBlobsAndEdges(true, false);
}
}

void blob_color() {
float red=0;
float blue=0;
float green=0;
int total=theBlobDetection.getBlobNb ();
for (int n=0; n
//get the color


blob_color=new float[total][3];



int centerX = int(blobs[n][0]+0.5*blobs[n][2]);
int centerY = int(blobs[n][1]+0.5*blobs[n][3]);

color c = get(centerX+a, centerY+b);
blob_color[n][0] = red(c);

blob_color[n][1] = green(c);
blob_color[n][2] = blue(c);

red+=blob_color[n][0];
green+=blob_color[n][1];
blue+=blob_color[n][2];
}
avg_color[0]=constrain(red/total*1.2,0,255);
avg_color[1]=constrain(green/total*1.2,0,255);
avg_color[2]=constrain(blue/total*1.2,0,255);
}

void drawBlobsAndEdges(boolean drawBlobs, boolean drawEdges) {
pushMatrix();

translate(a, b);


noFill();



rectMode(CORNER);
Blob b;
EdgeVertex eA, eB;

for (int n=0; n{
b=theBlobDetection.getBlob(n);
if (b!=null)
{
// Edges
if (drawEdges)
{
strokeWeight(3);

stroke(0, 255, 0);
for (int m=0; m{
eA = b.getEdgeVertexA(m);
eB = b.getEdgeVertexB(m);
if (eA !=null && eB !=null)
line(

eA.x*block_size, eA.y*block_size,


eB.x*block_size, eB.y*block_size
);
}
}

// Blobs
if (dist(block_size/2,block_size/2,b.xMin*block_size,
b.yMin*block_size)&&drawBlobs&&b.w*block_size>5&&b.w*block_size<25&&
b.h*block_size>5&&b.h*block_size<25)
{
strokeWeight(3);
stroke(255, 0, 0);

rect(


b.xMin*block_size, b.yMin*block_size,



b.w*block_size, b.h*block_size
);
}
}
}
popMatrix();

}

void fastblur(PImage img, int radius)
{
if (radius<1) {
return;
}
int w=img.width;
int h=img.height;
int wm=w-1;
int hm=h-1;
int wh=w*h;
int div=radius+radius+1;
int r[]=new int[wh];
int g[]=new int[wh];
int b[]=new int[wh];
int rsum, gsum, bsum, x, y, i, p, p1, p2, yp, yi, yw;
int vmin[] = new int[max(w, h)];
int vmax[] = new int[max(w, h)];
int[] pix=img.pixels;
int dv[]=new int[256*div];
for (i=0; i<256*div; i++) {
dv[i]=(i/div);
}

yw=yi=0;

for (y=0; yrsum=gsum=bsum=0;
for (i=-radius; i<=radius; i++) {
p=pix[yi+min(wm, max(i, 0))];
rsum+=(p & 0xff0000)>>16;
gsum+=(p & 0x00ff00)>>8;
bsum+= p & 0x0000ff;
}
for (x=0; x
r[yi]=dv[rsum];
g[yi]=dv[gsum];
b[yi]=dv[bsum];

if (y==0) {
vmin[x]=min(x+radius+1, wm);
vmax[x]=max(x-radius, 0);
}
p1=pix[yw+vmin[x]];

p2=pix[yw+vmax[x]];

rsum+=((p1 & 0xff0000)-(p2 & 0xff0000))>>16;
gsum+=((p1 & 0x00ff00)-(p2 & 0x00ff00))>>8;


bsum+= (p1 & 0x0000ff)-(p2 & 0x0000ff);
yi++;
}
yw+=w;
}

for (x=0; xrsum=gsum=bsum=0;
yp=-radius*w;
for (i=-radius; i<=radius; i++) {
yi=max(0, yp)+x;
rsum+=r[yi];
gsum+=g[yi];
bsum+=b[yi];
yp+=w;
}
yi=x;
for (y=0; ypix[yi]=0xff000000 | (dv[rsum]<<16) | (dv[gsum]<<8) | dv[bsum];
if (x==0) {
vmin[y]=min(y+radius+1, hm)*w;
vmax[y]=max(y-radius, 0)*w;
}
p1=x+vmin[y];
p2=x+vmax[y];

rsum+=r[p1]-r[p2];
gsum+=g[p1]-g[p2];
bsum+=b[p1]-b[p2];

yi+=w;
}
}
}

void save_blob() {

Blob b;
blobs=new float[theBlobDetection.getBlobNb ()][4];
for (int n=0; n{
b=theBlobDetection.getBlob(n);
if (dist(block_size/2,block_size/2,b.xMin*block_size,
b.yMin*block_size)&&b.w*block_size>5&&b.w*block_size<25&&
b.h*block_size>5&&b.h*block_size<25){
blobs[n][0]=b.xMin*block_size;
blobs[n][1]=b.yMin*block_size;
blobs[n][2]=b.w*block_size;
blobs[n][3]=b.h*block_size;
}
}
}

void convert() {
int row, col, i;
for (int n=0; nsequence[n]=false;
}
for (int n=0; nrow=int(blobs[n][0]+blobs[n][2]*0.5)/grid_size;
col=int(blobs[n][1]+blobs[n][3]*0.5)/grid_size;
i=row+col*grid_num;
if (i>0&&isequence[i]=true;
}
}
}

void draw_grid() {
pushMatrix();
translate(a, b);
rectMode(CORNER);
int x=0;
int y=0;
noStroke();
fill(0);
rect(-interval,-interval,(grid_size+interval)*grid_num+interval*2,
(grid_size+interval)*grid_num+interval*2);
for (int i=0; ix=(grid_size+interval)*(i%grid_num);
y=(grid_size+interval)*(i/grid_num);

noStroke();

if (sequence[i]) {
fill(avg_color[0], avg_color[1], avg_color[2]);
} else {
fill(70);
}
rect(x, y, grid_size, grid_size);
}
popMatrix();
}

void glow(int n) {
pushMatrix();
translate(a, b);
rectMode(CORNER);
for (int m=0; mif (sequence[m*grid_num+n]) {
for (int p=-1; p<2; p++) {
for (int q=-1; q<2; q++) {
if (n+p>=0&&n+p=0&&
m+qnoStroke();

fill(255, 255, 255, 20);
rect((n+p)*(interval+grid_size), (m+q)*(interval+grid_size),

grid_size, grid_size);
}
if (p==0&&q==0){
fill(255, 255, 255, 30);
rect(n*(interval+grid_size), m*(interval+grid_size),
grid_size, grid_size);
}
}
}
}
}
popMatrix();
}
void play_sounds(int n) {
float noteVal;
float[] noteVals=new float[0];
for (int i=0; iif (sequence[i*grid_num+n]) {
noteVal = float(notes[i]);
noteVals=append(noteVals, noteVal);
}
}
sc.instrument(instrument());
sc.playChord(noteVals, volume, 0.25);
}

float[] grid_color() {
float[] color_return=new float[3];
arrayCopy(avg_color, color_return);
return color_return;
}

boolean[] sequence() {
boolean[] to_return=new boolean[sequence.length];
arrayCopy(sequence, to_return);
return to_return;
}


int instrument(){
int h=int(hue(color(avg_color[0],avg_color[1],
avg_color[2]))%8);
if (h==0){return 2;}
else if (h==1){return 3;}
else if (h==2){return 38;}
else if (h==3){return 46;}
else if (h==4){return 47;}
else if (h==5){return 55;}
else if (h==6){return 116;}
else {return 120;}
}

void set_volume(int _volume) {
volume=constrain(_volume, 0, 127);
}
}

Source: blob detection http://www.v3ga.net/processing/BlobDetection/

soundcipher http://explodingart.com/soundcipher/