BitmapData  - AS3

La hauteur de l’image bitmap en pixels.

Le rectangle qui délimite la taille et l’emplacement de l’image bitmap. Le haut et le côté gauche du rectangle sont définis sur 0 ; la largeur et la hauteur sont égales à la largeur et à la hauteur, en pixels, de l’objet BitmapData.

Définit si l’image bitmap prend en charge la transparence par pixel. Vous pouvez définir cette valeur uniquement lorsque vous créez un objet BitmapData en transmettant la valeur true au paramètre transparent du constructeur. Après avoir créé un objet BitmapData, vous pouvez alors vérifier s’il prend en charge la transparence par pixel en déterminant si la valeur de la propriété transparent est true.

Largeur de l’image bitmap en pixels.

Crée un objet BitmapData à la largeur et la hauteur spécifiées. Si vous spécifiez une valeur pour le paramètre fillColor, chaque pixel de l’image bitmap est défini sur cette couleur.

Par défaut, l’image bitmap créée est transparente, sauf si vous transmettez la valeur false au paramètre transparent. Une fois l’image bitmap opaque créée, vous ne pouvez pas la transformer en bitmap transparente. Chaque pixel d’une image bitmap opaque utilise uniquement 24 bits d’informations du canal de couleur. Si vous réglez l’image bitmap sur transparent, chaque pixel utilise 32 bits d’informations de canal de couleur, y compris un canal de transparence alpha.

Dans AIR 1.5 et Flash Player 10, la taille maximale d’un objet BitmapData est de 8 191 pixels en largeur ou en hauteur, et le nombre total de pixels ne peut pas excéder 16 777 215 pixels (ainsi, si la largeur d’un objet BitmapData est de 8 191 pixels, sa hauteur maximale doit être de 2 048 pixels). Dans Flash Player 9 et les versions antérieures, ainsi que dans AIR 1.1 et les versions antérieures, la limite est de 2 880 pixels de haut sur 2 880 pixels de large. Si vous spécifiez une valeur de largeur ou de hauteur supérieure à 2880, la nouvelle occurrence n’est pas créée.

Prend une image source et un objet filtre et génère l’image filtrée.

Cette méthode repose sur le comportement des objets filtres intégrés, qui déterminent le rectangle de destination affecté par un rectangle source d’entrée.

Une fois le filtre appliqué, la taille de l’image obtenue peut être supérieure à celle de l’image d’entrée. Par exemple, si vous utilisez une classe BlurFilter pour rendre flou un rectangle source de (50,50,100,100) et un point de destination de (10,10), la zone modifiée sur l’image de destination est supérieure à (10,10,60,60) en raison du flou. Cela se produit en interne au cours de l’appel applyFilter().

Si le paramètre sourceRect du paramètre sourceBitmapData est une zone intérieure, telle que (50,50,100,100) sur une image 200 x 200, le filtre utilise les pixels source hors du paramètre sourceRect pour générer le rectangle de destination.

Si l’objet BitmapData et l’objet spécifié en tant que paramètre sourceBitmapData sont identiques, l’application utilise une copie temporaire de l’objet pour effectuer le filtrage. Pour optimiser les performances, évitez ce cas de figure.

Paramètres

Plus d’exemples

Eléments de l’API associés

import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.geom.Point;
import flash.geom.Rectangle;
import flash.filters.BlurFilter;

var bmd:BitmapData = new BitmapData(80, 30, false, 0xFFCC00);
var rect:Rectangle = new Rectangle(10, 10, 40, 10);
bmd.fillRect(rect, 0xFF0000);

var pt:Point = new Point(10, 10);
var filter:BlurFilter = new BlurFilter();
bmd.applyFilter(bmd, rect, pt, filter);

var bm:Bitmap = new Bitmap(bmd);
addChild(bm);

Renvoie un nouvel objet BitmapData, clone de l’occurrence d’origine avec une copie exacte de l’image bitmap contenue.

import flash.display.Bitmap;
import flash.display.BitmapData;

var bmd1:BitmapData = new BitmapData(100, 80, false, 0x00000000);
var bmd2:BitmapData = bmd1.clone();

bmd1.setPixel32(1, 1, 0xFFFFFFFF);

trace(bmd1.getPixel32(1, 1).toString(16)); // ffffffff
trace(bmd2.getPixel32(1, 1).toString(16)); // ff000000

var bm1:Bitmap = new Bitmap(bmd1);
this.addChild(bm1);

var bm2:Bitmap = new Bitmap(bmd2);
bm2.x = 110;
this.addChild(bm2);

Définit les valeurs de couleur dans une zone spécifiée d’une image bitmap en utilisant un objet ColorTransform. Si le rectangle correspond aux limites de l’image bitmap, cette méthode transforme les valeurs de couleur de l’image tout entière.

Paramètres

Eléments de l’API associés

import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.geom.Rectangle;
import flash.geom.ColorTransform;

var bmd:BitmapData = new BitmapData(80, 30, false, 0xFF0000);

var cTransform:ColorTransform = new ColorTransform();
cTransform.alphaMultiplier = 0.5
var rect:Rectangle = new Rectangle(0, 0, 40, 30);
bmd.colorTransform(rect, cTransform);

var bm:Bitmap = new Bitmap(bmd);
addChild(bm);

Compare deux objets BitmapData. S’ils ont tous deux les mêmes dimensions (largeur et hauteur), la méthode renvoie un nouvel objet BitmapData, dans lequel chaque pixel correspond à la « différence » entre les pixels des deux objets source :

• Si deux pixels sont équivalents, le pixel de différence est 0x00000000.
• Si deux pixels ont des valeurs RVB différentes (en dehors de la valeur alpha), le pixel de différence est 0xRRGGBB où RR/GG/BB sont les valeurs de différences individuelles entre les canaux rouge, vert et bleu (la valeur du pixel dans l’objet source moins la valeur du pixel dans l’objet otherBitmapData). Les différences relatives au canal alpha ne sont pas prises en compte dans ce cas.
• Si seule la valeur du canal alpha diffère, la valeur du pixel est 0xZZFFFFFF, où ZZ est la différence entre les valeurs alpha (la valeur alpha dans l’objet source moins la valeur alpha dans l’objet otherBitmapData).

