// Pierre MARZIN
// Trying to learn Processing... First project, much inspired by "Mycelium" by Scloopy?
// http://marzinp.free.fr/applets

//GUI and Drag 'n drop: great libraries ! Thanks to Andreas Schlegel (http://www.sojamo.de/libraries/index.html)
import controlP5.*;
import sojamo.drop.*;
//import processing.opengl.*;
//GUI variables
public SDrop drop;
public String mUrl;
public ControlP5 controlP5;
public ControlWindow controlWindow;
public Textlabel weightlabel;
public Textlabel seuilmaxlabel;
public Textlabel seuilminlabel;
public Textlabel modeCouleurLabel;
public Textlabel strokemaxlengthlabel;
public Textlabel pInfo;
public Textlabel rangelabel;
public Textlabel radiuslabel;
public Textlabel devMaxlabel;
public Textlabel maxSpeedlabel;
public RadioButton radio ;
public RadioButton shapeRadio ;
public Button strokeButton;
public Button fillButton;
public Button onOffButton;
public Button restartButton;
public Button limitButton;
public Slider s1;
public Slider s2;
public Slider s3;
public Slider s4;
public Slider s5;
public ColorPicker cp;
//Feuille feuille;
String monInfo;
PFont f;
PImage source;      // Source image
//for each "worm", variables: position
//position
PVector [] p;
//speed
PVector [] v;
//aimed direction
PVector vise=new PVector();
//"seeking" vector
PVector deviation=new PVector();
//worm's length
int [] longueurVer;
//like pixels[], to keep track of how many times a point is reached by a worm
int [] buffer;
boolean[] typeVer;
int [] limiteDown;
float [] seekerWeight;
int[] variationspeed;
//number of worms at the beginning
int nbePoints;
//width and length of the drawing area
int larg;
int haut;
int largI;
int hautI;
//brightness of the destination pixel
float briMax;
//minimum brightness threshold
public int seuilBrillanceMini;
//maximum brightness threshold
public int seuilBrillanceMaxi;
//location of the tested point in pixels[]
int locTest;
//around a point (worms position), how many pixels will we look at...
int amplitudeTest;
//constrain the aimed direction vector into an r radius circle
int inertia;
//constrain the acceleration vector into a devMax radius circle
float devMax;
//constrain the speed vector into a maxSpeed radius circle
int maxSpeed;
//not used:random factor
int hasard;
//stroke's weight (slider) or radius of ellipse used for drawing
public float myweight;
//stroke's maximum length
public int maxstrokelength;
//draw or not (button onOffButton)
public boolean dessine;
//different drawing options
public int modeCouleur;
public int forme;
//fill color
int macouleur;
boolean limite;

