// by Che-Wei Wang <http://cwwang.com>
// 3/20/2007

//libraries/////////////////////////////////////////////////////////
//load openGL
import processing.opengl.*;
//load camera
import JMyron.*;
//load Ess
import krister.Ess.*;
int bufferSize;
int steps;
float limitDiff;
int numAverages=30;
float myDamp=.07f;
float maxLimit,minLimit;
FFT myFFT;
AudioInput myInput;
//load SMS
import sms.*;
float smsX, smsY, smsZ;
float smsXten=0;
float smsYten=0;
float smsZten=0;
float [] smsXdamp= new float[10];
float [] smsYdamp= new float[10];
float [] smsZdamp= new float[10];
//ocd
import damkjer.ocd.*;
Camera camera1;
////////////////////////////////////////////////////////////////////////

//load variables
PFont font,mFont;
PFont smFont;

////////////////////////////////////////////////////////////////////////
void setup() {
  size(screen.width, screen.height,OPENGL); //fullscreen
  noCursor();
  //cursor(CROSS);
  font=loadFont("Bauhaus93-200.vlw");
  mFont=loadFont("Bauhaus93-18.vlw");
  smFont=loadFont("HelveticaNeue-UltraLight-12.vlw");
  smooth();

  // start up Ess
  Ess.start(this);  
  // set up our AudioInput
  bufferSize=512;
  myInput=new AudioInput(bufferSize);
  // set up our FFT
  myFFT=new FFT(bufferSize);
  myFFT.equalizer(true);
  // set up our FFT normalization/dampening
  minLimit=.005;
  maxLimit=.05;
  myFFT.limits(minLimit,maxLimit);
  myFFT.damp(myDamp);
  myFFT.averages(numAverages);
  // get the number of bins per average 
  steps=bufferSize/numAverages;
  myInput.start();

  //blob
  // Capture 
  cam = new Capture(this, width, height, 150); 
  // BlobDetection 
  // img which will be sent to detection (a smaller copy of the cam frame); 
  img = new PImage(width/10,height/10);  
  theBlobDetection = new BlobDetection(img.width, img.height); 
  theBlobDetection.setPosDiscrimination(true); 
  theBlobDetection.setThreshold(0.2f); // will detect bright areas whose luminosity > 0.2f; 
  //ocd
  //Camera(parent,cameraX,cameraY,cameraZ,targetX,targetY,targetZ,upX,upY,upZ,fov,aspect,nearClip,farClip)
  camera1 = new Camera(this, width/2, height/2, 2000,width/2, height/2, -1500);

  //slider timer
  for (int i=0;i<n;i++) t[i]=.01f;

  //init random values
  for (int i=0;i<3;i++) cn[i]=random(1);
} 


/////////////////////////////////////////////////////////////////////////
void draw() {
  //ocd
  //lights();
  camera1.feed();
  //camera1.tumble(0, radians(smsY/100));
  //camera1.roll(radians(smsX/50));
  camera1.jump(width/2-smsX*10,height/2+smsY*10,1500-cn[3]*1500);

  //get SMS values
  int[] vals = Unimotion.getSMSArray();

  //dampen sms values
  smsXdamp=append(smsXdamp,vals[0]);
  smsXdamp=reverse(smsXdamp);
  smsXdamp=shorten(smsXdamp);
  smsXdamp=reverse(smsXdamp);

  smsYdamp=append(smsYdamp,vals[1]);
  smsYdamp=reverse(smsYdamp);
  smsYdamp=shorten(smsYdamp);
  smsYdamp=reverse(smsYdamp);

  smsZdamp=append(smsZdamp,vals[2]);
  smsZdamp=reverse(smsZdamp);
  smsZdamp=shorten(smsZdamp);
  smsZdamp=reverse(smsZdamp);

  for(int i=0;i<smsXdamp.length;i++){
    smsXten=smsXten+smsXdamp[i];  
    smsYten=smsYten+smsYdamp[i];  
    smsZten=smsZten+smsZdamp[i];  
  }

  smsX=smsXten/smsXdamp.length;
  smsY=smsYten/smsYdamp.length;
  smsZ=255-smsZten/smsZdamp.length;

  smsXten=0;
  smsYten=0;
  smsZten=0;

  //fft
  myFFT.damp(constrain(myDamp+cn[7],0.01,.80));

  //blob
  theBlobDetection.setThreshold(0.2f+cn[12]); // will detect bright areas whose luminosity > 0.2f; 

  //sliders
  background(0);

  int bleed =numAverages/3+int(cn[8]*20);
  float nUnits=numAverages-bleed;
  for (int i=-bleed+1;i<=nUnits+bleed-1;i++){
    for (int j=-bleed+1;j<=nUnits+bleed-1;j++){

      float x = width/nUnits*i;
      float y = width/nUnits*j;
      float z =-myFFT.averages[abs(i)]*4000+4000*cn[9]-myFFT.averages[abs(j)]*3000+3000*cn[9];
      dots(x,y,z,width/nUnits-10-cn[6]*200);
    }
  }

  if (newFrame){
    newFrame=false;
    //image(cam,0,0,width,height); 
    img.copy(cam, 0, 0, cam.width, cam.height, 0, 0, img.width, img.height); 
    //fastblur(img, 2); 
    theBlobDetection.computeBlobs(img.pixels); 
    if (myFFT.spectrum[int(127-cn[10]*127)]>.22+cn[11]){
      drawBlobsAndEdges(false,true); 
    }
  }


  //beatCounter();
  //beater();
  timer();
}

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

void dots(float x, float y, float z, float s){
  //color c =cam.pixels[2];
  //rotate background dots according to sms x axis tilt
  pushMatrix();
  translate(width/2,height/4);
  // rotate(radians(90*smsX/(360)));
  //draw dots
  pushMatrix();
  translate(-width/2,-height/2);


  //rotateX(radians(z/10));
  translate(x,y,z);

  fill(abs(cn[0])*255*abs(x)/width,abs(cn[1])*255*abs(x)/height,abs(cn[2])*255*abs(y)/height,255-abs(z)/(3+cn[4]*10));
  stroke(abs(cn[0])*255*abs(x)/width,abs(cn[1])*255*abs(x)/height,abs(cn[2])*255*abs(y)/height,abs(z)/(3+cn[4]*10));
  strokeWeight(.4);


  rectMode(CENTER);

  rect (0,0,s,s) ;

  //box(s,s,z);
  popMatrix();
  popMatrix();
}

////////////////////////////////////////////////////////////////////////////////////
public void audioInputData(AudioInput theInput) {
  myFFT.getSpectrum(myInput);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////