/* 

* have an envelope altering the tempo.
* lower notes change at a slower rate--half notes.
* higher frequencies can change on half or quarter notes... etc

* have different categories of blobs--always look for a bass blob around the size of area/2, which changes very infrequently.
* next version, trigger samples...

*/

import beads.*;
import hypermedia.video.*;

int N_CHANNELS = 3;

AudioContext ac;

OscillatorBank ob;
int NOSCCHANNELS = 10;
float[] ofreqs = new float[NOSCCHANNELS];
float[] ogains = new float[NOSCCHANNELS];

Envelope freqs[] = new Envelope[N_CHANNELS];
Gain gains[] = new Gain[N_CHANNELS];
WavePlayer wavePlayers[] = new WavePlayer[N_CHANNELS];

OpenCV opencv;

float[] tempos = {30f, 45f, 60f};


void setup() {
  size( 640, 480 );
  opencv = new OpenCV( this );
  //opencv.movie("/Users/Luke/Desktop/IMG_0069.mov", width, height );    // load movie file
  opencv.capture(width,height);
  frameRate(30);
  setupSound();
}

void setupSound() {
  ac = new AudioContext();
  for(int i=0; i<N_CHANNELS; i++) {
    freqs[i] = new Envelope(ac, 440);
    wavePlayers[i] = new WavePlayer(ac, freqs[i], Buffer.SINE);
    gains[i] = new Gain(ac, 1, 0.0);
    gains[i].addInput(wavePlayers[i]);
    ac.out.addInput(gains[i]);
  }

  /* setup the oscillator bank */
  ob = new OscillatorBank(ac, new SineBuffer().getDefault(), NOSCCHANNELS);
  for(int j=0; j<NOSCCHANNELS; j++) {
    ofreqs[j] = 440.0 + j*440.0;
    ogains[j] = 1.0/(float)NOSCCHANNELS;
  }
  ob.setGains(ogains);
  ob.setFrequencies(ofreqs);
  Gain obg = new Gain(ac, 1, 0f);
  obg.addInput(ob);
  ac.out.addInput(obg);

  ac.start();
}

 
void draw() {
  background(128);
  noStroke();
  opencv.read();  // read a new frame
  opencv.flip(OpenCV.FLIP_HORIZONTAL);
  opencv.blur(OpenCV.GAUSSIAN, 3);
  opencv.convert(opencv.GRAY);
  //opencv.invert();
  opencv.threshold(map(mouseX, 0, width, 0, 255));
  opencv.detect();
  image(opencv.image(), 0, 0);


  Blob[] blobs = opencv.blobs( 200, width*height/3, 10, false, OpenCV.MAX_VERTICES*4 );


  for(int b=0; b< min(blobs.length, N_CHANNELS); b++) {
    gains[b].getGainEnvelope().setValue(0.2);

//    pushMatrix();
//    translate(-blobs[b].centroid.x + width/2, -blobs[b].centroid.y + height/2);
//    drawing routines here...
//    popMatrix();

    /* draw the colored shape to the screen */
    colorMode(HSB, 100);
    fill( b * 30, 100, 100 );

    beginShape();
    for(int i=0; i<blobs[b].points.length; i++) {
      vertex(blobs[b].points[i].x, blobs[b].points[i].y);
    }
    endShape(CLOSE);


    /* determine the corrected frequency and change the tone */
//    if(frameCount % int(floor(frameRate / (tempos[b]/60.0))) == 0) {
      float uf = map(blobs[b].area, 100, (width*height)/4, 480, 60); // unadjusted frequency
      int mf = Pitch.forceToScale( (int)Pitch.ftom(uf) , Pitch.minor); // midi tone
      float ff = Pitch.mtof(mf);
      freqs[b].setValue(ff);
//    }
  }
  

    for(int x=min(blobs.length, N_CHANNELS); x<N_CHANNELS; x++ )
      gains[x].getGainEnvelope().setValue(0.0); // mute the unused channels
    
//    if(blobs.length > 0) {
//      /* set the oscillator bank */
//      ogains = getRadialCoefficients(blobs[0], NOSCCHANNELS);
//      ob.setGains(ogains);
//      float[] newfreqs = new float[NOSCCHANNELS];
//      for(int p=0; p<NOSCCHANNELS; p++) {
//        newfreqs[p] = freqs[0].getValue() + freqs[0].getValue() * p;
//      }
//      ob.setFrequencies(newfreqs);
//    }



}


float[] getRadialCoefficients(Blob blob, int bins) {
  float[] coefs = new float[bins];
  int[] ninbin = new int[bins];
  int i;
  for(i=0; i<bins; i++) ninbin[i] = 0;  
  for(i=0; i<blob.points.length; i++) {
    float theta = atan(((float)blob.points[i].y - (float)blob.centroid.y)/ ((float)blob.points[i].x - (float)blob.centroid.x)) + PI/2.0;
    float d = dist(blob.points[i].x, blob.points[i].y, blob.centroid.x, blob.centroid.y);
    int bin = min((int)floor((theta / PI) * bins), bins-1);
    coefs[bin] += d;
    ninbin[bin]++;
  }
  float s = 0.0;
  for(i=0; i<bins; i++) {
    if(ninbin[i] > 0)
      coefs[i] /= (float)ninbin[i]; // average each bin
    s += coefs[i]; // sum the bins
  }

  for(i=0; i<bins; i++) {
    coefs[i] /= s;
  }
  return coefs;
}