//setup only sets up what won't change:GUI and window params
//I use initialiser() to set up what has to be initialised
//when you hit "RestartButton" and dessin() to set the drawing parameters
void setup() {
  frameRate(100);
  larg=largI=1200;
  haut=hautI=850;
  //size(1200, 1000,OPENGL);
 size(1200, 850,P3D);
  limite=false;
  drop = new SDrop(this);
  f = loadFont("ArialUnicodeMS-12.vlw");
  source = loadImage("tiger.jpg");
  if (hautI*source.width>largI*source.height) {
    larg=largI;
    haut=larg*source.height/source.width;
  }
  else {
    haut=hautI;
    larg=haut*source.width/source.height;
  }
  source.resize(larg, haut);
  source.loadPixels();
  //info text
  textFont(f);
  //fill(0);
  //GUI
  controlP5 = new ControlP5(this);
  controlP5.setControlFont(new ControlFont(createFont("ArialUnicodeMS", 10, true), 12));
  controlWindow =controlP5.addControlWindow("controlP5CW",10,10,largI,160).setBackground(128).hideCoordinates();

  // add radioButton for drawing modes
  radio = controlP5.addRadioButton("radioButton", 120, 125)
  .moveTo(controlWindow)
  .setColorForeground(color(120))
  .setColorLabel(color(0))
  .setItemsPerRow(4)
  .setSpacingColumn(100)
  .addItem("Normal", 1)
  .addItem("Pic Colors", 2)
  .addItem("Growing", 3)
  .activate("Normal");
// add radioButton for drawing shape
  shapeRadio = controlP5.addRadioButton("shapeRadio", 450, 95)
  .moveTo(controlWindow)
  .setColorForeground(color(120))
  .setColorLabel(color(0))
  .setItemsPerRow(4)
  .setSpacingColumn(100)
  .addItem("Circle", 1)
  .addItem("Square", 2)
  //shapeRadio.addItem("Triangle", 3);
  .activate("Circle");
  //add switch button for limit to threshold
  limitButton= controlP5.addButton("short_strokes",0, 450,120, 110, 15)
  .moveTo(controlWindow)  
  //limitButton.setLabel("Kill strokes");
  .setSwitch(true);
  //add onOffButton,sound and RestartButton Buttons
  onOffButton=controlP5.addButton("onOff", 0, 1050, 120, 50, 15)
  .setSwitch(true)
  .moveTo(controlWindow);
  //add strokeButton and fillButton Buttons to control if the seeker draws strokes, fills or both
  strokeButton=controlP5.addButton("Stroke", 0, 600, 120, 60, 15)
  .setSwitch(true)
  .moveTo(controlWindow);
   
  fillButton=controlP5.addButton("Fill", 0, 700, 120, 50, 15)
  .setSwitch(true)
  .setOn()
  .moveTo(controlWindow);
 
  restartButton=controlP5.addButton("Restart", 0, 900, 120, 70, 15)
  .moveTo(controlWindow);
  //add colorpicker cp
  cp = controlP5.addColorPicker("picker",10,10,200,16)
          .setColorValue(color(255,255,255, 255))
          .moveTo(controlWindow);

  //add slider for maximum stroke length
  controlP5.addSlider("maxstrokelength", 1, 600, 400, 350, 40, 300, 15).moveTo(controlWindow);
  s1 = (Slider)controlP5.controller("maxstrokelength")
  .setLabel("Max stroke length");
  strokemaxlengthlabel=new Textlabel( controlP5, "Max stroke length", 300, 40, 10, 10);
 // strokemaxlengthlabel.moveTo(controlWindow);
  strokemaxlengthlabel.setColorValue(0);
  
  // add horizontal sliders and labels for stroke, threshold and drawing modes
  controlP5.addSlider("myweight", 1, 50, 3, 350, 10, 100, 15).setWindow(controlWindow);
  s2 = (Slider)controlP5.controller("myweight")
  .setLabel("Stroke width:");
  s2.setDecimalPrecision(0);
  //add slider for inertia
  controlP5.addSlider("inertia", 1, 20, 8, 800, 40, 200, 15).moveTo(controlWindow);
  s3 = (Slider)controlP5.controller("inertia");
  s3.setLabel("Inertia:");
  //add slider for devMax (acceleration limiter)
  controlP5.addSlider("devMax", 0, 5, 2.2, 800, 60, 200, 15).moveTo(controlWindow);
  s4 = (Slider)controlP5.controller("devMax");
  s4.setLabel("Acceleration:");
  //add slider for maxSpeed
  controlP5.addSlider("maxSpeed", 0, 100, 40, 800, 80, 200, 15).moveTo(controlWindow);
  s5 = (Slider)controlP5.controller("maxSpeed");
  s5.setLabel("Max speed:");
  //s3.setDecimalPrecision(0);
  s5.setSliderMode(Slider.FIX);
  maxSpeedlabel=new Textlabel( controlP5, "Max speed:", 800, 80, 10, 10);
  maxSpeedlabel.setColorValue(0);
  //add Range control for value thresholds
  Range range=controlP5.addRange("rangeController", 0, 255, 0, 128, 100, 95, 200, 15).moveTo(controlWindow)
  .setDecimalPrecision(0)
  .setCaptionLabel("Value range")
  .setSliderMode(Slider.FIX);
  seuilBrillanceMaxi=128;
  seuilBrillanceMini=0;
  seuilmaxlabel = new Textlabel( controlP5, "light", 350, 90, 10, 10);
  seuilmaxlabel.setColorValue(0);
  seuilminlabel = new Textlabel(controlP5, "dark", 10, 90, 10, 10);
  seuilminlabel.setColorValue(0);
  modeCouleurLabel = new Textlabel(controlP5, "Drawing modes:", 10, 120, 10, 10);
  modeCouleurLabel.setColorValue(0);
  pInfo=new Textlabel( controlP5, "You can drag and drop a picture (not too big!) from your web or file browser...", 600, 10, 10, 10);
  pInfo.setColorValue(0);
  
  rangelabel=new Textlabel(controlP5, "Range", 180, 77, 10, 10);
  rangelabel.setColorValue(0);
  //frameRate(15);

  initialiser();
}

