import hypermedia.video.*;
import java.awt.*;


OpenCV opencv;
import controlP5.*;    

PImage img;

ControlP5 controlP5;

static float imgw = 800;
static float imgh = 600;

PImage diffImg;
PImage current;

static int MAXPOINTS = 10;

PVector [] mypoints;

float center=64.0;
float width=64.0;
float thresh=16.0;
int count=0;

Rectangle biggest;

void setup() {
  size(1600, 800);
  opencv = new OpenCV( this );

  img = loadImage("urs_firscher_060_push.jpg"); // Load demo image
  opencv.loadImage("urs_firscher_060_push.jpg", (int)imgw, (int)imgh);
  opencv.convert( OpenCV.GRAY );    // convert to gray

  background(255);

  controlP5 = new ControlP5(this);

  controlP5.addSlider("center")
    .setPosition(imgw-160, imgh+20)
      .setRange(0, 255)
        .setValue(center)
          .setCaptionLabel("center");
  controlP5.addSlider("width")
    .setPosition(imgw-160, imgh+40)
      .setRange(0, 255)
        .setValue(width)
          .setCaptionLabel("width");
  controlP5.addSlider("thresh")
    .setPosition(imgw-160, imgh+60)
      .setRange(0, 255)
        .setValue(thresh)
          .setCaptionLabel("thresh");

  mypoints = new PVector[MAXPOINTS];

  calcDiffImage();
}

void draw() {
  //createStrokeGroup();
  searchInRectangle(biggest.x, biggest.y, biggest.width, biggest.height);
  drawStrokeGroup();

  //noFill();
  //rect(biggest.x, biggest.y, biggest.width, biggest.height);

  count++;
  if (count==10) {
    calcDiffImage();
    count=0;
  }
}

PVector findPoint() {
  return findPoint(0, 255);
};

PVector findPoint(float center, float width) {
  color c;
  float ix, iy;
  float x, y;
  float bright;
  boolean done=false;
  // weighted sample towards darker pixels
  do {
    ix=random(0, img.width);
    iy=random(0, img.height);
    c = img.get((int)ix, (int)iy);
    bright = brightness(c);
    if ((bright>center-width/2) && (bright<=center+width/2)) done=true;
  } 
  while ( !done);
  //println(ix);
  //println(iy);
  return new PVector(ix, iy);
}

PVector findPoint(float center, float width, float x, float y, float w, float h) {
  color c;
  float ix, iy; 
  float bright;
  boolean done=false;
  do {
    ix=x+random(w);
    iy=y+random(h);
    //c = img.get((int)ix, (int)iy);
   // bright = brightness(c);
    //if ((bright>center-width/2) && (bright<=center+width/2) && (random (width)<(float)width/2)) done=true;
    //if(bright<thresh)done=true;
    done=true;
  } 
  while ( !done);
  //println(ix);
  //println(iy);
  return new PVector(ix, iy);
}

void searchInRectangle(float x, float y, float w, float h) {
  float sf = (float)img.width/(float)imgw;
  for (int i=0;i<MAXPOINTS;i++) {
    PVector result = findPoint(center, width, x*sf, y*sf, w*sf, h*sf);
    //println(result.x);
    //println(result.y);
    mypoints[i] = new PVector(result.x, result.y);
  }
}

void createStrokeGroup() {
  for (int i=0;i<MAXPOINTS;i++) {
    PVector result = findPoint(center, width);
    //println(result.x);
    //println(result.y);
    mypoints[i] = new PVector(result.x, result.y);
  }
}

void drawStrokeGroup() {
  float sf = (float)imgw/(float)img.width;
  for (int i=0;i<MAXPOINTS;i++) {
    color c = img.get((int)mypoints[i].x, (int)mypoints[i].y);
    fill(c);
    stroke(c);
    strokeWeight(random(2, 5));
    //    float x=mypoints[i].x*(float)imgw/(float)img.width;
    //    float y=mypoints[i].y*(float)imgh/(float)img.height;
    float x=mypoints[i].x*sf;
    float y=mypoints[i].y*sf;

    //line(10+x, 10+y, 10+x+random(-10, 10), 10+y+random(-10, 10));
    line(x, y, x,y);//x+random(-10, 10), y+random(-10, 10));
  }
}

void calcDiffImage() {
  //  color cA, cB,colordiff;
  //  float diff;
  //  for(int x=0;x<imgw;x++)
  //    for(int y=0;y<imgh;y++) {
  //      int ix,iy;
  //      
  //      ix = (int)(x*(float)img.width/(float)imgw);
  //      iy = (int)(y*(float)img.height/(float)imgh);
  //      colordiff = img.get(ix, iy)-get(x,y);
  //      diff = mag(red(colordiff),green(colordiff),blue(colordiff));
  //      
  ////      diffImg.set(x,y,colordiff);
  //      diffImg.set(x,y, (int)color(diff));
  //    }
  //  image(diffImg, imgw, 0);
  opencv.restore();
  opencv.remember();
  current = get(0, 0, (int)imgw, (int)imgh); // grab current drawing state
  opencv.copy(current);
  opencv.absDiff();   // make the difference between the current image and the image in memory
  opencv.convert( OpenCV.GRAY );    // convert to gray
  //opencv.invert();
  opencv.threshold(thresh);

  image( opencv.image(OpenCV.MEMORY), imgw, 0, 320, 240);   // GRAY image  
  image( opencv.image(), imgw, 240, 320, 240  );



  // working with blobs
  Blob[] blobs = opencv.blobs( 100, (int)(imgw*imgh*0.25), 5, true );

  noFill();

  pushMatrix();
  translate(imgw, 480);
  scale(0.4);
  fill(255);
  rect(0, 0, imgw, imgh);
  boolean found=false;;
  for ( int i=0; i<blobs.length; i++ ) {
    if (!found) {
      biggest = blobs[i].rectangle;
      found=true;
    }
    Rectangle bounding_rect	= blobs[i].rectangle;
    float area = blobs[i].area;
    float circumference = blobs[i].length;
    Point centroid = blobs[i].centroid;
    Point[] points = blobs[i].points;

    // rectangle
    noFill();
    stroke( blobs[i].isHole ? 128 : 64 );
    rect( bounding_rect.x, bounding_rect.y, bounding_rect.width, bounding_rect.height );


    // centroid
//    stroke(0, 0, 255);
//    line( centroid.x-5, centroid.y, centroid.x+5, centroid.y );
//    line( centroid.x, centroid.y-5, centroid.x, centroid.y+5 );
//    noStroke();
//    fill(0, 0, 255);
//    text( area, centroid.x+5, centroid.y+5 );


    fill(255, 0, 255, 64);
    stroke(255, 0, 255);
    if ( points.length>0 ) {
      beginShape();
      for ( int j=0; j<points.length; j++ ) {
        vertex( points[j].x, points[j].y );
      }
      endShape(CLOSE);
    }

    noStroke();
    fill(255, 0, 255);
    text( circumference, centroid.x+5, centroid.y+15 );
  }
  popMatrix();
  noFill();
  stroke(255,0,255);
  rect( imgw+biggest.x*0.4, 240+biggest.y*0.4, biggest.width*0.4, biggest.height*0.4);

}