boolean init;
PImage[] img;
int imgNr;

float hairDirNoiseScale=0.005;
int bushNr;
boolean drawing;

void setup() {
  size(800,800,P3D); //smooth(); 1658,1658
  background(0,0,0);
  init=true;
  bushNr=0;
  imgNr=0;
  drawing = true;
  img = new PImage[5];
  img[0] = loadImage("vangogh.jpg");
  img[1] = loadImage("vermeer.jpg");
  img[2] = loadImage("monalisa.jpg");
  img[3] = loadImage("warhol.jpg");
  img[4] = loadImage("giger.jpg");
  initBush();
}

void draw() {
  if (drawing) {

    for (int j=0;j<250;j++) {
      if (bushNr<nr_bush) {
        bush[bushNr].rotateLikeNeighbour();
        bush[bushNr].setNewRotation();
        bush[bushNr].drawMe();
      }
      bushNr++;
    }

    if (bushNr>=nr_bush) {
      bushNr=0;      
      drawing = false;
    }
  }
  //saveFrame("c:/cd_cover_0.005_####.tga");
}

void mousePressed() {
  drawing = true;
  bushNr=0;
  imgNr++;
  if (imgNr==img.length) imgNr=0;
  initBush();
  //println(imgNr);
}

/*
void keyPressed() {
  if (key=='r') setup();
}
*/

////////////////////////////////////////////////////////////////////////
////////////////////////////// Bush class //////////////////////////////

int nr_col=400, nr_row=400, nr_bush;  // number of rows/columns
float colWid, rowHei;                 // column width/row height
float baseLen=12, randLen=12;         // basic bush length plus random length
int nrHairPerBush=8;
float randDir=radians(45);
Bush[] bush; 

void initBush() {
  nr_bush=nr_col*nr_row;
  colWid=width/(float)nr_col; 
  rowHei=height/(float)nr_row;
  bush=new Bush[nr_bush];

  for (int x=0;x<nr_col;x++) { 
    for (int y=0;y<nr_row;y++) {
      int i=y*nr_col+x;
      //    float p=noise(20*x/(float)nr_col,10*y/(float)nr_row,millis()*0.01);

      int img_x=int(img[imgNr].width*x/(float)nr_col);
      int img_y=int(img[imgNr].height*y/(float)nr_row);
      int pixNum=img_y*img[imgNr].width+img_x;

      bush[i]=new Bush(x,y,img[imgNr].pixels[pixNum]);
    } 
  }
  //println();
}

void updateBush() {
  for (int i=0;i<nr_bush;i++) {
    bush[i].rotateLikeNeighbour();
    bush[i].setNewRotation();
    bush[i].drawMe();
  }
}

class Bush {
  //  boolean white; 
  color c;

  int col, row;
  float x, y;
  float len, lenMin=8, lenMax=20;
  float dir, rot;  
  Hair[] hair; 
  int nrHair;

  Bush(int col, int row, int _c) {
    this.col=col; 
    this.row=row;
    x=colToWidth(col)+random(-colWid/2.0,colWid/2.0); 
    y=rowToHeight(row)+random(-rowHei/2.0,rowHei/2.0);
    c=_c;
    len=baseLen+random(randLen);
    //    dir=TWO_PI*noise(col*0.02,row*0.02)*noise(col*0.2,row*0.2)-PI; rot=0;
    dir=TWO_PI*noise(col*hairDirNoiseScale,row*hairDirNoiseScale); 
    rot=0;

    nrHair=nrHairPerBush; 
    hair=new Hair[nrHair];
    for (int i=0;i<nrHair;i++) {
      float xo=random(-colWid/2.0,colWid/2.0);
      float yo=random(-rowHei/2.0,rowHei/2.0);
      float p=random(1); 
      color hc=c;

      if (p<0.9) {
        hc=c;
      } 
      else {
        //        hc=invert(c);
        hc=randomCol(c,50);
      }
      hair[i]=new Hair(x+xo,y+yo,baseLen+random(randLen),random(-randDir/2.0,randDir/2.0),hc);
    }
  }