//launched after setup and any time you hit the RestarButton button
void initialiser() { 

  background(255);
  nbePoints=6;
  
//  strokemaxlengthlabel.draw(this);
//  weightlabel.draw(this);
//  seuilmaxlabel.draw(this);
//  seuilminlabel.draw(this);
//  modeCouleurLabel.draw(this);
//  rangelabel.draw(this);
//  radiuslabel.draw(this);
//  devMaxlabel.draw(this);
//  maxSpeedlabel.draw(this);
//  pInfo.draw(this);

  onOffButton.setOn();
  buffer=new int[haut*larg];
  smooth();
  dessine=true;
  p=new PVector[nbePoints];
  v=new PVector[nbePoints];
  longueurVer=new int[nbePoints] ;
  seekerWeight=new float[nbePoints];
  variationspeed=new int[nbePoints];
  limiteDown=new int[nbePoints] ;
  typeVer=new boolean[nbePoints];
  maxstrokelength=int(s1.value());
  inertia=int(s3.value());
  myweight=s2.value();
  devMax=s4.value();
  maxSpeed=int(s5.value());
  forme=int(shapeRadio.value());
  for (int i=0;i<nbePoints;i++) {
    v[i]=new PVector(3-random(6), 3-random(6));
    longueurVer[i]=0;
    limiteDown[i]=0;
    seekerWeight[i]=myweight;
    variationspeed[i]=5+int(random(200));
    if (random(4)<2) {
      typeVer[i]=true;
    }
    else {
      typeVer[i]=false;
    }

    p[i]=new PVector(random(larg), random(haut));
    while ( (brightness (source.pixels[floor (p[i].x)+floor(p[i].y)*larg])>seuilBrillanceMaxi)||(brightness(source.pixels[floor(p[i].x)+floor(p[i].y)*larg])<seuilBrillanceMini))
    {
      p[i].x=int(random(larg));
      p[i].y=int(random(haut));
    }
  }

}