Prenons l’exemple des deux objets BitmapData suivants :

     var bmd1:BitmapData = new BitmapData(50, 50, true, 0xFFFF8800);
     var bmd2:BitmapData = new BitmapData(50, 50, true, 0xCCCC6600);
     var diffBmpData:BitmapData = bmd1.compare(bmd2) as BitmapData;
     trace ("0x" + diffBmpData.getPixel(0,0).toString(16); // 0x332200
     

Remarque : les couleurs utilisées pour remplir les deux objets BitmapData ont des valeurs RVB légèrement différentes (0xFF0000 et 0xFFAA00). L’utilisation de la méthode compare() entraîne la création d’un objet BitmapData dont chaque pixel indique la différence entre les valeurs RVB des deux bitmaps.

Prenez l’exemple des deux objets BitmapData suivants, dans lesquels les couleurs RVB sont identiques, mais les valeurs alpha sont différentes :

     var bmd1:BitmapData = new BitmapData(50, 50, true, 0xFFFFAA00);
     var bmd2:BitmapData = new BitmapData(50, 50, true, 0xCCFFAA00);
     var diffBmpData:BitmapData = bmd1.compare(bmd2) as BitmapData;
     trace ("0x" + diffBmpData.getPixel32(0,0).toString(16); // 0x33ffffff
     

L’utilisation de la méthode compare() entraîne la création d’un objet BitmapData dont chaque pixel indique la différence entre les valeurs alpha des deux bitmaps.

Si les objets BitmapData sont équivalents (largeur, hauteur et valeurs de pixels identiques), la méthode renvoie la valeur 0.

Si les largeurs des objets BitmapData ne sont pas identiques, la méthode renvoie la valeur -3.

Si les hauteurs des objets BitmapData ne sont pas identiques, mais que les largeurs sont les mêmes, la méthode renvoie la valeur -4.

L’exemple suivant compare deux objets Bitmap de différentes largeurs (50 et 60) :

     var bmd1:BitmapData = new BitmapData(100, 50, false, 0xFFFF0000);
     var bmd2:BitmapData = new BitmapData(100, 60, false, 0xFFFFAA00);
     trace(bmd1.compare(bmd2)); // -4
     

Paramètres

import flash.display.Bitmap;
import flash.display.BitmapData;

var bmd1:BitmapData = new BitmapData(50, 50, true, 0xFFFFAA00);
var bmd2:BitmapData = new BitmapData(50, 50, true, 0xCCFFAA00);
var diffBmpData:BitmapData = BitmapData(bmd1.compare(bmd2));
var diffValue:String = diffBmpData.getPixel32(1, 1).toString(16);
trace (diffValue); // 33ffffff

var bm1:Bitmap = new Bitmap(bmd1);
addChild(bm1);
var bm2:Bitmap = new Bitmap(bmd2);
addChild(bm2);
bm2.x = 60;

Transfère les données du canal d’un autre objet BitmapData ou de l’objet BitmapData actuel vers un canal de l’objet BitmapData actuel. Toutes les données contenues dans les autres canaux de l’objet BitmapData de destination sont préservées.

La valeur du canal source et de destination peut être l’une des valeurs suivantes :

• BitmapDataChannel.RED
• BitmapDataChannel.GREEN
• BitmapDataChannel.BLUE
• BitmapDataChannel.ALPHA

Paramètres

Eléments de l’API associés

import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.geom.Rectangle;
import flash.geom.Point;

var bmd:BitmapData = new BitmapData(100, 80, false, 0x00FF0000);

var rect:Rectangle = new Rectangle(0, 0, 20, 20);
var pt:Point = new Point(10, 10);
bmd.copyChannel(bmd, rect, pt, BitmapDataChannel.RED, BitmapDataChannel.BLUE);

var bm:Bitmap = new Bitmap(bmd);
this.addChild(bm);    

Met en place une routine rapide permettant de manipuler les pixels de différentes images sans effets d’étirement, de rotation ou de couleur. Cette méthode copie une zone rectangulaire d’une image source dans une zone rectangulaire de taille identique au point de destination de l’objet BitmapData de destination.

Si vous incluez les paramètres alphaBitmap et alphaPoint, vous pouvez utiliser une image secondaire en tant que source alpha pour l’image source. Si l’image source contient des données alpha, les deux ensembles de données alpha sont utilisés pour composer des pixels de l’image source vers l’image de destination. Le paramètre alphaPoint est le point, sur l’image alpha, correspondant au coin supérieur gauche du rectangle source. Aucun pixel situé hors de l’intersection de l’image source et de l’image alpha n’est copié sur l’image de destination.

La propriété mergeAlpha contrôle si le canal alpha est utilisé ou non lorsqu’une image transparente est copiée sur une autre image transparente. Pour copier des pixels avec les données du canal alpha, définissez la propriété mergeAlpha sur true . Par défaut, la propriété mergeAlpha est définie sur false.

Paramètres

import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.geom.Rectangle;
import flash.geom.Point;

var bmd1:BitmapData = new BitmapData(40, 40, false, 0x000000FF);
var bmd2:BitmapData = new BitmapData(80, 40, false, 0x0000CC44);

var rect:Rectangle = new Rectangle(0, 0, 20, 20);
var pt:Point = new Point(10, 10);
bmd2.copyPixels(bmd1, rect, pt);

var bm1:Bitmap = new Bitmap(bmd1);
this.addChild(bm1);
var bm2:Bitmap = new Bitmap(bmd2);
this.addChild(bm2);
bm2.x = 50;

Remplit un tableau d’octets à partir d’une zone rectangulaire de données de pixels. En commençant par l’index position de l’objet ByteArray, cette méthode écrit un entier non signé (valeur de pixel non multipliée de 32 bits) pour chaque pixel dans le tableau d’octets. Si besoin est, la taille du tableau d’octets est augmentée du nombre d’octets nécessaire pour pouvoir contenir toutes les données de pixel.

Paramètres

Eléments de l’API associés

Libère la mémoire utilisée pour stocker l’objet BitmapData.

Lorsque la méthode dispose() est appelée sur une image, la largeur et la hauteur de celle-ci sont définies sur 0. Tous les appels ultérieurs des méthodes ou des propriétés de cette occurrence de BitmapData échouent et une exception est renvoyée.

BitmapData.dispose() libère immédiatement la mémoire occupée par les données bitmap actuelles (une image bitmap peut consommer jusqu’à 64 Mo de mémoire). Après avoir utilisé BitmapData.dispose(), l’objet BitmapData n’est plus utilisable et le moteur d’exécution de Flash renvoie une exception si vous appelez des fonctions sur l’objet BitmapData. Toutefois, BitmapData.dispose() ne nettoie pas l’objet BitmapData (environ 128 octets) ; la mémoire occupée par l’objet BitmapData actuel est libérée lorsque le nettoyeur de mémoire collecte l’objet BitmapData.

Eléments de l’API associés

import flash.display.BitmapData;

var myBitmapData:BitmapData = new BitmapData(100, 80, false, 0x000000FF);
trace(myBitmapData.getPixel(1, 1)); // 255 == 0xFF

myBitmapData.dispose();
try {
    trace(myBitmapData.getPixel(1, 1));
} catch (error:Error) {
    trace(error); // ArgumentError
}

Dessine l’objet d’affichage source sur l’image bitmap avec la fonctionnalité de rendu vectoriel du moteur d’exécution de Flash. Vous pouvez spécifier les paramètres matrix, colorTransform, blendMode, ainsi qu’un paramètre de destination clipRect pour contrôler l’exécution du rendu. Vous pouvez éventuellement indiquer si l’image bitmap doit être lissée lorsqu’elle est redimensionnée (cette opération ne fonctionne que si l’objet source est un objet BitmapData).

Remarque : la méthode drawWithQuality() fonctionne exactement comme la méthode draw(), mais au lieu d’utiliser la propriété Stage.quality pour déterminer la qualité de rendu vectoriel, vous spécifiez le paramètre quality sur la méthode drawWithQuality().

Cette méthode correspond directement au mode de traçage des objets à l’aide de la fonctionnalité de rendu vectoriel standard dans l’interface de l’outil de création.

L’objet d’affichage source n’utilise pas les transformations appliquées pour cet appel. Il est traité de la manière dont il apparaît dans la bibliothèque ou dans le fichier, sans transformation de matrice, de couleurs et sans mode de fondu. Pour dessiner un objet d’affichage, tel qu’un clip, en utilisant ses propres propriétés de transformation, vous pouvez copier sa propriété transform dans la propriété transform de l’objet Bitmap qui utilise l’objet BitmapData.

Cette méthode est prise en charge sur RTMP dans Flash Player 9.0.115.0 et versions ultérieures, et dans Adobe AIR. Vous pouvez contrôler l’accès aux flux sur un serveur FMS (Flash Media Server) dans un script coté serveur. Pour plus de détails, voir les propriétés Client.audioSampleAccess et Client.videoSampleAccess dans le Guide de référence du langage ActionScript d’Adobe Flash Media Server côté serveur.

Si l’objet source et (dans le cas d’un objet Sprite ou MovieClip) tous les objets enfant correspondants ne proviennent pas du même domaine que l’appelant, ou ne résident pas dans un contenu auquel ce dernier peut accéder par le biais de la méthode Security.allowDomain(), un appel à la méthode draw() renvoie une exception SecurityError. Cette restriction ne s’applique pas au contenu AIR dans le sandbox de sécurité de l’application.

Il existe également des restrictions concernant l’utilisation d’une image bitmap chargée en tant que source. Un appel de la méthode draw() aboutit si l’image chargée provient du même domaine que l’appelant. Par ailleurs, un fichier de régulation interdomaine sur le serveur de l’image peut autoriser le domaine du contenu SWF qui appelle la méthode draw(). Le cas échéant, vous devez définir la propriété checkPolicyFile d’un objet LoaderContext, puis utiliser cet objet en tant que paramètre context lors de l’appel de la méthode load() de l’objet Loader utilisée pour charger l’image. Le contenu AIR du sandbox de sécurité de l’application n’est pas soumis à ces restrictions.

Dans Windows, la méthode draw() ne peut pas capturer le contenu SWF incorporé dans une page HTML dans un objet HTMLLoader dans Adobe AIR.

La méthode draw() ne peut pas capturer un contenu PDF dans Adobe AIR. Elle ne peut pas non plus capturer un contenu SWF intégré dans HTML dont l’attribut wmode est défini sur "window" dans Adobe AIR.

Paramètres

Eléments de l’API associés

import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.text.TextField;

var tf:TextField = new TextField();
tf.text = "bitmap text";

var myBitmapData:BitmapData = new BitmapData(80, 20);
myBitmapData.draw(tf);
var bmp:Bitmap = new Bitmap(myBitmapData);
this.addChild(bmp);

Dessine l’objet d’affichage source sur l’image bitmap avec la fonctionnalité de rendu vectoriel du moteur d’exécution de Flash. Vous pouvez spécifier les paramètres matrix, colorTransform, blendMode, ainsi qu’un paramètre de destination clipRect pour contrôler l’exécution du rendu. Vous pouvez éventuellement indiquer si l’image bitmap doit être lissée lorsqu’elle est redimensionnée (cette opération ne fonctionne que si l’objet source est un objet BitmapData).

Remarque : la méthode drawWithQuality() fonctionne exactement comme la méthode draw(), mais au lieu d’utiliser la propriété Stage.quality pour déterminer la qualité de rendu vectoriel, vous spécifiez le paramètre quality sur la méthode drawWithQuality().

Cette méthode correspond directement au mode de traçage des objets à l’aide de la fonctionnalité de rendu vectoriel standard dans l’interface de l’outil de création.

L’objet d’affichage source n’utilise pas les transformations appliquées pour cet appel. Il est traité de la manière dont il apparaît dans la bibliothèque ou dans le fichier, sans transformation de matrice, de couleurs et sans mode de fondu. Pour dessiner un objet d’affichage, tel qu’un clip, en utilisant ses propres propriétés de transformation, vous pouvez copier sa propriété transform dans la propriété transform de l’objet Bitmap qui utilise l’objet BitmapData.

Cette méthode est prise en charge sur RTMP dans Flash Player 9.0.115.0 et versions ultérieures, et dans Adobe AIR. Vous pouvez contrôler l’accès aux flux sur un serveur FMS (Flash Media Server) dans un script coté serveur. Pour plus d’informations, voir les propriétés Client.audioSampleAccess et Client.videoSampleAccess dans le Guide de référence du langage ActionScript d’Adobe Flash Media Server côté serveur.

Si l’objet source et (dans le cas d’un objet Sprite ou MovieClip) tous les objets enfants correspondants ne proviennent pas du même domaine que l’appelant, ou ne résident pas dans un contenu auquel ce dernier peut accéder par le biais de la méthode Security.allowDomain(), un appel à la méthode drawWithQuality() renvoie une exception SecurityError. Cette restriction ne s’applique pas au contenu AIR dans le sandbox de sécurité de l’application.

Il existe également des restrictions concernant l’utilisation d’une image bitmap chargée en tant que source. Un appel de la méthode drawWithQuality() aboutit si l’image chargée provient du même domaine que l’appelant. Par ailleurs, un fichier de régulation interdomaine sur le serveur de l’image peut autoriser le domaine du contenu SWF qui appelle la méthode drawWithQuality(). Le cas échéant, vous devez définir la propriété checkPolicyFile d’un objet LoaderContext, puis utiliser cet objet en tant que paramètre context lors de l’appel de la méthode load() de l’objet Loader utilisée pour charger l’image. Le contenu AIR du sandbox de sécurité de l’application n’est pas soumis à ces restrictions.

Dans Windows, la méthode drawWithQuality() ne peut pas capturer le contenu SWF incorporé dans une page HTML dans un objet HTMLLoader dans Adobe AIR.

La méthode drawWithQuality() ne peut pas capturer un contenu PDF dans Adobe AIR. Elle ne peut pas non plus capturer un contenu SWF intégré dans HTML dont l’attribut wmode est défini sur "window" dans Adobe AIR.

Paramètres

Eléments de l’API associés

import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.text.TextField;

var tf:TextField = new TextField();
tf.text = "bitmap text";

var myBitmapData:BitmapData = new BitmapData(80, 20);
myBitmapData.drawWithQuality(tf, , , , , , StageQuality.LOW);
var bmp:Bitmap = new Bitmap(myBitmapData);
this.addChild(bmp);

Compresse l’objet BitmapData à l’aide de l’algorithme de compression sélectionné et renvoie un nouvel objet ByteArray. Ecrit les données résultantes dans l’objet ByteArray spécifié (facultatif). L’argument compressor spécifie l’algorithme de codage, qui peut être PNGEncoderOptions, JPEGEncoderOptions ou JPEGXREncoderOptions.

L’exemple suivant compresse un objet BitmapData à l’aide de JPEGEncoderOptions :

     // Compress a BitmapData object as a JPEG file.
     var bitmapData:BitmapData = new BitmapData(640,480,false,0x00FF00);
     var byteArray:ByteArray = new ByteArray();
     bitmapData.encode(new Rectangle(0,0,640,480), new flash.display.JPEGEncoderOptions(), byteArray); 

Paramètres

Eléments de l’API associés

Remplit une zone rectangulaire de pixels avec une couleur ARVB spécifiée.

Paramètres

Eléments de l’API associés

import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.geom.Rectangle;

var myBitmapData:BitmapData = new BitmapData(40, 40, false, 0x0000FF00);

var rect:Rectangle = new Rectangle(0, 0, 20, 20);
myBitmapData.fillRect(rect, 0x0000FF);

var bm:Bitmap = new Bitmap(myBitmapData);
addChild(bm);

Effectue une opération de peinture sur une image à partir de certaines coordonnées (x, y) et à l’aide d’une certaine couleur. La méthode floodFill() est similaire à l’outil Pot de peinture dans divers programmes de dessin. La couleur ARVB contient des informations alpha ainsi que des informations sur les couleurs.

Paramètres

import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.geom.Rectangle;

var myBitmapData:BitmapData = new BitmapData(40, 40, false, 0x0000FF00);

var rect:Rectangle = new Rectangle(0, 0, 20, 20);
myBitmapData.fillRect(rect, 0x000000FF);
rect = new Rectangle(15, 15, 25, 25);
myBitmapData.fillRect(rect, 0x000000FF);

myBitmapData.floodFill(10, 10, 0x00FF0000);

var bm:Bitmap = new Bitmap(myBitmapData);
addChild(bm);

Détermine le rectangle de destination affecté par l’appel de la méthode applyFilter(), en fonction d’un objet BitmapData, d’un rectangle source et d’un objet filtre spécifiés.

Par exemple, un filtre de flou affecte normalement une zone dont la taille est supérieure à celle de l’image d’origine. Une image de 100 x 200 pixels filtrée par une occurrence BlurFilter par défaut, où blurX = blurY = 4 génère un rectangle de destination de (-2,-2,104,204). La méthode generateFilterRect() permet de déterminer la taille de ce rectangle de destination à l’avance, de sorte que vous puissiez dimensionner l’image de destination en conséquence avant d’effectuer une opération de filtrage.

Certains filtres découpent leur rectangle de destination selon la taille de l’image source. Par exemple, un filtre DropShadow interne ne génère pas de résultat de taille supérieure à celle de son image source. Dans cette interface API, l’objet BitmapData fait office de limites source et n’est pas utilisé en tant que paramètre rect.

Paramètres

import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.geom.Point;
import flash.geom.Rectangle;
import flash.filters.BlurFilter;

var bmd:BitmapData = new BitmapData(80, 30, false, 0xFFCC00);
var rect:Rectangle = new Rectangle(10, 10, 40, 10);
bmd.fillRect(rect, 0xFF0000);

var pt:Point = new Point(10, 10);
var filter:BlurFilter = new BlurFilter();

trace(bmd.generateFilterRect(rect, filter));
// (x=8, y=8, w=44, h=14)

bmd.applyFilter(bmd, rect, pt, filter);
var bm:Bitmap = new Bitmap(bmd);
addChild(bm);

Détermine une zone rectangulaire qui regroupe entièrement tous les pixels d’une couleur spécifiée au sein de l’image bitmap (si le paramètre findColor est défini sur true) ou tous les pixels qui n’incluent pas la couleur spécifiée (si le paramètre findColor est défini sur false).

Par exemple, si vous disposez d’une image source et souhaitez déterminer le rectangle de l’image qui contient un canal alpha différent de zéro, utilisez {mask: 0xFF000000, color: 0x00000000} en tant que paramètres. Si le paramètre findColor est défini sur true, les limites de pixels caractérisées par (value & mask) == color (value correspondant à la valeur de la couleur du pixel) sont recherchées dans l’image entière. Si le paramètre findColor est défini sur false, la recherche des limites des pixels porte sur l’ensemble de l’image pour laquelle (value & mask) != color (où value correspond à la valeur de couleur du pixel). Pour déterminer l’espace blanc entourant une image, transmettez {mask: 0xFFFFFFFF, color: 0xFFFFFFFF} pour rechercher les limites des pixels qui ne sont pas blancs.

Paramètres

import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.geom.Rectangle;

var bmd:BitmapData = new BitmapData(80, 40, false, 0xFFFFFF);
var rect:Rectangle = new Rectangle(0, 0, 80, 20);
bmd.fillRect(rect, 0xFF0000);

var maskColor:uint = 0xFFFFFF; 
var color:uint = 0xFF0000;  
var redBounds:Rectangle = bmd.getColorBoundsRect(maskColor, color, true);
trace(redBounds); // (x=0, y=0, w=80, h=20)

var notRedBounds:Rectangle = bmd.getColorBoundsRect(maskColor, color, false);
trace(notRedBounds); // (x=0, y=20, w=80, h=20)

var bm:Bitmap = new Bitmap(bmd);
addChild(bm);

Renvoie un entier représentant une valeur de pixels RVB à partir d’un objet BitmapData à un point spécifique (x, y). La méthode getPixel() renvoie une valeur de pixels non multipliée. Aucune information alpha n’est renvoyée.

Tous les pixels d’un objet BitmapData sont stockés en tant que valeurs de couleur prémultipliées. Les valeurs des canaux de couleur rouge, vert et bleu d’un pixel image prémultiplié sont déjà multipliées par les données alpha. Par exemple, si la valeur alpha est 0, les canaux RVB sont également définis sur 0, indépendamment de leurs valeurs non multipliées. Cette perte de données peut entraîner certains problèmes lorsque vous effectuez ces opérations. Toutes les méthodes BitmapData utilisent et renvoient des valeurs non multipliées. La représentation des pixels interne est convertie du format prémultiplié au format non multiplié avant d’être renvoyée en tant que valeur. Au cours d’une opération de définition, la valeur de pixels est prémultipliée avant de définir le pixel d’image brut.

Paramètres

Eléments de l’API associés

import flash.display.BitmapData;

var bmd:BitmapData = new BitmapData(80, 40, false, 0xFF0000);

var pixelValue:uint = bmd.getPixel(0, 0);
trace(pixelValue.toString(16)); // ff0000;

Renvoie une valeur de couleur ARVB qui contient des données de canal alpha, ainsi que les données RVB. Cette méthode est similaire à la méthode getPixel() qui renvoie une couleur RVB sans les données de canal alpha.

Tous les pixels d’un objet BitmapData sont stockés en tant que valeurs de couleur prémultipliées. Les valeurs des canaux de couleur rouge, vert et bleu d’un pixel image prémultiplié sont déjà multipliées par les données alpha. Par exemple, si la valeur alpha est 0, les canaux RVB sont également définis sur 0, indépendamment de leurs valeurs non multipliées. Cette perte de données peut entraîner certains problèmes lorsque vous effectuez ces opérations. Toutes les méthodes BitmapData utilisent et renvoient des valeurs non multipliées. La représentation des pixels interne est convertie du format prémultiplié au format non multiplié avant d’être renvoyée en tant que valeur. Au cours d’une opération de définition, la valeur de pixels est prémultipliée avant de définir le pixel d’image brut.

Paramètres

Eléments de l’API associés

import flash.display.BitmapData;

var bmd:BitmapData = new BitmapData(80, 40, true, 0xFF44AACC);

var pixelValue:uint = bmd.getPixel32(0, 0);
var alphaValue:uint = pixelValue >> 24 & 0xFF;
var red:uint = pixelValue >> 16 & 0xFF;
var green:uint = pixelValue >> 8 & 0xFF;
var blue:uint = pixelValue & 0xFF;

trace(alphaValue.toString(16)); // ff
trace(red.toString(16)); // 44
trace(green.toString(16)); // aa
trace(blue.toString(16)); // cc

Génère un tableau d’octets à partir d’une zone rectangulaire de données de pixels. Écrit un entier non signé (valeur de pixel non multipliée 32 bits) pour chaque pixel dans le tableau d’octets.

Paramètres

Eléments de l’API associés

import flash.display.BitmapData;
import flash.geom.Rectangle;
import flash.utils.ByteArray;

var bmd:BitmapData = new BitmapData(80, 40, true);
var seed:int = int(Math.random() * int.MAX_VALUE);
bmd.noise(seed);

var bounds:Rectangle = new Rectangle(0, 0, bmd.width, bmd.height);
var pixels:ByteArray = bmd.getPixels(bounds);

Génère un tableau de vecteurs à partir d’une zone rectangulaire de données de pixels. Renvoie un objet Vector d’entiers non signés (une valeur de pixel non multipliée de 32 bits) pour le rectangle spécifié.

Paramètres

Calcule l’histogramme binaire à 256 valeurs d’un objet BitmapData. Cette méthode renvoie un objet Vector contenant quatre occurrences de Vector.<Number> (quatre objets Vector qui contiennent des objets Number). Les quatre occurrences de Vector représentent les composants rouge, vert, bleu et alpha, dans l’ordre. Chaque occurrence de Vector contient 256 valeurs qui représentent le nombre de remplissages d’un composant individuel, de 0 à 255.

Paramètres

Procède à la détection des clics au niveau des pixels entre une image bitmap et un point, un rectangle ou toute autre image bitmap. Un clic est défini comme le chevauchement d’un point ou d’un rectangle sur un pixel opaque, ou comme deux pixels opaque se chevauchant. Aucun étirement, aucune rotation ou autre transformation n’est pris en compte lorsque vous effectuez un test de recherche.

Si une image est opaque, elle est considérée comme étant un rectangle entièrement opaque pour cette méthode. Les deux images doivent être transparentes pour effectuer un test de recherche au niveau des pixels tenant compte de la transparence. Lorsque vous testez deux images transparentes, les paramètres de seuil alpha déterminent les valeurs des canaux alpha, comprises entre 0 et 255, considérées comme étant opaques.

Paramètres

import flash.display.BitmapData;
import flash.geom.Rectangle;
import flash.geom.Point;

var bmd1:BitmapData = new BitmapData(80, 80, true, 0x00000000);
var rect:Rectangle = new Rectangle(20, 20, 40, 40);
bmd1.fillRect(rect, 0xFF0000FF);

var pt1:Point = new Point(1, 1);
trace(bmd1.hitTest(pt1, 0xFF, pt1)); // false
var pt2:Point = new Point(40, 40);
trace(bmd1.hitTest(pt1, 0xFF, pt2)); // true

Verrouille une image de sorte que les objets qui référencent l’objet BitmapData, tels que les objets Bitmap, ne sont pas mis à jour lorsque celui-ci est modifié. Pour améliorer les performances, utilisez cette méthode en conjonction avec la méthode unlock() avant et après les appels répétés de la méthode setPixel() ou setPixel32().

Eléments de l’API associés

import flash.display.BitmapData;

var bitmapData:BitmapData = picture.bitmapData;
bitmapData.lock();
bitmapData = complexTransformation(bitmapData);
bitmapData.unlock();
picture.bitmapData = bitmapData;

Procède à la fusion canal par canal d’une image source vers une image de destination. Pour chaque canal et chaque pixel, une nouvelle valeur est calculée en fonction des valeurs de canal des pixels source et cible. Par exemple, dans le canal rouge, la nouvelle valeur est calculée comme suit (où redSrc est la valeur du canal rouge d’un pixel dans l’image source et redDest la valeur du canal rouge du pixel correspondant dans l’image cible) :

new redDest = [(redSrc * redMultiplier) + (redDest * (256 - redMultiplier))] / 256;

Les multiplicateurs redMultiplier, greenMultiplier, blueMultiplier et alphaMultiplier sont utilisés pour chaque canal de couleur. Servez-vous d’une valeur hexadécimale comprise entre 0 et 0x100 (256), où 0 spécifie que la valeur entière de la cible est utilisée dans le résultat, 0x100 spécifie que la valeur entière de la source est utilisée, et les nombres intermédiaires spécifient l’utilisation de la fusion (par exemple 0x80 pour 50 %).

Paramètres

import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.geom.Rectangle;
import flash.geom.Point;

var bmd1:BitmapData = new BitmapData(100, 80, true, 0xFF00FF00);
var bmd2:BitmapData = new BitmapData(100, 80, true, 0xFFFF0000);
var rect:Rectangle = new Rectangle(0, 0, 20, 20);
var pt:Point = new Point(20, 20);
var mult:uint = 0x80; // 50% 
bmd1.merge(bmd2, rect, pt, mult, mult, mult, mult);

var bm1:Bitmap = new Bitmap(bmd1);
addChild(bm1);
var bm2:Bitmap = new Bitmap(bmd2);
addChild(bm2);
bm2.x = 110;

Remplit une image avec des pixels représentant un bruit aléatoire.

Paramètres

Eléments de l’API associés

import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.BitmapDataChannel;

var bmd1:BitmapData = new BitmapData(80, 80);
var bmd2:BitmapData = new BitmapData(80, 80);

var seed:int = int(Math.random() * int.MAX_VALUE);
bmd1.noise(seed, 0, 0xFF, BitmapDataChannel.RED, false);
bmd2.noise(seed, 0, 0xFF, BitmapDataChannel.RED, true);

var bm1:Bitmap = new Bitmap(bmd1);
this.addChild(bm1);
var bm2:Bitmap = new Bitmap(bmd2);
this.addChild(bm2);
bm2.x = 90;

Remappe les valeurs des canaux de couleur dans une image recevant jusqu’à quatre tableaux de données de palette de couleurs, un pour chaque canal.

Les moteurs d’exécution de Flash utilisent la procédure suivante pour générer l’image résultante :

1. Une fois le calcul des valeurs rouge, vert, bleu et alpha effectué, celles-ci sont additionnées en effectuant une opération arithmétique standard s’articulant autour d’un entier 32 bits.
2. Les valeurs de couleur rouge, vert, bleu et alpha de chaque pixel sont extraites dans des valeurs distinctes comprises entre 0 et 255. Ces valeurs permettent de rechercher de nouvelles valeurs de couleur dans le tableau voulu : redArray, greenArray, blueArray et alphaArray. Chacun de ces quatre tableaux doit contenir 256 valeurs.
3. Une fois les quatre nouvelles valeurs de canaux récupérées, elles sont combinées dans une valeur ARVB standard appliquée au pixel.

Les effets multicanaux sont pris en charge par cette méthode. Chaque tableau d’entrée peut contenir des valeurs entières 32 bits ; aucun décalage ne se produit lorsque les valeurs sont additionnées. Cette routine ne prend pas en charge le verrouillage canal par canal.

Si aucun tableau n’est spécifié pour un canal, le canal de couleur est copié de l’image source vers l’image de destination.

Vous pouvez utiliser cette méthode pour de nombreux effets, tel que le mappage de palette général (qui consiste à sélectionner un canal pour le convertir en image couleur de valeur false). Vous pouvez également utiliser cette méthode pour de nombreux algorithmes de manipulation de couleurs avancés, tels que gamma, courbes, niveaux et quantification.

Paramètres

import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.geom.Rectangle;
import flash.geom.Point;

var myBitmapData:BitmapData = new BitmapData(80, 80, false, 0x00FF0000);
myBitmapData.fillRect(new Rectangle(20, 20, 40, 40), 0x0000FF00);

var redArray:Array = new Array(256);
var greenArray:Array = new Array(256);

for(var i:uint = 0; i < 255; i++) {
    redArray[i] = 0x00000000;
    greenArray[i] = 0x00000000;
}

redArray[0xFF] = 0x0000FF00;
greenArray[0xFF] = 0x00FF0000;

var bottomHalf:Rectangle = new Rectangle(0, 0, 100, 40);
var pt:Point = new Point(0, 0);
myBitmapData.paletteMap(myBitmapData, bottomHalf, pt, redArray, greenArray);

var bm1:Bitmap = new Bitmap(myBitmapData);
addChild(bm1);

Génère une image de bruit Perlin.

L’algorithme permettant de générer un bruit Perlin interpole et combine des fonctions de bruit aléatoire individuelles (appelées octaves) en fonction unique qui génère un bruit aléatoire qui semble plus naturel. Tout comme les octaves musicales, la fréquence de chaque fonction d’octave est doublée par rapport à celle qui la précède. Le bruit Perlin est décrit comme étant une « somme de bruit fractale » car il combine plusieurs ensembles de données de bruit avec différents niveaux de détails.

Vous pouvez utiliser les fonctions de bruit Perlin pour simuler des phénomènes naturels et des paysages tels que le grain du bois, les nuages ou les chaînes de montagnes. Dans la plupart des cas, la sortie d’une fonction de bruit Perlin ne s’affiche pas directement mais est utilisée pour améliorer d’autres images et leur attribuer des variations pseudo-aléatoires.

Les fonctions de bruit aléatoire numériques simples produisent souvent des images aux points durs et contrastés. On ne retrouve pas souvent ce type de contraste dur dans la nature. L’algorithme de bruit Perlin mélange plusieurs fonctions de bruit ayant des niveaux de détails différents. Cet algorithme engendre des variations plus petites parmi les valeurs des pixels environnants.

Paramètres

import flash.display.Bitmap;
import flash.display.BitmapData;

var bmd:BitmapData = new BitmapData(200, 200, false, 0x00CCCCCC);

var seed:Number = Math.floor(Math.random() * 10);
var channels:uint = BitmapDataChannel.RED | BitmapDataChannel.BLUE;
bmd.perlinNoise(100, 80, 6, seed, false, true, channels, false, null);

var bm:Bitmap = new Bitmap(bmd);
addChild(bm);

Procède à la dissolution de pixels, soit d’une image source vers une image de destination, soit en utilisant la même image. Les moteurs d’exécution de Flash utilisent une valeur randomSeed pour générer une dissolution de pixels aléatoire. La valeur renvoyée par la fonction doit être transmise lors des appels suivants pour poursuivre la dissolution de pixels jusqu’à ce qu’elle soit terminée.

Si l’image source diffère de l’image de destination, les pixels sont copiés de la source vers la destination à l’aide de toutes les propriétés. Ce processus permet de procéder à la dissolution d’une image vide dans une image entièrement remplie.

Si les images source et de destination sont équivalentes, les pixels sont remplis avec le paramètre color. Ce processus permet de procéder à la dissolution d’une image entièrement remplie. Dans ce mode, le paramètre point de destination est ignoré.

Paramètres

import flash.display.BitmapData;
import flash.display.Bitmap;
import flash.geom.Point;
import flash.geom.Rectangle;
import flash.utils.Timer;
import flash.events.TimerEvent;

var bmd:BitmapData = new BitmapData(100, 80, false, 0x00CCCCCC);
var bitmap:Bitmap = new Bitmap(bmd);
addChild(bitmap);

var tim:Timer = new Timer(20);
tim.start();
tim.addEventListener(TimerEvent.TIMER, timerHandler);
 
function timerHandler(event:TimerEvent):void {
    var randomNum:Number = Math.floor(Math.random() * int.MAX_VALUE);
    dissolve(randomNum);
}

function dissolve(randomNum:Number):void {
    var rect:Rectangle = bmd.rect;
    var pt:Point = new Point(0, 0);
    var numberOfPixels:uint = 100;
    var red:uint = 0x00FF0000;
    bmd.pixelDissolve(bmd, rect, pt, randomNum, numberOfPixels, red);
    var grayRegion:Rectangle = bmd.getColorBoundsRect(0xFFFFFFFF, 0x00CCCCCC, true);
    if(grayRegion.width == 0 && grayRegion.height == 0 ) {
        tim.stop();
    }
}

Fait défiler une image en fonction d’un certain montant en pixels (x, y). Les zones du bord situées hors de la zone de défilement demeurent inchangées.

Paramètres

import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.geom.Rectangle;

var bmd:BitmapData = new BitmapData(80, 80, true, 0xFFCCCCCC);
var rect:Rectangle = new Rectangle(0, 0, 40, 40);
bmd.fillRect(rect, 0xFFFF0000);
            
var bm:Bitmap = new Bitmap(bmd);
addChild(bm);

trace (bmd.getPixel32(50, 20).toString(16)); // ffcccccccc

bmd.scroll(30, 0); 

trace (bmd.getPixel32(50, 20).toString(16)); // ffff0000

Définit un pixel unique d’un objet BitmapData. La valeur de canal alpha actuelle du pixel de l’image est préservée au cours de cette opération. La valeur du paramètre de couleur RVB est traitée en tant que valeur de couleur non multipliée.

Remarque : lorsque vous utilisez à plusieurs reprises la méthode setPixel() ou setPixel32(), appelez la méthode lock() avant setPixel() ou setPixel32(), puis appelez la méthode unlock() une fois tous les pixels modifiés. Vous optimiserez ainsi les performances. Ce processus empêche la mise à jour des objets qui référencent cette occurrence de BitmapData tant que les modifications de pixels ne sont pas terminées.

Paramètres

Eléments de l’API associés

import flash.display.Bitmap;
import flash.display.BitmapData;

var bmd:BitmapData = new BitmapData(80, 80, false, 0xCCCCCC);

for (var i:uint = 0; i < 80; i++) {
    var red:uint = 0xFF0000;
    bmd.setPixel(i, 40, red);
}

var bm:Bitmap = new Bitmap(bmd);
addChild(bm);

Définit les valeurs de couleur et transparence alpha d’un pixel unique d’un objet BitmapData. Cette méthode est similaire à la méthode setPixel() ; la principale différence réside dans le fait que la méthode setPixel32() adopte une valeur de couleur ARVB contenant les informations de canal alpha.

Tous les pixels d’un objet BitmapData sont stockés en tant que valeurs de couleur prémultipliées. Les valeurs des canaux de couleur rouge, vert et bleu d’un pixel image prémultiplié sont déjà multipliées par les données alpha. Par exemple, si la valeur alpha est 0, les canaux RVB sont également définis sur 0, indépendamment de leurs valeurs non multipliées. Cette perte de données peut entraîner certains problèmes lorsque vous effectuez ces opérations. Toutes les méthodes BitmapData utilisent et renvoient des valeurs non multipliées. La représentation des pixels interne est convertie du format prémultiplié au format non multiplié avant d’être renvoyée en tant que valeur. Au cours d’une opération de définition, la valeur de pixels est prémultipliée avant de définir le pixel d’image brut.

Remarque : lorsque vous utilisez à plusieurs reprises la méthode setPixel() ou setPixel32(), appelez la méthode lock() avant setPixel() ou setPixel32(), puis appelez la méthode unlock() une fois tous les pixels modifiés. Vous optimiserez ainsi les performances. Ce processus empêche la mise à jour des objets qui référencent cette occurrence de BitmapData tant que les modifications de pixels ne sont pas terminées.

Paramètres

Eléments de l’API associés

import flash.display.Bitmap;
import flash.display.BitmapData;

var bmd:BitmapData = new BitmapData(80, 80, true, 0xFFCCCCCC);

for (var i:uint = 0; i < 80; i++) {
    var red:uint = 0x60FF0000;
    bmd.setPixel32(i, 40, red);
}

var bm:Bitmap = new Bitmap(bmd);
addChild(bm);

Convertit un tableau d’octets en une zone rectangulaire de données de pixels. La méthode ByteArray.readUnsignedInt() est appelée pour chaque pixel et la valeur renvoyée est écrite dans ce dernier. Si le tableau d’octets prend fin avant l’écriture du rectangle complet, la fonction renvoie une valeur. Le système s’attend à ce que les données du tableau d’octets soient des valeurs de pixel ARVB 32 bits. Aucune recherche n’est effectuée dans le tableau d’octets avant ou après la lecture des pixels.

Paramètres

Eléments de l’API associés

import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.utils.ByteArray;
import flash.geom.Rectangle;

var bmd1:BitmapData = new BitmapData(100, 100, true, 0xFFCCCCCC);
var bmd2:BitmapData = new BitmapData(100, 100, true, 0xFFFF0000);

var rect:Rectangle = new Rectangle(0, 0, 100, 100);
var bytes:ByteArray = bmd1.getPixels(rect);

bytes.position = 0;
bmd2.setPixels(rect, bytes);

var bm1:Bitmap = new Bitmap(bmd1);
addChild(bm1);
var bm2:Bitmap = new Bitmap(bmd2);
addChild(bm2);
bm2.x = 110;

Convertit un objet Vector en une zone rectangulaire de données de pixels. Pour chaque pixel, un élément Vector est lu et écrit dans le pixel BitmapData. Le système s’attend à ce que les données de l’objet Vector soient des valeurs de pixel ARVB 32 bits.

Paramètres

Teste les valeurs de pixels d’une image selon un seuil spécifié et définit les pixels qui réussissent le test sur de nouvelles valeurs de couleur. L’utilisation de la méthode threshold() permet d’isoler et de remplacer les gammes de couleurs d’une image et d’effectuer d’autres opérations logiques sur les pixels de l’image.

La logique du test de la méthode threshold() est définie comme suit :

1. Si ((pixelValue & mask) operation (threshold & mask)), définissez le pixel sur color.
2. Dans le cas contraire, si copySource == true, réglez le pixel sur la valeur de pixel correspondante dans sourceBitmap.

Le paramètre operation spécifie l’opérateur de comparaison à utiliser pour le test de seuil. Par exemple, si vous utilisez « == » en tant que paramètre operation, vous pouvez isoler une valeur de couleur spécifique dans une image. Ou si vous utilisez {operation: "<", mask: 0xFF000000, threshold: 0x7F000000, color: 0x00000000}, vous pouvez définir tous les pixels de destination comme étant entièrement transparents lorsque la valeur alpha du pixel de l’image source est inférieure à 0x7F. Vous pouvez utiliser cette technique pour les transitions animées et d’autres effets.

Paramètres

import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.BitmapDataChannel;
import flash.geom.Point;
import flash.geom.Rectangle;

var bmd1:BitmapData = new BitmapData(200, 200, true, 0xFFCCCCCC);

var seed:int = int(Math.random() * int.MAX_VALUE);
var channels:uint = BitmapDataChannel.RED | BitmapDataChannel.BLUE;
bmd1.perlinNoise(100, 80, 12, seed, false, true, channels, false, null);

var bitmap1:Bitmap = new Bitmap(bmd1);
addChild(bitmap1);

var bmd2:BitmapData = new BitmapData(200, 200, true, 0xFFCCCCCC);
var pt:Point = new Point(0, 0);
var rect:Rectangle = new Rectangle(0, 0, 200, 200);
var threshold:uint =  0x00800000; 
var color:uint = 0x20FF0000;
var maskColor:uint = 0x00FF0000;
bmd2.threshold(bmd1, rect, pt, ">", threshold, color, maskColor, true);

var bitmap2:Bitmap = new Bitmap(bmd2);
bitmap2.x = bitmap1.x + bitmap1.width + 10;
addChild(bitmap2);

Déverrouille une image de sorte que les objets qui référencent l’objet BitmapData, tels que les objets Bitmap, sont mis à jour lorsque celui est modifié. Pour améliorer les performances, utilisez cette méthode en conjonction avec la méthode lock() avant et après les appels répétés de la méthode setPixel() ou setPixel32().

Paramètres

Eléments de l’API associés

import flash.display.BitmapData;

var bitmapData:BitmapData = picture.bitmapData;
bitmapData.lock();
bitmapData = complexTransformation(bitmapData);
bitmapData.unlock();
picture.bitmapData = bitmapData;

1. Une propriété url est créée pour désigner l’emplacement et le nom du fichier d’image.
2. Le constructeur de classe crée un objet Loader, qui crée à son tour un écouteur d’événements, qui est transmis lorsque la méthode completeHandler() termine la manipulation de l’image.
3. Le paramètre request de l’objet URLRequest est ensuite transmise à loader.load(), qui charge l’image en mémoire à l’aide d’un objet d’affichage.
4. L’image est ensuite placée dans la liste d’affichage, qui affiche l’image aux coordonnées x = 0, y = 0.
5. La méthode completeHandler() effectue ensuite les opérations suivantes :
   • Crée un deuxième objet Loader, ainsi qu’un objet Bitmap, qui est initialisé avec l’objet Loader.
   • Crée un deuxième objet Bitmap, duplicate, qui appelle en retour la méthode duplicateImage(), qui crée elle-même un double de l’image d’origine.
   • Crée un objet BitmapData qui est associé à l’objet BitmapData de l’objet duplicate.
   • Crée un objet Rectangle qui est initialisé avec les mêmes coordonnées, la même largeur et hauteur, que l’image d’origine.
   • Crée un objet Point, qui emploie par défaut les coordonnées x = 0, y = 0.
   • Crée les variables suivantes :
     • operation — Applique la nouvelle couleur lorsque la valeur de seuil est supérieure ou égale à l’original.
     • threshold — La valeur de chaque pixel est comparée (dans cet exemple, gris clair avec une valeur alpha de 0xCC).
     • color — La couleur des pixels qui répondent aux critères imposés, soit jaune uni dans ce cas.
     • mask — Le contraire exact de la couleur (bleu transparent).
     • copySource — Défini sur false, indique que les valeurs des pixels ne sont pas copiées si les critères de la valeur de seuil ne sont pas réunis. Cette valeur n’a aucune signification, car l’image est dupliquée et seuls les pixels qui répondent aux critères de seuil sont modifiés.
   • Appelle la méthode threshold() à l’aide des variables précédentes. L’équation de seuil qui en résulte figure ci-dessous : if (current pixel Value & 0x000000FF) >= (0xCCCCCCCC & 0x000000FF) then set pixel to 0xFFFFFF00.

Remarques :

• Vous devrez compiler le fichier SWF en définissant Sécurité de lecture locale sur Accès aux fichiers locaux uniquement.
• Pour exécuter cet exemple, il est nécessaire de placer un fichier intitulé Image.txt dans le même répertoire que votre fichier SWF.
• Il est recommandé d’utiliser une image qui ne dépasse pas 80 pixels de largeur.

package {
    import flash.display.Bitmap;
    import flash.display.BitmapData;
    import flash.display.Loader;
    import flash.display.Sprite;
    import flash.events.*;
    import flash.geom.Point;
    import flash.geom.Rectangle;
    import flash.net.URLRequest;

    public class BitmapDataExample extends Sprite {
        private var url:String = "Image.gif";
        private var size:uint = 80;

        public function BitmapDataExample() {
            configureAssets();
        }

        private function configureAssets():void {
            var loader:Loader = new Loader();
            loader.contentLoaderInfo.addEventListener(Event.COMPLETE, completeHandler);
            loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);

            var request:URLRequest = new URLRequest(url);
            loader.x = size * numChildren;
            loader.load(request);
            addChild(loader);
        }

        private function duplicateImage(original:Bitmap):Bitmap {
            var image:Bitmap = new Bitmap(original.bitmapData.clone());
            image.x = size * numChildren;
            addChild(image);
            return image;
        }

        private function completeHandler(event:Event):void {
            var loader:Loader = Loader(event.target.loader);
            var image:Bitmap = Bitmap(loader.content);

            var duplicate:Bitmap = duplicateImage(image);
            var bitmapData:BitmapData = duplicate.bitmapData;
            var sourceRect:Rectangle = new Rectangle(0, 0, bitmapData.width, bitmapData.height);
            var destPoint:Point = new Point();
            var operation:String = ">=";
            var threshold:uint = 0xCCCCCCCC;
            var color:uint = 0xFFFFFF00;
            var mask:uint = 0x000000FF;
            var copySource:Boolean = true;

            bitmapData.threshold(bitmapData,
                                 sourceRect,
                                 destPoint,
                                 operation,
                                 threshold,
                                 color,
                                 mask,
                                 copySource);
        }
        
        private function ioErrorHandler(event:IOErrorEvent):void {
            trace("Unable to load image: " + url);
        }
    }
}