//***************************************************************************//
//   EXUVIA - an installation by Alessandro Capozzo and Katja Noppes         //
//   Milano, September 2005 - Januray 2006                                   //
//   www.abstract-codex.net - www.katjanoppes.net                            //
//   Code by Alessandro Capozzo built with Processing Beta .91               //
//   www.processing.org                                                      //
//***************************************************************************//
Pix [] amountOfPix;
int my_array_length;
boolean mouseDown;
float timeC=0;
float midWidth;
float midHeight;
// put some blue dots on a picture :)
PImage myImage = loadImage("/libmatrix4.jpg"); 
   
int automaNum;  
Automa [] cellularAutoma;

void setup(){
    size(1024,768,P3D);
    image(myImage,1,1);
    loadPixels(); 
    automaNum=320;
    midWidth=width*.5;
    midHeight=height*.5;
     cellularAutoma=new Automa[automaNum];
     for(int a=0; a<automaNum; a++){
        cellularAutoma[a]=new Automa(a);
     }
    int pp=0;
    
    for(int i=0; i<(width*height); i++) { 
    color p = pixels[i]; 
    float cp=red(p);
     if(cp<10){
      pp++;
    }
    
  }  
    
     amountOfPix=new Pix[pp]; 
  
    int n=0;
    for(int i=0; i<width; i++){
        for(int j=0; j<height; j++){
        color p = pixels[j*width+i]; 
       float cp=red(p);
      if(cp<10){
        int xx=int(i);
        int yy=int(j);
        amountOfPix[n]=new Pix(xx,yy,n);
        n++;
         }
         
        }
    }
    my_array_length=amountOfPix.length;
    for(int k=0;k<my_array_length;k++){
         amountOfPix[k].setConnection();
        
    }
    
}
void draw() {
    background(187,186,183);
    timeC+=.1;
    for(int k=0;k<my_array_length;k++){
         amountOfPix[k].newPosition();
        
    }
    for(int k=0;k<my_array_length;k++){
         amountOfPix[k].drawShape();
        
    }
    for(int a=0; a<automaNum; a++){
        cellularAutoma[a].upDate();
     }
     for(int a=0; a<automaNum; a++){
        cellularAutoma[a].drawMe();
     }
}

class Pix {
    int _X;
    int _Y;
    int _pX,_pY;
    int ID;
    float distance;
    float mousedist;
    int difX,difY;
    int  firstSeg;
    int  secondSeg;
    float xSpeed,ySpeed,ndelay;
    int connected;
    int gravity;
    float pixNoise;
    Pix (int pixX, int pixY,int id){
        _X=pixX;
        _Y=pixY;
        ID=id;
        _pX=_X;
        _pY=_Y;
        difX=0;
        difY=0;
        xSpeed=0.00;
        ySpeed=0.00;
        ndelay=.4;
        firstSeg=0;
        secondSeg=0;
        connected=0;
        pixNoise=noise(_pX,_pY,timeC);

    }
   void drawShape (){
    
    float redCoef=220-int(_pX*.3);
    float blueCoef=100-int(_pY*.3);
   //stroke(redCoef,120,blueCoef,60);
   stroke(255);
    line(_pX-2,_pY,_pX+2,_pY);
    line(_pX,_pY-2,_pX,_pY+2);
    //
   
    if(connected>2){
           //stroke(redCoef,redCoef,blueCoef,60);
           stroke(255);
           
           if(amountOfPix[firstSeg].firstSeg!=ID&&amountOfPix[firstSeg].secondSeg!=ID||firstSeg>ID){
           line(_pX,_pY,amountOfPix[firstSeg]._pX,amountOfPix[firstSeg]._pY);
           }
           if(amountOfPix[secondSeg].firstSeg!=ID&&amountOfPix[secondSeg].secondSeg!=ID||secondSeg>ID){
           line(_pX,_pY,amountOfPix[secondSeg]._pX,amountOfPix[secondSeg]._pY);
           }
           gravity+=connected;
           connected=0;
    }
    stroke(redCoef,redCoef,blueCoef,100);
    setConnection();
  
      
   }
   void newPosition(){
   
   if(gravity>160){
   //if(dist(_X,_Y,mouseX,mouseY)<80){
     pixNoise=noise(_pX,_pY,timeC);
     _pX+=cos(atan2(_Y-midHeight,_X-midWidth))*((_X-(gravity)-_pX)*.1);
     _pY+=sin(atan2(_Y-midHeight,_X-midWidth))*((_X-(gravity)-_pX)*.1);
   /* _pX+=int((_X-(gravity)-_pX)*.1);
    _pY+=int((_Y-(gravity)-_pY)*.1); */
    gravity=0;  
     } else{
     difX=_X-_pX;
     difY=_Y-_pY;
     xSpeed+=difX*ndelay;
     ySpeed+=difY*ndelay;
     xSpeed*=.9;
     ySpeed*=.9;
     _pX+=xSpeed;
     _pY+=ySpeed;

    }
   }
   void setConnection(){
       float oldDist=width*height;
       float newDist=0;
       for(int k=0;k<my_array_length;k++){
        if(k!=ID){
           newDist=Math.abs(dist(amountOfPix[k]._pX,amountOfPix[k]._pY,_pX,_pY));
           if(newDist<150){
             if (newDist<=oldDist){
                 secondSeg=firstSeg;
                 firstSeg=k;
                 oldDist=newDist;
              }
             }
         }
        
        
    }
   }
  
}