void draw() {

  defineLights();
  
  if (mUrl!=null) {
    source=null;
    source=loadImage(mUrl);
    if (hautI*source.width>largI*source.height) {
      larg=largI;
      haut=larg*source.height/source.width;
    }
    else {
      haut=hautI;
      larg=haut*source.width/source.height;
    }
    //  println(source.width+" "+source.height);
    

    source.resize(larg, haut);
    source.loadPixels();
    initialiser();
    mUrl=null;
  }
  if (dessine) {
    dessin();
  }
  controlP5.draw();
}
void dessin() {

  amplitudeTest=2;
  vise.x=0;
  vise.y=0;
  hasard=0;
  locTest=0;
  //pour chaque mobile
  for (int t=0;t<p.length;t++) {//X.length
    //on va tester les pixels autour du mobile p[t] en direction de la vitesse du mobile
    //calcul du barycentre des points testés pondérés de la brillance (vise.x, vise.y)
    vise.x=0;
    vise.y=0;
    deviation.x=0;
    deviation.y=0;
    for (int i=-amplitudeTest+floor(deviation.x);i<amplitudeTest+1+floor(deviation.x);i++) {///rdessin
      for (int j=-amplitudeTest+floor(deviation.y);j<amplitudeTest+floor(deviation.y)+1;j++) {
        locTest=floor(p[t].x)+i+(floor(p[t].y)+j)*larg; 
        //on vérifie que le point fait partie de l'image
        if ((p[t].x+i>0)&& (p[t].y+j>0)&&(p[t].x+i<larg-1)&&(p[t].y+j<haut-1)) {
          vise.x+=i*(255-brightness(source.pixels[locTest]));
          vise.y+=j*(255-brightness(source.pixels[locTest]));
        }
      }
    }
    //on contraint vise.x et vise.y dans un cercle de rayon r
    //qd r augmente, les mobiles tournent plus serrés

    if ((p[t].x>0)&& (p[t].y>0)&&(p[t].x<larg-1)&&(p[t].y<haut-1)) {
      //buffer est une copie vide de l'image. on l'augmente pour chaque point teste
      buffer[floor(p[t].x)+floor(p[t].y)*larg]++;
    }
    //si on est passé plus de 10 fois on demenage le point
    if (buffer[floor(p[t].x)+floor(p[t].y)*larg]>10) {
      //source.pixels[floor(p[t].x)+floor(p[t].y)*larg]=0;
      deplacePoint(t);
    } 

    //on compte les segments de chaque ver 
    longueurVer[t]++;
    //si c'est trop long on déménage
    if (longueurVer[t]>maxstrokelength) {       
      longueurVer[t]=0;
      deplacePoint(t);
    }

    //coeur du comportement de seeker:
    vise.normalize();
    vise.mult(100/inertia);          
    v[t].add(new PVector(vise.x, vise.y)); //+hasard-random(2*hasard)  
    deviation=v[t].get();
    deviation.normalize();
    deviation.mult(devMax);
    v[t].normalize();
    v[t].mult(maxSpeed);     
    p[t].x=p[t].x+deviation.x;
    p[t].y=p[t].y+deviation.y;
    // if(t==1)(inertia);
    //noLoop();
    if (((p[t].x>0)&& (p[t].y>0)&&(p[t].x<larg-1)&&(p[t].y<haut-1))&&((limite)&&((brightness(source.pixels[floor(p[t].x)+floor(p[t].y)*larg])<=seuilBrillanceMaxi)&&(brightness(source.pixels[floor(p[t].x)+floor(p[t].y)*larg])>=seuilBrillanceMini))))
    {
      if (limiteDown[t]!=0) {
        limiteDown[t]-=2;
      }
    }
    if (((p[t].x<0)|| (p[t].y<0)||(p[t].x>larg-1)||(p[t].y>haut-1))||((limite)&&((brightness(source.pixels[floor(p[t].x)+floor(p[t].y)*larg])>seuilBrillanceMaxi)||(brightness(source.pixels[floor(p[t].x)+floor(p[t].y)*larg])<seuilBrillanceMini))))
    {
      if (limiteDown[t]==0) {
        limiteDown[t]=2;
      }
      limiteDown[t]+=2;//print(limiteDown[t]+" ");
      if (limiteDown[t]>=52/myweight) {
        limiteDown[t]=0;
        deplacePoint(t);
      }
    }
    if ((p[t].x<0)|| (p[t].y<0)||(p[t].x>larg-1)||(p[t].y>haut-1)||((deviation.x==0)&&(deviation.y==0)))//||
    {
      limiteDown[t]=0;
      deplacePoint(t);
    }
    else {
      briMax=brightness(source.pixels[floor(p[t].x)+floor(p[t].y)*larg]);
    }


    if (modeCouleur==1) {
      //macouleur=0;
    }
    if (modeCouleur==2) {
      macouleur=source.pixels[floor(p[t].x)+floor(p[t].y)*larg];
    }
    if (modeCouleur==3) {            
      float vert=200;//50+(100*(1-sin(longueurVer[t]/200)));
      float rouge=50*(1-cos(longueurVer[t]/300));
      float bleu=100*(1-sin(longueurVer[t]/100));//100-vert-rouge;

      macouleur=color(rouge, vert, bleu);
    }

    //control the type of drawing, with or without strokes and/or fill
    strokeWeight(1);
    strokeCap(ROUND);
    if (strokeButton.isOn()) {
      //noFill();
      stroke(macouleur, -limiteDown[t]+100/seekerWeight[t]);
    }
    else noStroke();
    if (fillButton.isOn()) {
      fill(macouleur);//, -limiteDown[t]+100/seekerWeight[t]);
    }
    else noFill();
    float dia=seekerWeight[t]*(1-sin(float(longueurVer[t])/variationspeed[t]));
    
    if(forme==1){
      pushMatrix();
      translate(p[t].x,p[t].y);
      sphereDetail(6);
      sphere(dia);
      //ellipse(p[t].x,p[t].y,dia,dia);
      popMatrix();
    }else {
      pushMatrix();
      translate(p[t].x, p[t].y);
      //rotate(float(longueurVer[t])/100);
      rotateX(float(longueurVer[t])/100);
      rotateY(float(longueurVer[t])/100);
      box(dia);
      //rect(0, 0,dia, dia);    
      popMatrix();
    }

    //uncomment to draw withe leaf.png image 
    //      float vartaillefeuille=10+random(10);
    //      feuille=new Feuille(p[t].x,p[t].y,8*dia,8*dia,color(random(50),200,random(50)),-limiteDown[t]+52/seekerWeight[t],PI/4-random(PI/2));
    //      feuille.display();

    //important: on cree un nouveau vers de temps en temps (on pourrait tester selon la brilance de la zone...)
    if (random(1)>1-(255-briMax)/80000) {//0.997
      p=(PVector[])append(p, new PVector(p[t].x, p[t].y));
      v=(PVector[])append(v, new PVector(v[t].x*(5+random(6)), v[t].x*(5+random(6))));

      //uncomment to draw withe leaf.png image when a new seeker is created
      //      vartaillefeuille=random(15);
      //      feuille=new Feuille(p[t].x,p[t].y,vartaillefeuille,(2+random(1))*vartaillefeuille,color(random(50),200,random(50)),-limiteDown[t]+452/seekerWeight[t],PI/4-random(PI/2));
      //      feuille.display();

      longueurVer=append(longueurVer, 0);
      seekerWeight=append(seekerWeight, myweight);
      limiteDown=append(limiteDown, 0);
      variationspeed=append(variationspeed, int(5+random(200)));
    }
  }
}
void deplacePoint(int t) {
  p[t].x=int(random(larg));
  p[t].y=int(random(haut));
  while ( (brightness (source.pixels[floor (p[t].x)+floor(p[t].y)*larg])>seuilBrillanceMaxi)||(brightness(source.pixels[floor(p[t].x)+floor(p[t].y)*larg])<seuilBrillanceMini))
  {
    p[t].x=int(random(larg));
    p[t].y=int(random(haut));
  }
}
void dropEvent(DropEvent theDropEvent) {

  // si le drop est une image jpg
  // on charge l'adresse dans  mUrl.
  if (theDropEvent.isFile()) {
    mUrl = theDropEvent.filePath();
  }
  if (theDropEvent.isURL()==true) {
    if (theDropEvent.url().trim().substring(theDropEvent.url().trim().length()-3, theDropEvent.url().trim().length())=="jpg") {
      mUrl = theDropEvent.url().trim();
    }
  }
}
public void rangeController(ControlEvent theControlEvent) {
  if (theControlEvent.isFrom("rangeController")) {
    // min and max values are stored in an array.
    // access this array with controller().arrayValue().
    // min is at index 0, max is at index 1.
    seuilBrillanceMini = int(theControlEvent.getController().getArrayValue(0));
    seuilBrillanceMaxi = int(theControlEvent.getController().getArrayValue(1));
  }
}

public void onOff() {
  if (dessine) {
    dessine=false;
  }
  else {
    dessine=true;
  }
}
public void short_strokes() {
  limite=!limite;
}

public void Restart() {

  initialiser();
}

// color information from ColorPicker 'picker' are forwarded to the picker(int) function
public void picker(int col) {
  macouleur=col;
}
void controlEvent(ControlEvent theEvent) { 
  if (theEvent.isFrom(radio)) {
    modeCouleur = int(theEvent.group().value());
  }
  if (theEvent.isFrom(shapeRadio)) {
    forme = int(theEvent.group().value());
  }
}
  public void defineLights() {
  // Orange point light on the right
  pointLight(250, 100, 0,   // Color
             200, -150, 0); // Position

  // Blue directional light from the left
  directionalLight(0, 100, 255, // Color
                   1, 0, .5);    // The x-, y-, z-axis direction

  // Yellow spotlight from the front
  spotLight(255, 255, 200,  // Color
            400, 240, 800,     // Position
            0, 0, -1.5,  // Direction
            PI / 2, 2);     // Angle, concentration
}