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;
PVector maxpoint;

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];

  maxpoint = new PVector(0, 0, 0);
  calcDiffImage();
}

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

  calcDiffImage();
  drawStroke();

}

void drawStroke() {
  float x, y, len;
  x=maxpoint.x;
  y=maxpoint.y;
  stroke(0.0, 128);
  strokeWeight(random(2,5));
  len=random(30);
  line(x, y, x+random(len), y+random(len));
}

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.convert( OpenCV.GRAY );    // convert to gray
  opencv.absDiff();   // make the difference between the current image and the image in memory
  //opencv.invert();
  opencv.blur(OpenCV.GAUSSIAN, 10);
  //opencv.threshold(thresh);

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

  float maxval=-1;
  PImage temp=opencv.image();
  //print(temp.get(20,20));
  for (int i=0;i<imgw;i++)
    for (int j=0;j<imgh;j++)
      if (brightness(temp.get(i, j))>maxval) {
        maxval=brightness(temp.get(i, j));
        maxpoint.x=(float)i;
        maxpoint.y=(float)j;
      }

  //  // 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);
}