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 du bitmap est défini sur cette couleur.

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

Les largeur et hauteur maximales d'un objet BitmapData sont de 2 880 pixels. 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, Flash Player utilise une copie temporaire de l’objet pour effectuer le filtrage. Pour optimiser les performances, évitez ce cas de figure.

Paramètres

Voir aussi

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 du bitmap contenu.

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

Voir aussi

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 (0xFF8800 et 0xCC6600). 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

Voir aussi

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;

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.

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 de Flash Player. 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 le bitmap doit être lissé lorsqu’il est redimensionné (cette opération ne fonctionne que si l’objet source est un objet BitmapData).

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 programmation.

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.

Remarque : l’objet source et (dans le cas d’un objet Sprite ou MovieClip) tous ses objets enfants doivent provenir du même domaine que l’appelant ou résider dans un fichier SWF accessible à l'appelant par le biais de la méthode Security.allowDomain(). Si ces conditions ne sont pas remplies, la méthode draw() ne dessine rien.

Cette méthode est prise en charge sur RTMP dans Flash Player Mise à jour 3 et supérieures. 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, consultez les propriétés Client.audioSampleAccess et Client.videoSampleAccess dans le Guide de référence ActionScript d'Adobe Flash Media Server côté serveur.

Paramètres

	source:IBitmapDrawable — Objet d'affichage ou objet BitmapData à dessiner sur l’objet BitmapData. (Les classes DisplayObject et BitmapData mettent en œuvre l’interface IBitmapDrawable.)
	matrix:Matrix (default = null) — Objet Matrix utilisé pour redimensionner, faire pivoter ou traduire les coordonnées du bitmap. Si vous ne souhaitez pas appliquer une matrice de transformation à l’image, réglez ce paramètre sur une matrice d’identité, créée à l’aide du constructeur new Matrix() par défaut, ou transmettez une valeur null.
	colorTransform:ColorTransform (default = null) — Objet ColorTransform utilisé pour définir les valeurs de couleur du bitmap. Si aucun objet n'est fourni, les couleurs de l'image bitmap ne sont pas transformées. Si ce paramètre doit être transmis, alors que vous ne souhaitez pas transformer l’image, réglez-le sur un objet ColorTransform créé à l'aide du constructeur new ColorTransform() par défaut.
	blendMode:String (default = null) — Chaîne extraite de la classe flash.display.BlendMode, qui spécifie le mode de fondu à appliquer au·bitmap générée par l’opération.
	clipRect:Rectangle (default = null) — Objet Rectangle qui définit la zone de l'image source à dessiner. Si cette valeur n'est pas fournie, aucun découpage n'est effectué et l’objet source est dessiné dans sa totalité.
	smoothing:Boolean (default = false) — Une valeur booléenne qui détermine si l'objet BitmapData doit être lissé lors d'une mise à l'échelle ou d'une rotation demandée par le paramètre matrix. Le paramètre smoothing s'applique uniquement lorsque le paramètre source est un objet BitmapData. Lorsque le paramètre smoothing est défini sur false, l'image BitmapData pivotée ou mise à l'échelle peut sembler pixélisée ou irrégulière. Par exemple, les deux images suivantes utilisent le même objet BitmapData pour le paramètre source, mais le paramètre smoothing est défini sur true à gauche et sur false à droite : Le traçage d'un bitmap avec le paramètre smoothing défini sur true prend plus de temps que lorsque smoothing est défini sur false.

Voir aussi

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);

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

Paramètres

Voir aussi

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

Voir aussi

import flash.display.BitmapData;

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

var pixelValue:uint = bmd.getPixel(1, 1);
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

Voir aussi

import flash.display.BitmapData;

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

var pixelValue:uint = bmd.getPixel32(1, 1);
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. Ecrit un entier non signé (valeur de pixel non multipliée 32 bits) pour chaque pixel dans le tableau d’octets.

Paramètres

Voir aussi

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);

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. 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 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().

Voir aussi

import flash.display.BitmapData;

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

Procède au mélange 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

Voir aussi

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.

Flash Player utilise 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.

Remarque : on doit l'algorithme de bruit Perlin à Ken Perlin, qui a été le premier à le mettre au point après avoir créé des images graphiques sur ordinateur pour le film Tron sorti en 1982. Perlin a reçu un Oscar pour avoir mis au point la fonction de bruit Perlin en 1997.

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. Flash Player utilise 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

Voir aussi

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

Voir aussi

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

Voir aussi

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;

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

Voir aussi

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);
        }
    }
}