  void rotateLikeNeighbour() {
    int x1=col-1; 
    if (x1<0) {
      x1=0;
    }
    int x2=col+1; 
    if (x2>=nr_col) {
      x2=nr_col-1;
    }
    int y1=row-1; 
    if (y1<0) {
      y1=0;
    }
    int y2=row+1; 
    if (y2>=nr_row) {
      y2=nr_row-1;
    }
    for (int x=x1;x<=x2;x++) { 
      for (int y=y1;y<=y2;y++) {
        if (!(x==0&&y==0)) {
          int i=y*nr_col+x;
          rot+=0.01*(getTurnDirection(dir,bush[i].dir));
        }
      } 
    }
  }

  void setNewRotation() {
    rot*=0.95;
    dir+=rot; 
    while (dir>PI) {
      dir-=TWO_PI;
    } 
    while (dir<-PI) {
      dir+=TWO_PI;
    }
  }

  void drawMe() { 
    dirLine(x,y,len,dir,c);
    for (int i=0;i<nrHair;i++) {
      hair[i].toScreen(dir);
    }
  }
}
////////////////////////////// end Bush class //////////////////////////////
////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////
////////////////////////////// Hair class //////////////////////////////////

class Hair {
  color c;
  float x,y,len,dir;
  Hair() { 
    x=0; 
    y=0; 
    len=0; 
    dir=0; 
    c=color(0,0,0);
  }
  Hair(float _x, float _y, float _len, float _dir, color _c) { 
    x=_x; 
    y=_y; 
    len=_len; 
    dir=_dir; 
    c=_c; 
  }
  void toScreen(float rd) {
    dirLine(x,y,len,dir+rd,c);
  }
}

////////////////////////////// end Hair class //////////////////////////////
////////////////////////////////////////////////////////////////////////////


color invert(color c) {
  colorMode(RGB,255);
  return color(255-red(c),255-green(c),255-blue(c));
}

color randomCol(color c, float p) {
  colorMode(RGB,255);
  return color(red(c)+random(-p,p),green(c)+random(-p,p),blue(c)+random(-p,p));
}

// columns to x position and vice versa
float colToWidth(float c) { 
  return width*(c+0.5)/(float)nr_col; 
}
int widthToCol(float x) { 
  return int((x/(float)width)*nr_col-0.5); 
}
// rows to y position and vice versa
float rowToHeight(float r) { 
  return height*(r+0.5)/(float)nr_row; 
}
int heightToRow(float y) { 
  return int((y/(float)height)*nr_row-0.5); 
}

// calculate shortest degree from deg1 to deg2
float getTurnDirection(float deg1, float deg2) {
  float rdeg=(deg1>deg2)?deg2-(deg1-TWO_PI):deg2-deg1;
  if (rdeg<PI) { 
    return rdeg; 
  } 
  else { 
    return (rdeg-TWO_PI); 
  }
}

void dirLine(float x1, float y1, float len, float dir, color c) {
  float COS=cos(dir), SIN=sin(dir);

  //  stroke(c);
  //  line(x1,y1,x1+len*COS,y1+len*SIN);

  for (float r=0;r<=len;r+=0.7) {
    float x=x1+r*COS, y=y1+r*SIN;
    softSet(int(x),int(y),c,0.05);
  }

}

void softSet(int x, int y, int c1, float p1) {
  float p2=1.0-p1; 
  int c2=get(x,y);
  int r=int((c1>>16&255)*p1 + (c2>>16&255)*p2);
  int g=int((c1>>8&255)*p1 + (c2>>8&255)*p2);
  int b=int((c1&255)*p1 + (c2&255)*p2);
  set(x,y,(r<<16|g<<8|b));
}

float bright(int c) {
  int r=c>>16&255, g=c>>8&255, b=c&255;
  return (r+g+b)/3.0;
}