// Instancions donc un sous-type de BitmapData présent dans la bibliothèque de notre fla
// Il s'agit de l'image originale sur laquelle nous allons travailler.
     var originale:BitmapData = BitmapData(new Fruit0(0,0));
 
     var c:uint      = 0; // Une simple variable que nous pourrons incrémenter pour servir de compteur (toujours utile)
     var dim:uint    = 2; // La taille des blocs de pixels que l'on souhaite analyser (ici 2*2 soit des blocs des 4 pixels)
 
 // Une valeur de décalage entre les blocs. On analyse des blocs de 2 pixels de largeurs et hauteurs et on a un
 // décalage de 3 pixels, ce qui nous laisse un pixel vide entre chaque bloc.
     var offset:uint = 3;
 
 // La position de chaque nouveau bloc. L'idée, c'est de recréer l'image en la simplifiant, donc on va créer un
 // certain nombres de blocs de couleurs à partir de l'image originale.
     var posX:uint = 0;
     var posY:uint = 0;
 
  // Compte tenu de ces paramètres, on va se retrouver avec un certain nombre de lignes et de colonnes de blocs
     var iCols:uint = Math.floor(originale.width / offset);
     var iLines:uint = Math.floor(originale.height / offset);
 
  // A partir de là, l'idée c'est d'analyser l'image bloc par bloc (de 4 pixels) et d'obtenir les couleurs de
  // chaque pixel du bloc.
 
  for ( var i:uint = 0 ; i < iCols ; i++ ){
      for( var j:uint = 0 ; j < iLines ; j++ ){
 
           // Créons un object Rectangle de dimension dim * dim, positionné à posX, posY
           var rect:Rectangle = new Rectangle(posX, posY, dim, dim);
 
           // Dès lors, nous pouvons obtenir un tableau d'octets des pixels du bloc de dimension dim * dim situé aux coordonnées {posX, posY} de notre image
           var bytes:ByteArray = originale.getPixels(rect);
	   bytes.position = 0; // Ici, on repositionne l'itérateur du tableau à 0
 
           // ...
 
           // Incrémentons afin de passer au bloc suivant...
           posY += offset;
	   c++;
	}
	posY = 0;
	posX += offset;
}

// Passons le ByteArray de pixels du bloc à une méthode chargée de renvoyer la couleur
// moyenne de ce bloc
   var medianeColor:String = this.analyse( bytes );	 
 
// Créons un nouvel objet ByteArray
   var inputByteArray:ByteArray = new ByteArray();
 
 // Ici, nous écrivons pour chaque pixel du bloc, la couleur dominante du bloc dans l'objet ByteArray créé pour l'occasion
 
     for ( var a:uint = 0 ; a < bytes.length/4 ; a++){
		inputByteArray.writeUnsignedInt( uint( dominanteColor )) ;
      }
      inputByteArray.position = 0; // On replace l'itérateur au début
 
 // Nous disposons des informations nécessaires, mais il faut les représenter en mémoire dans un
 // objet qui permettra de les afficher ultérieurement à l'écran ; un BitmapData est approprié
 
      var bmd:BitmapData = new BitmapData(dim, dim, true, 0xFFFF0000);
 
  // Reste à écrire la couleur dans le BitmapData...
 
      bmd.setPixels(new Rectangle(0,0,dim,dim), inputByteArray);
 
  // Afin de permettre l'affichage du BitmapData à l'écran, il faut l'envelopper dans un objet Bitmap
       var b:Bitmap = new Bitmap(bmd);
       b.name = "bit" + c++; // Notre variable c va servir à nommer les différentes instances de Bitmap
 
  // Et afin d'afficher ce bitmap de façon à reconstituer l'image, on lui affecte posX et posY
  // comme valeurs de ses propriétés x et y
        b.x = posX;
	b.y = posY;
 
  // Je voulais pouvoir réutiliser ces objets Bitmap d'affichage, il fallait donc les stocker.
  // Pour stocker des données, j'utilise en général une classe dédiée (un modèle) et globale (singleton)
	Model.getInstance().dessin.push(b); // Stocke chaque bitmap dans un tableau dynamique
 
  // Ici, on affiche chaque bloc à l'écran
        _pCanvas.addChild(b);
 
  // ...

String.fromCharCode( Math.round( Math.random() * 400 + 10000 ));