void draw ()
{  
/*******EVOLUTION DES COULEURS***********/
tourCouleur += 1;
if (tourCouleur == 10) {
if (monteBleu)
    {
      bleuActeur += evolutionBleu;
      if (bleuActeur > 255)
          {
              monteBleu = false;
              evolutionBleu = int (random (1,5));
          }
    }

if (!monteBleu)
    {
      bleuActeur -= evolutionBleu;
      if (bleuActeur < 100)
          {
              monteBleu = true;
              evolutionBleu = int (random (1,5));
          }
    }
if (monteVert)
    {
      vertActeur += evolutionVert;
      if (vertActeur > 255)
          {
              monteVert = false;
              evolutionVert = int (random (1,5));
          }
    }

if (!monteVert)
    {
      vertActeur -= evolutionVert;
      if (vertActeur < 100)
          {
              monteVert = true;
              evolutionVert = int (random (1,5));
          }
    }
if (monteRouge)
    {
      rougeActeur += evolutionRouge;
      if (rougeActeur > 255)
          {
              monteRouge = false;
              evolutionRouge = int (random (1,5));
          }
    }

if (!monteRouge)
    {
      rougeActeur -= evolutionRouge;
      if (rougeActeur < 100)
          {
              monteRouge = true;
              evolutionRouge = int (random (1,5));
          }
    }

acteur2 = color (abs (85-rougeActeur),abs (85-vertActeur),abs(85-bleuActeur));
acteur1= color (rougeActeur,vertActeur,bleuActeur);
acteur0 = color (abs(50-rougeActeur),abs(50-vertActeur),abs (50-bleuActeur));
tourCouleur = 0;
}


  
  if (quelquUn) {fill (255,255/10);  choixDeVisuel = 1;compteAttente = 0;}
  if (!quelquUn) {fill (255,255/10);compteAttente += 1;}
  if (compteAttente >= tempsDattente) {
      compteAttente = 0;
      for (int i=0, x=0, y=0; i<img.width*img.height; i+=1 )
     { cellule [x][y].vOmA = 0;
       cellule [x][y].acteur = 0;
      x += 1;if (x == img.width) {x = 0;y +=1;}
      }
  }
  rect (0,0,width,height);
  //image (mov,0,0);
  
  /***********INTERPRETATION DE L'IMAGE*************/
  quelquUn = false;

  for (int i = 0, x=0, y=0, multiple=0; i< img.width*img.height; i+=1)
  {  color c = mov.get (x,y); 
     if (((c >> 16 & 0xFF) + (c >> 8 & 0xFF) + (c & 0xFF))/3 < 15 )
     {  cellule [159-x][y].vOmA = 1; // si la valeur de gris est infŽrieure ˆ 240, alors la cellule est vivante
        cellule [159-x][y].acteur = 2;
        if (multiple == 0) {
        stroke (acteur2);
        //rect (largeurRect*x,largeurRect*y,1,1);
        line (largeurRect*(159-x)+int( random (0,+8)),largeurRect*y+int( random (0,+4)),largeurRect*(159-x)+int( random (-8,0)),largeurRect*y+int( random (-4,0)));
        }
        
        /*if (y == 60) { acteur2 = color ((c >> 16 & 0xFF),(c >> 8 & 0xFF),(c & 0xFF),200); acteur1 = color ((c >> 16 & 0xFF),(c >> 8 & 0xFF),(c & 0xFF),225);
        acteur0 = color ((c >> 16 & 0xFF),(c >> 8 & 0xFF),(c & 0xFF),255);}*/
        quelquUn = true; 
     }
     x += 1;if (x == img.width) {x = 0;y +=1;}
     multiple += 1;
     if (multiple == 2) {
         multiple = 0;
     }
  }

  
  /*************DETERMINATION DE LA COULEUR DES CELLULES***********/
  for (int i=0, x=0, y=0; i<img.width*img.height;i+=1)
  { if (cellule[x][y].scintillement)
    { cellule[x][y].couleur+= 20; 
      if (cellule[x][y].couleur > 255 )
      { cellule[x][y].scintillement=false;
      }
     }
     if (!cellule[x][y].scintillement)
     { cellule[x][y].couleur-= 20; 
      if (cellule[x][y].couleur < 100 )
      { cellule[x][y].scintillement=true;
      }
     }
   x += 1;if (x == img.width) {x = 0;y +=1;}
  }
    
  /*************DESSIN DES CELLULES****************/
  if (choixDeVisuel == 0) {
  for (int i=0, x=0, y=0; i< img.width*img.height; i+=1 )
  {  if (cellule [x][y].vOmA == 1)
      {  for (int j=0; j<tailleDePixel ; j+=1)
         { for (int k=0; k<tailleDePixel; k+=1)
           { set (x*tailleDePixel+j,y*tailleDePixel+k, color (cellule[x][y].couleur));
           }
         }
      }
      x += 1;if (x == img.width) {x = 0;y +=1;}
  }
  }
  
  /*******ETUDE DES FORMES*********/
  if (choixDeVisuel == 1 || choixDeVisuel == 2 || choixDeVisuel == 3) {
    for (int i=0; i<(hauteur/largeurRect); i++)
   {  for (int j=0; j<(largeur/largeurRect) ; j++)
   { if (cellule [j][i].vOmA == 1) {
   if (!entreeX) {entreeX = true;cellule[j][i].affichage = 1;}
   } 
   if (cellule [j][i].vOmA == 0) {
   if (entreeX) {entreeX = false;
       if ((j-1) < 0) {
         cellule[(largeur/largeurRect-1)][i].affichage = 1;
       } else {
         cellule[j-1][i].affichage = 1;
         }
   } 
   }
   }
   }
   for (int i=0; i<(largeur/largeurRect); i++)
   {  for (int j=0; j<(hauteur/largeurRect) ; j++)
   { if (cellule [i][j].vOmA == 1) {
   if (!entreeY) {entreeY = true;cellule[i][j].affichage = 1;}
   }  
   if (cellule [i][j].vOmA == 0) {
   if (entreeY) {entreeY = false;
       if ((j-1) < 0 ) {
         cellule [i][(hauteur/largeurRect)-1].affichage = 1;
       }else {
         cellule[i][j-1].affichage = 1;
       }
   }
   }
   }
   }
   
  /**********DESSIN DES FORMES**********/
  for (int i = 0, x=0, y=0; i < (largeur/largeurRect*hauteur/largeurRect) ; i++)
  {  if (cellule [x][y].affichage == 1 && cellule [x][y].forme == 0){
        
        int contourX = constrain (x,1,(largeur/largeurRect)-2);
        int contourY = constrain (y,1,(hauteur/largeurRect)-2);
        int finDeForme = 0;
        //INTERACTIF
        //stroke (couleurR,couleurG,couleurB,transparenceCellule);
        stroke (255,200);
        fill (0);
        //EDITION
        //stroke (editionR,editionG,editionB);
        //fill (editionR,editionG,editionB);
       
       
       if (choixDeVisuel == 1) {beginShape (LINES);}
       if (choixDeVisuel == 2) {beginShape (LINE_LOOP);}
       if (choixDeVisuel == 3) {beginShape (POLYGON);}
       if (cellule[x][y].acteur == 2) {stroke (acteur2);}
       if (cellule[x][y].acteur == 1) {stroke (acteur1);}
       if (cellule[x][y].acteur == 3) {stroke (acteur0);}
       if (cellule[x][y].acteur == 0) {stroke (acteur0);}

        
        //curveVertex (contourX*largeurRect,contourY*largeurRect);
        vertex (contourX*largeurRect,contourY*largeurRect);
        
        while (finDeForme == 0) {
          
          
          
          if ( cellule [contourX+1][contourY].affichage == 1 && cellule[contourX+1][contourY].forme == 0) {
              if (cellule[x][y].acteur != 2 && cellule [contourX+1][contourY]. acteur == 2) {stroke (acteur1);cellule[x][y].acteur=1;}
              if (cellule[x][y].acteur != 1 && cellule [contourX+1][contourY]. acteur == 0) {stroke (acteur0);cellule[x][y].acteur=3;}
              
              //curveVertex ((contourX+1)*largeurRect,(contourY)*largeurRect);
              vertex ((contourX+1)*largeurRect,(contourY)*largeurRect);
              cellule [contourX+1][contourY].forme = 1;
              contourX += 1;
              if (contourX > (largeur/largeurRect) -2 ){
                 contourX -= 1;
              }
              
          }
          else
            if ( cellule [contourX+1][contourY+1].affichage == 1 && cellule[contourX+1][contourY+1].forme == 0) {
              if (cellule[x][y].acteur != 2 && cellule [contourX+1][contourY+1]. acteur == 2) {stroke (acteur1);cellule[x][y].acteur=1;}
              if (cellule[x][y].acteur != 1 && cellule [contourX+1][contourY]. acteur == 0) {stroke (acteur0);cellule[x][y].acteur=3;}
              
              //curveVertex ((contourX+1)*largeurRect,(contourY+1)*largeurRect);
              vertex ((contourX+1)*largeurRect,(contourY+1)*largeurRect);
              cellule [contourX+1][contourY+1].forme = 1;
              contourX += 1;
              if (contourX > (largeur/largeurRect) -2 ){
                 contourX -= 1;
              } 
              contourY += 1;
              if (contourY > (hauteur/largeurRect)-2) {
                   contourY -= 1;
              }
              
            }
            else
              if ( cellule [contourX][contourY+1].affichage == 1 && cellule[contourX][contourY+1].forme == 0) {
                if (cellule[x][y].acteur != 2 && cellule [contourX][contourY+1]. acteur == 2) {stroke (acteur1);cellule[x][y].acteur=1;}
                if (cellule[x][y].acteur != 1 && cellule [contourX+1][contourY]. acteur == 0) {stroke (acteur0);cellule[x][y].acteur=3;}
                
              //curveVertex ((contourX)*largeurRect,(contourY+1)*largeurRect);
              vertex ((contourX)*largeurRect,(contourY+1)*largeurRect);
              cellule [contourX][contourY+1].forme = 1;
              contourY += 1;
              if (contourY > (hauteur/largeurRect)-2) {
                   contourY -= 1;
              }
                
              }
              else
                if ( cellule [contourX-1][contourY+1].affichage == 1 && cellule[contourX-1][contourY+1].forme == 0) {
                  if (cellule[x][y].acteur != 2 && cellule [contourX-1][contourY+1]. acteur == 2) {stroke (acteur1);cellule[x][y].acteur=1;}
                  if (cellule[x][y].acteur != 1 && cellule [contourX+1][contourY]. acteur == 0) {stroke (acteur0);cellule[x][y].acteur=3;}
                 
                //curveVertex ((contourX-1)*largeurRect,(contourY+1)*largeurRect);
                vertex ((contourX-1)*largeurRect,(contourY+1)*largeurRect);
                cellule [contourX-1][contourY+1].forme = 1;
                contourX -= 1;
                if (contourX < 1 ){
                   contourX += 1;
              }
                contourY += 1;
                if (contourY > (hauteur/largeurRect)-2) {
                   contourY -= 1;
              }
                  
                }
                else
                  if ( cellule [contourX-1][contourY].affichage == 1 && cellule[contourX-1][contourY].forme == 0) {
                    if (cellule[x][y].acteur != 2 && cellule [contourX-1][contourY]. acteur == 2) {stroke (acteur1);cellule[x][y].acteur=1;}
                    if (cellule[x][y].acteur != 1 && cellule [contourX+1][contourY]. acteur == 0) {stroke (acteur0);cellule[x][y].acteur=3;}
                    
                  //curveVertex ((contourX-1)*largeurRect,(contourY)*largeurRect);
                  vertex ((contourX-1)*largeurRect,(contourY)*largeurRect);
                  cellule [contourX-1][contourY].forme = 1;
                    
                  if (contourX-1 == x && contourY == y) {
                      finDeForme = 1;
                  }
                  contourX -= 1;
                  if (contourX < 1 ){
                 contourX += 1;
                 }
                    
                 }
                 else
                  if ( cellule [contourX-1][contourY-1].affichage == 1 && cellule[contourX-1][contourY-1].forme == 0) {
                    if (cellule[x][y].acteur != 2 && cellule [contourX-1][contourY-1]. acteur == 2) {stroke (acteur1);cellule[x][y].acteur=1;}
                    if (cellule[x][y].acteur != 1 && cellule [contourX+1][contourY]. acteur == 0) {stroke (acteur0);cellule[x][y].acteur=3;}
                    
                  //curveVertex ((contourX-1)*largeurRect,(contourY-1)*largeurRect);
                  vertex ((contourX-1)*largeurRect,(contourY-1)*largeurRect);
                  cellule [contourX-1][contourY-1].forme = 1;
                  if (contourX-1 == x && contourY-1 == y) {
                      contourX += 1;
                  }
                  contourX -= 1;
                  if (contourX < 1 ){
                   contourX += 1;;
                   }
                  contourY -= 1;
                  if (contourY < 1) {
                   contourY += 1;
                   }
                    
                  }
                  else
                    if ( cellule [contourX][contourY-1].affichage == 1 && cellule[contourX][contourY-1].forme == 0) {
                      if (cellule[x][y].acteur != 2 && cellule [contourX][contourY-1]. acteur == 2) {stroke (acteur1);cellule[x][y].acteur=1;}
                      if (cellule[x][y].acteur != 1 && cellule [contourX+1][contourY]. acteur == 0) {stroke (acteur0);cellule[x][y].acteur=3;}
                     
                    //curveVertex ((contourX)*largeurRect,(contourY-1)*largeurRect);
                    vertex ((contourX)*largeurRect,(contourY-1)*largeurRect);
                    cellule [contourX][contourY-1].forme = 1;
                    if (contourX == x && contourY-1 == y) {
                      finDeForme = 1;
                    }
                    contourY -= 1;
                    if (contourY < 1) {
                   contourY += 1;
                    }
                      
                  }
                  else
                    if ( cellule [contourX+1][contourY-1].affichage == 1 && cellule[contourX+1][contourY-1].forme == 0) {
                      if (cellule[x][y].acteur != 2 && cellule [contourX+1][contourY-1]. acteur == 2) {stroke (acteur1);cellule[x][y].acteur=1;}
                      if (cellule[x][y].acteur != 1 && cellule [contourX+1][contourY]. acteur == 0) {stroke (acteur0);cellule[x][y].acteur=3;}
                     
                    //curveVertex ((contourX+1)*largeurRect,(contourY-1)*largeurRect);
                    vertex ((contourX+1)*largeurRect,(contourY-1)*largeurRect);
                    cellule [contourX+1][contourY-1].forme = 1;
                    if (contourX+1 == x && contourY-1 == y) {
                      finDeForme = 1;
                    }
                    contourX += 1;
                    if (contourX > (largeur/largeurRect) -2 ){
                    contourX -= 1;
                    }
                    contourY -= 1;
                    if (contourY < 1) {
                     contourY += 1;
                    }
                      
                  }
                  else {
                     finDeForme = 1;
                  }
            
        
        }
        
        cellule [x][y].forme = 1;
        endShape (); 
        noStroke ();
        
    }
    x+=1;
    if (x == largeur/largeurRect) {
    x = 0;
    y += 1;
    }
  }
  
 for (int i=0, x=0, y=0; i< ((largeur/largeurRect)*(hauteur/largeurRect)) ; i++)
  {  cellule[x][y].affichage = 0;
     cellule[x][y].forme = 0;
     x+=1;
     if (x == largeur/largeurRect) {
         x=0;
         y+=1;
     }
  }
  entreeX = false;
  entreeY = false;
  }
  /*************DESSIN DU FILM****************/
  /*for (int i=0, x=80, y=0; i< img.width*img.height; i+=1 )
  {  color c = mov.get (x,y); fill (c);
         rect (x*2,y*2,2,2);
      x += 1;if (x == img.width+80) {x = 80;y +=1;}
  }*/
  
  /*************ACTIVATION DE L'AUTOMATE************/
  for (int i=0, x=0, y=0; i< img.width*img.height; i+=1 )
  {  cellule [x][y].automate (x,y);
     x += 1;if (x == img.width) {x = 0;y +=1;}
  }
  
  /*************PREPARATION DU TOUR SUIVANT*********/
  for (int i=0, x=0, y=0; i<img.width*img.height; i+=1 )
  { if (cellule [x][y].vOmA == 1) {val += 1;}
    cellule [x][y].vOmA = cellule [x][y].vOmP;
    if (cellule[x][y].acteur== 2) {cellule [x][y].acteur = 0;}

     x += 1;if (x == img.width) {x = 0;y +=1;}
  }
  if (tourReseau == 0) {
  tourReseau = 20;
  val = (val*255)/(640/4*480/4);
  myServer.write (val);
  //println (val);
  }
  tourReseau -= 1;
  val = 0;
  
  /*************************************************/
}

/*void movieEvent(Movie m) { 
  mov.read(); 
}*/ 

void keyPressed ()
 {
    if (keyCode == ENTER)
      {save ("jdlvcouleur.tif");
      }
  }