class Automa {
  int _x;
  int _y;
   int oldX;
  int  oldY;
  int _id;
  float speedX;
  float speedY;
  int oldTarget,oldestTarget,veryOldTarget;
  int proxyLimit;
  float beta,beta2;
  boolean checkTarget; 
  int idTarget;
  float oldDist;
  float distanzaAbs;
  float distanza;
  int stopCount;
  
  // draw property
  int _dist;
  int ndist;
  float _near;
   float antivectX;
   float antivectY;
   
   // upDate prop
   float newDist;
   float r;
   int disCounter;
   float xJump;
   float yJump;
   float pixNoise;
   color aColor;
  Automa (int id) {
   _x=int(random(width));
   _y=int(random(height));
   _id=id;
   oldTarget=-1;
   oldestTarget=-1;
   veryOldTarget=-1;
   proxyLimit=10;
   oldX=_x;
   oldY=_y;
   checkTarget=true;
   stopCount=0;
  }
  void drawMe(){
    _dist=800;
     ndist=0;
          _near=0;
         antivectX=0;
         antivectY=0;
   for(int k=0;k<automaNum;k++){
    if(k!=_id){
      ndist=(int) dist(cellularAutoma[k]._x,cellularAutoma[k]._y,_x,_y);
      
      }
      if(ndist<8){
      antivectX+=(_x-cellularAutoma[k]._x)*.2;
       antivectY+=(_y-cellularAutoma[k]._y)*.2;
      }
      if(ndist<_dist){
       _near=k;
       _dist=ndist;
       
      }
  }
    aColor=color(160*(pixNoise*1.2)+(_dist*.3),150*(pixNoise*1.3)+(_dist*.3),140*(pixNoise*1.2)+(_dist*.4),200+(pixNoise)*_dist);
    
    if((_dist>8)){
      stroke(aColor);
      line(_x,_y,cellularAutoma[(int)_near]._x,cellularAutoma[(int)_near]._y);
      noFill();
      ellipse(_x,_y,ceil(_dist),ceil(_dist));
      fill(aColor);;
       ellipse(_x,_y,3,3);
    } else {
      fill(aColor);
      stroke(aColor);
      ellipse(_x,_y,3,3);
        
    }
  }
  void upDate(){
        
     if(checkTarget){
         
         oldDist=width*height;
         idTarget=-1;
         checkTarget=false;
     for(int k=0;k<my_array_length;k++){
        newDist=dist (_x,_y,amountOfPix[k]._pX,amountOfPix[k]._pY);
      if((oldTarget!=k)&&(oldestTarget!=k)&&(veryOldTarget!=k)){
           if(newDist<oldDist){
              
              oldDist=newDist;
              idTarget=k;
              }
           }
        }
        
    }
    amountOfPix[idTarget].connected++;
    pixNoise=amountOfPix[idTarget].pixNoise;
    // define old target, next cycle automa will check for another target
   r=dist (_x,_y,amountOfPix[idTarget]._pX,amountOfPix[idTarget]._pY);
   if(r<proxyLimit){
       veryOldTarget=oldestTarget;
       oldestTarget=oldTarget;
       oldTarget=idTarget;
       
       checkTarget=true;
    }
    if(r==0){
      r=1;
    }
    beta=(float)Math.acos((amountOfPix[idTarget]._pX-_x)/r);
    beta2=(float)Math.asin((amountOfPix[idTarget]._pY-_y)/r);
     speedX+=cos(beta)*3;
     speedY+=sin(beta2)*3;
     disCounter=0;
     xJump=0;
     yJump=0;
     for (int j=0; j<automaNum;j++){
        if(j!=_id){
           distanza=dist(cellularAutoma[j]._x,cellularAutoma[j]._y,_x,_y);
           if(distanza<10){
               xJump+=(_x-cellularAutoma[j]._x)*.3;
               yJump+=(_y-cellularAutoma[j]._y)*.3;
               
               
           }

    if(speedX>4){
       speedX=4;
    } else if(speedX<-4){
        speedX=-4;
    }
    if(speedY>4){
        speedY=4;
    } else if(speedY<-4){
        speedY=-4;
    }
           
        }
     }
    speedX=speedX+xJump;
    speedY=speedY+yJump;
    oldX=_x;
    oldY=_y;
    _x+=speedX;
    _y+=speedY;
   if(_x==oldX && _y==oldY){
       stopCount++;
       if(stopCount>10){
          reStart(_id);
       }
    }

     
   
   }
  }
void reStart (int id){
   cellularAutoma[id]=new Automa(id);
}