BitmapData  - AS3

L'altezza dell'immagine bitmap, espressa in pixel.

Il rettangolo che definisce le dimensioni e la posizione dell'immagine bitmap. La parte superiore e sinistra del rettangolo hanno valore zero; la larghezza e l'altezza sono uguali alla larghezza e all'altezza espresse in pixel dell'oggetto BitmapData.

Indica se l'immagine bitmap supporta la trasparenza per pixel. Potete impostare questo valore solo quando create un oggetto BitmapData passando true per il parametro transparent della funzione di costruzione. Quindi, dopo aver creato un oggetto BitmapData, potete controllare se supporta la trasparenza per pixel verificando se il valore della proprietà transparent è true.

La larghezza dell'immagine bitmap, espressa in pixel.

Crea un nuovo oggetto BitmapData con specificati valori di larghezza e altezza. Se specificate un valore del parametro fillColor, ogni pixel nella bitmap viene impostato su tale colore.

Per impostazione predefinita, l'immagine bitmap creata è trasparente, a meno che non passiate il valore false per il parametro transparent. Una volta creata un'immagine bitmap opaca, non è possibile convertirla in una bitmap trasparente. Ogni pixel in un'immagine bitmap opaca utilizza solo 24 bit di informazioni dei canali di colore. Se definite l'immagine bitmap come trasparente, ogni pixel utilizza 32 bit di informazioni dei canali di colore, compreso il canale di trasparenza alfa.

In AIR 1.5 e Flash Player 10, la dimensione massima di un oggetto BitmapData è di 8.191 pixel in larghezza o altezza, mentre il numero totale di pixel non può essere superiore a 16.777.215. (Quindi, se un oggetto BitmapData ha una larghezza di 8.191 pixel, può avere solo una lunghezza di 2.048 pixel.) In Flash Player 9 e versioni precedenti e in AIR 1.1 e versioni precedenti, la limitazione è di 2.880 pixel in altezza e 2.880 pixel in larghezza. Se per la larghezza e l'altezza si specifica un valore maggiore di 2880, non viene creata una nuova istanza.

Usa un'immagine di origine e un oggetto filtro per generare l'immagine filtrata.

Questo metodo si basa sul comportamento degli oggetti filtro incorporati, che determinano il rettangolo di destinazione su cui agisce un rettangolo di origine di input.

Dopo l'applicazione di un filtro, l'immagine risultante può apparire più grande di quella di input. Ad esempio, se si utilizza una classe BlurFilter per sfocare un rettangolo di origine con dimensioni (50,50,100,100) e un punto di destinazione con dimensioni (10,10), l'area che viene modificata nell'immagine di destinazione risulta più grande di (10,10,60,60) a causa della sfocatura. Questo comportamento si verifica internamente durante la chiamata a applyFilter().

Se il parametro sourceRect del parametro sourceBitmapData è una regione interna, ad esempio (50,50,100,100) in un'immagine 200 x 200, il filtro utilizza i pixel di origine fuori del parametro sourceRect per generare il rettangolo di destinazione.

Se l'oggetto BitmapData e l'oggetto specificato come parametro sourceBitmapData coincidono, l'applicazione utilizza una copia temporanea dell'oggetto per eseguire il filtro. Per ottenere risultati ottimali, evitate questa situazione.

Parametri

Altri esempi

Elementi API correlati

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

Restituisce un nuovo oggetto BitmapData che è un clone dell'istanza originale con una copia esatta dell'immagine bitmap contenuta.

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

Regola i valori di colore in un'area specificata di un'immagine bitmap utilizzando un oggetto ColorTransform. Se il rettangolo corrisponde ai bordi dell'immagine bitmap, questo metodo trasforma i valori del colore dell'intera immagine.

Parametri

Elementi API correlati

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

Confronta due oggetti BitmapData. Se i due oggetti BitmapData hanno le stesse dimensioni (larghezza e altezza), il metodo restituisce un nuovo oggetto BitmapData nel quale ogni pixel è la "differenza" tra i pixel dei due oggetti di origine:

• Se due pixel sono uguali, il pixel di differenza è 0x00000000.
• Se due pixel hanno valori RGB diversi (ignorando il valore alfa), la differenza è data da 0xRRGGBB, dove RR/GG/BB sono i singoli valori di differenza tra i canali rosso, verde e blu (il valore in pixel nell'oggetto di origine meno il valore in pixel nell'oggetto otherBitmapData). In questo caso le differenze del canale alfa vengono ignorate.
• Se solo il valore del canale alfa è diverso, il valore in pixel è 0xZZFFFFFF, dove ZZ rappresenta la differenza tra i valori alfa (il valore alfa nell'oggetto di origine meno il valore alfa nell'oggetto otherBitmapData).

Ad esempio, esaminate i due seguenti oggetti BitmapData:

     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
     

Nota: i colori utilizzati per riempire i due oggetti BitmapData hanno valori RGB leggermente diversi (0xFF0000 e 0xFFAA00). Il risultato del metodo compare() è un nuovo oggetto BitmapData in cui ogni pixel mostra la differenza nei valori RGB tra le due bitmap.

Osservate i due oggetti BitmapData seguenti, in cui i colori RGB sono uguali ma i valori alfa sono diversi:

     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
     

Il risultato del metodo compare() è un nuovo oggetto BitmapData in cui ogni pixel mostra la differenza nei valori alfa tra le due bitmap.

Se gli oggetti BitmapData sono equivalenti (con la stessa larghezza e altezza e valori di pixel identici), il metodo restituisce il numero 0.

Se le larghezze degli oggetti BitmapData non sono uguali, il metodo restituisce -3.

Se invece le altezze non sono uguali ma le larghezze coincidono, il metodo restituisce -4.

L'esempio seguente confronta due oggetti Bitmap con larghezze diverse (50 e 60):

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

Parametri

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;

Trasferisce i dati da un canale di un altro oggetto BitmapData o dell'oggetto BitmapData corrente a un canale dell'oggetto BitmapData corrente. Tutti i dati degli altri canali dell'oggetto BitmapData di destinazione vengono mantenuti.

Il valore del canale di origine e il valore del canale di destinazione possono essere i seguenti:

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

Parametri

Elementi API correlati

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

Fornisce una routine veloce per la modifica dei pixel tra immagini prive di effetti di allungamento, rotazione o colore. Il metodo copia un'area rettangolare di un'immagine di origine in un'area rettangolare delle stesse dimensioni in corrispondenza del punto di destinazione dell'oggetto BitmapData di destinazione.

Se includete i parametri alphaBitmap e alphaPoint, potete utilizzare un'immagine secondaria come origine alfa per l'immagine di origine. Se l'immagine di origine contiene dei dati relativi all'alfa, entrambi i gruppi di dati alfa vengono utilizzati per comporre i pixel dall'immagine di origine all'immagine di destinazione. Il parametro alphaPoint è il punto all'interno dell'immagine alfa che corrisponde all'angolo superiore sinistro del rettangolo di origine. Gli eventuali pixel fuori dell'immagine di origine e dell'immagine alfa non vengono copiati nell'immagine di destinazione.

La proprietà mergeAlpha controlla se il canale alfa viene utilizzato quando un'immagine trasparente viene copiata in un'altra immagine trasparente. Per copiare i pixel con i dati relativi al canale alfa, impostate la proprietà mergeAlpha su true. Per impostazione predefinita, la proprietà mergeAlpha è false.

Parametri

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;

Riempie un array di byte da un’area rettangolare di dati pixel. A partire dall’indice position del ByteArray, questo metodo scrive nell’array di byte un numero intero senza segno (un valore di pixel a 32 bit non moltiplicato) per ogni pixel. Se necessario, la dimensione dell’array viene aumentata fino al numero di byte necessario per contenere tutti i pixel.

Parametri

Elementi API correlati

Libera la memoria utilizzata per memorizzare l'oggetto BitmapData.

Quando si chiama il metodo dispose() su un'immagine, la larghezza e l'altezza dell'immagine vengono impostate su 0. Tutte le chiamate successive a metodi o proprietà di questa istanza BitmapData falliscono e viene generata un'eccezione.

BitmapData.dispose() rilascia immediatamente la memoria occupata dagli effettivi dati bitmap (una bitmap può utilizzare fino a 64 MB di memoria). Dopo l'utilizzo di BitmapData.dispose(), l'oggetto BitmapData non è più utilizzabile. Se chiamate funzioni sull'oggetto BitmapData, il runtime Flash genera un'eccezione. BitmapData.dispose() non sottopone tuttavia l'oggetto BitmapData a garbage collection (circa 128 byte). La memoria occupata dall'effettivo oggetto BitmapData viene rilasciata nel momento in cui su tale oggetto viene eseguito il garbage collector.

Elementi API correlati

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
}

Disegna l'oggetto di visualizzazione source sull'immagine bitmap utilizzando il renderer di vettori del runtime Flash. Potete specificare matrix, colorTransform, blendMode e un parametro clipRect di destinazione per controllare l'esecuzione del rendering. Facoltativamente, potete specificare se la bitmap deve essere smussata quando viene modificata in scala (questa soluzione funziona solo con un oggetto di origine BitmapData).

Nota: il metodo drawWithQuality() funziona esattamente come il metodo draw(), ma invece di utilizzare la proprietà Stage.quality per determinare la qualità del rendering vettoriale, occorre specificare il parametro quality del metodo drawWithQuality().

Questo metodo corrisponde al modo in cui gli oggetti vengono disegnati mediante il renderer di vettori standard per gli oggetti nell'interfaccia dello strumento di creazione.

L'oggetto di visualizzazione di origine non utilizza per questa chiamata nessuna delle relative trasformazioni applicate. Viene considerato come se facesse parte della libreria o del file, senza trasformazioni di matrice, trasformazioni di colore e metodo di fusione. Per disegnare un oggetto di visualizzazione (ad esempio un clip filmato) utilizzandone le proprietà di trasformazione, potete copiarne la proprietà transform nella proprietà transform dell'oggetto Bitmap che utilizza l'oggetto BitmapData.

Questo metodo è supportato attraverso RTMP in Flash Player 9.0.115.0 e versioni successive e in Adobe AIR. Potete controllare l'accesso agli streaming su Flash Media Server in uno script lato server. Per maggiori informazioni, vedete le proprietà Client.audioSampleAccess e Client.videoSampleAccess in Server-Side ActionScript Language Reference for Adobe Flash Media Server (Guida di riferimento del linguaggio ActionScript server-side per Adobe Flash Media Server).

Se l'oggetto source (nel caso di un oggetto Sprite o MovieClip) tutti i suoi oggetti secondari non provengono dallo stesso dominio del chiamante oppure non sono inclusi in un contenuto accessibile al chiamante mediante una chiamata al metodo Security.allowDomain(), una chiamata a draw() genera un'eccezione SecurityError. Questa limitazione non vale per il contenuto AIR nella funzione di sicurezza sandbox dell'applicazione.

Esistono anche delle limitazioni all'uso di un'immagine bitmap caricata come origine. Una chiamata al metodo draw() viene completata correttamente se l'immagine caricata proviene dallo stesso dominio del chiamante. Inoltre, un file di criteri validi tra più domini presente sul server dell'immagine può autorizzare il dominio del contenuto SWF che chiama il metodo draw(). In tal caso, dovete impostare la proprietà checkPolicyFile di un oggetto LoaderContext e utilizzare tale oggetto come parametro context quando chiamate il metodo load() dell'oggetto Loader utilizzato per caricare l'immagine. Queste limitazioni di sicurezza non valgono per il contenuto AIR presente nella funzione di sicurezza sandbox.

In Windows, il metodo draw() non può catturare il contenuto SWF incorporato in una pagina HTML in un oggetto HTMLLoader in Adobe AIR.

Il metodo draw() non può catturare il contenuto PDF in Adobe AIR né il contenuto SWF incorporato nel codice HTML in cui l'attributo wmode è impostato su "window" in Adobe AIR.

Parametri

Elementi API correlati

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

Disegna l'oggetto di visualizzazione source sull'immagine bitmap utilizzando il renderer di vettori del runtime Flash. Potete specificare matrix, colorTransform, blendMode e un parametro clipRect di destinazione per controllare l'esecuzione del rendering. Facoltativamente, potete specificare se la bitmap deve essere smussata quando viene modificata in scala (questa soluzione funziona solo con un oggetto di origine BitmapData).

Nota: il metodo drawWithQuality() funziona esattamente come il metodo draw(), ma invece di utilizzare la proprietà Stage.quality per determinare la qualità del rendering vettoriale, occorre specificare il parametro quality del metodo drawWithQuality().

Questo metodo corrisponde al modo in cui gli oggetti vengono disegnati mediante il renderer di vettori standard per gli oggetti nell'interfaccia dello strumento di creazione.

L'oggetto di visualizzazione di origine non utilizza per questa chiamata nessuna delle relative trasformazioni applicate. Viene considerato come se facesse parte della libreria o del file, senza trasformazioni di matrice, trasformazioni di colore e metodo di fusione. Per disegnare un oggetto di visualizzazione (ad esempio un clip filmato) utilizzandone le proprietà di trasformazione, potete copiarne la proprietà transform nella proprietà transform dell'oggetto Bitmap che utilizza l'oggetto BitmapData.

Questo metodo è supportato attraverso RTMP in Flash Player 9.0.115.0 e versioni successive e in Adobe AIR. Potete controllare l'accesso agli streaming su Flash Media Server in uno script lato server. Per ulteriori informazioni vedete le proprietà Client.audioSampleAccess e Client.videoSampleAccess nel manuale Server-Side ActionScript Language Reference for Adobe Flash Media Server.

Se l’oggetto source (nel caso di un oggetto Sprite o MovieClip) tutti i suoi oggetti secondari non provengono dallo stesso dominio del chiamante oppure non sono inclusi in un contenuto accessibile al chiamante mediante una chiamata al metodo Security.allowDomain(), una chiamata a drawWithQuality() genera un’eccezione SecurityError. Questa limitazione non vale per il contenuto AIR nella funzione di sicurezza sandbox dell'applicazione.

Esistono anche delle limitazioni all'uso di un'immagine bitmap caricata come origine. Una chiamata al metodo drawWithQuality() viene completata correttamente se l’immagine caricata proviene dallo stesso dominio del chiamante. Inoltre, un file di criteri validi tra più domini presente sul server dell’immagine può autorizzare il dominio del contenuto SWF che chiama il metodo drawWithQuality(). In tal caso, dovete impostare la proprietà checkPolicyFile di un oggetto LoaderContext e utilizzare tale oggetto come parametro context quando chiamate il metodo load() dell'oggetto Loader utilizzato per caricare l'immagine. Queste limitazioni di sicurezza non valgono per il contenuto AIR presente nella funzione di sicurezza sandbox.

In Windows, il metodo drawWithQuality() non può catturare il contenuto SWF incorporato in una pagina HTML in un oggetto HTMLLoader in Adobe AIR.

Il metodo drawWithQuality() non può catturare il contenuto PDF in Adobe AIR né il contenuto SWF incorporato nel codice HTML in cui l'attributo wmode è impostato su "window" in Adobe AIR.

Parametri

Elementi API correlati

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

Comprime questo oggetto BitmapData utilizzando l’algoritmo di compressione selezionato e restituisce un nuovo oggetto ByteArray. Facoltativamente, scrive i dati risultanti nel ByteArray specificato. L’argomento compressor specifica l’algoritmo di codifica e può essere PNGEncoderOptions, JPEGEncoderOptions o JPEGXREncoderOptions.

Nell’esempio seguente viene compresso un oggetto BitmapData utilizzando 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); 

Parametri

Elementi API correlati

Riempie un'area rettangolare di pixel con un determinato colore ARGB.

Parametri

Elementi API correlati

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

Esegue un'operazione di riempimento su un'immagine partendo da una coordinata (x, y) e applicando un riempimento di un determinato colore. Il metodo floodFill() è simile allo strumento "secchio di vernice" presente in molti programmi di disegno. Il colore è un colore ARGB che contiene le informazioni sia sull'alfa che sui colori.

Parametri

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

Determina il rettangolo di destinazione su cui agisce la chiamata a applyFilter(), dati un oggetto BitmapData, un rettangolo di origine e un oggetto filter.

Ad esempio, un filtro sfocatura agisce di solito su un'area più vasta delle dimensioni dell'immagine originale. Un'immagine di 100 x 200 pixel che viene filtrata da un'istanza BlurFilter predefinita dove blurX = blurY = 4 genera un rettangolo di destinazione di (-2,-2,104,204). Il metodo generateFilterRect() consente di determinare in anticipo le dimensioni di questo rettangolo di destinazione per stabilire correttamente le dimensioni dell'immagine di destinazione prima di un'operazione di filtro.

Alcuni filtri troncano il rettangolo di destinazione in base alle dimensioni dell'immagine di origine. Ad esempio, un filtro DropShadow interno non genera un risultato più grande della relativa immagine di origine. In questa API, l'oggetto BitmapData viene utilizzato come parametro bounds di origine e non come parametro rect di origine.

Parametri

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

Determina un'area rettangolare che racchiude completamente tutti i pixel di un colore specificato all'interno dell'immagine bitmap (se il parametro findColor è impostato su true) oppure che racchiude completamente tutti i pixel che non includono il colore specificato (se findColor è false).

Ad esempio, se savete un'immagine di origine e desiderate determinare il rettangolo che contiene un canale alfa diverso da 0, passate {mask: 0xFF000000, color: 0x00000000} come parametri. Se il parametro findColor è impostato su true, vengono cercati all'interno dell'intera immagine i limiti dei pixel per i quali (value & mask) == color (dove value è il valore di colore del pixel). Se il parametro findColor è impostato su false, vengono cercati all'interno dell'intera immagine i limiti dei pixel per i quali (value & mask) != color (dove value è il valore del colore del pixel). Per determinare lo spazio bianco attorno all'immagine, passate {mask: 0xFFFFFFFF, color: 0xFFFFFFFF} per trovare i limiti dei pixel diversi dal bianco.

Parametri

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

Restituisce un numero intero che rappresenta un valore in pixel RGB corrispondente a un punto specifico di un oggetto BitmapData (x, y). Il metodo getPixel() restituisce un valore di pixel non moltiplicato. Non viene restituita alcuna informazione sull'alfa.

Tutti i pixel di un oggetto BitmapData vengono memorizzati sotto forma di valori di colore premoltiplicati. In un pixel di immagine premoltiplicato i valori dei canali rosso, verde e blu sono già moltiplicati per i dati dell'alfa. Ad esempio, se il valore dell'alfa è 0, anche i canali RGB sono 0, indipendentemente dai relativi valori non moltiplicati. Questa perdita di dati può provocare dei problemi durante l'esecuzione delle operazioni. Tutti i metodi BitmapData accettano e restituiscono valori non moltiplicati. La rappresentazione in pixel interni viene convertita dal formato premoltiplicato a non moltiplicato prima di essere restituita come valore. Durante un'operazione di impostazione, il valore in pixel viene premoltiplicato prima di impostare il pixel dell'immagine grezza.

Parametri

Elementi API correlati

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;

Restituisce un valore di colore ARGB che contiene dati di canale alfa e dati RGB. Questo metodo è simile al metodo getPixel(), che restituisce un colore RGB senza dati relativi al canale alfa.

Tutti i pixel di un oggetto BitmapData vengono memorizzati sotto forma di valori di colore premoltiplicati. In un pixel di immagine premoltiplicato i valori dei canali rosso, verde e blu sono già moltiplicati per i dati dell'alfa. Ad esempio, se il valore dell'alfa è 0, anche i canali RGB sono 0, indipendentemente dai relativi valori non moltiplicati. Questa perdita di dati può provocare dei problemi durante l'esecuzione delle operazioni. Tutti i metodi BitmapData accettano e restituiscono valori non moltiplicati. La rappresentazione in pixel interni viene convertita dal formato premoltiplicato a non moltiplicato prima di essere restituita come valore. Durante un'operazione di impostazione, il valore in pixel viene premoltiplicato prima di impostare il pixel dell'immagine grezza.

Parametri

Elementi API correlati

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

Genera un array di byte da un'area rettangolare di dati pixel. Scrive nell'array di byte un numero intero senza segno (un valore di pixel a 32 bit non moltiplicato) per ogni pixel.

Parametri

Elementi API correlati

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

Genera un array Vector da un'area rettangolare di dati pixel. Restituisce un oggetto Vector di numeri interi senza segno (un valore di pixel a 32 bit non moltiplicato) per il rettangolo specificato.

Parametri

Calcola un istogramma di numeri binari con 256 valori di un oggetto BitmapData. Questo metodo restituisce un oggetto Vector contenente 4 Vector.<Number> istanze (4 oggetti Vector che contengono oggetti Number). Le 4 istanze Vector rappresentano nell'ordine i componenti rosso, verde, blu e alpha. Ogni istanza Vector contiene 256 valori che rappresentano il conteggio di popolazione di un valore componente individuale, da 0 a 255.

Parametri

Esegue un rilevamento per zone a livello di pixel tra una singola immagine bitmap e un punto, un rettangolo o un'altra immagine bitmap. Una zona attiva viene definita come una sovrapposizione di un punto o un rettangolo su un pixel opaco o due pixel opachi sovrapposti. Durante l'esecuzione del rilevamento per zone non vengono considerati allungamenti, rotazioni o altre trasformazioni per nessun oggetto.

Se un'immagine è opaca, questo metodo la considera un rettangolo completamente opaco. Entrambe le immagini devono essere trasparenti per eseguire un rilevamento per zone a livello di pixel che consideri la trasparenza. Quando si verificano due immagini trasparenti, i parametri di soglia dell'alfa controllano quali valori di canale alfa (da 0 a 255) vengono considerati opachi.

Parametri

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

Blocca un'immagine in modo che gli eventuali oggetti che fanno riferimento all'oggetto BitmapData, ad esempio gli oggetti Bitmap, non vengano aggiornati quando questo oggetto BitmapData viene modificato. Per migliorare le prestazioni, utilizzate questo metodo in combinazione con unlock() prima e dopo numerose chiamate al metodo setPixel() o setPixel32().

Elementi API correlati

import flash.display.BitmapData;

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

Esegue una fusione per ogni canale da un'immagine di origine a una di destinazione. Per ogni canale e ogni pixel, viene calcolato un nuovo valore in base ai valori dei canali dell'origine e ai pixel di destinazione. Ad esempio, nel canale rosso, il nuovo valore viene calcolato come segue (redSrc è il valore del canale rosso per un pixel dell'immagine di origine e redDest è il valore del canale rosso per il pixel corrispondente dell'immagine di destinazione):

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

I valori redMultiplier, greenMultiplier, blueMultiplier e alphaMultiplier sono i moltiplicatori utilizzati per ciascun canale di colore. Utilizzate un valore esadecimale che va da 0 a 0x100 (256), dove 0 specifica il valore completo dalla destinazione utilizzata nel risultato, 0x100 specifica il valore completo dall'origine utilizzata e i numeri compresi specificano la fusione utilizzata (ad esempio 0x80 per 50%).

Parametri

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;

Riempie un'immagine con pixel che rappresentano disturbi a caso.

Parametri

Elementi API correlati

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;

Mappa nuovamente i valori dei canali di colore di un'immagine che ha fino a quattro array di dati della tavolozza, uno per ogni canale.

I runtime Flash utilizzano la seguente procedura per generare l'immagine risultante:

1. Una volta calcolati, i valori del rosso, del verde, del blu e della trasparenza alfa vengono sommati mediante l'aritmetica standard a numeri interi a 32 bit.
2. I valori dei canali rosso, verde, blu e alfa di ogni pixel vengono estratti sotto forma di valori distinti compresi tra 0 e 255. I valori ottenuti vengono quindi utilizzati per la ricerca di nuovi valori di colore nell'array appropriato: redArray, greenArray, blueArray e alphaArray. Ognuno di questi quattro array solitamente contiene 256 valori.
3. Una volta recuperati, tutti e quattro i nuovi valori di canale colore vengono combinati in un valore ARGB standard che viene applicato al pixel.

Questo metodo consente di supportare gli effetti su più canali. Ogni array di input può contenere valori completi a 32 bit, e non avviene alcuno spostamento quando i valori vengono combinati. Questa routine non supporta il fissaggio di canali singoli.

Se per un canale non viene specificato alcun array, il canale di colore viene copiato dall'immagine di origine all'immagine di destinazione.

Questo metodo può essere utilizzato per numerosi effetti, come la mappatura delle tavolozze generiche (dove un canale viene convertito in un'immagine di colore falsa). Potete utilizzarlo anche per una serie di algoritmi avanzati per la manipolazione dei colori, come gamma, curve, livelli e quantizzazione.

Parametri

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

Genera un'immagine di disturbo Perlin.

L'algoritmo di generazione del disturbo Perlin interpola e combina singole funzioni di disturbo casuale (definite ottave) in un'unica funzione che genera un disturbo casuale dall'aspetto più naturale. Come accade nelle ottave musicali, ogni funzione di ottava è il doppio della frequenza di quella che la precede. Il disturbo Perlin è stato descritto come una "somma frattale di disturbo", dal momento che combina più serie di disturbo con diversi livelli di dettaglio.

Le funzioni di disturbo Perlin possono essere utilizzate per simulare fenomeni naturali e paesaggi, come la trama del legno, le nuvole e le catene montuose. Nella maggior parte dei casi, l'output di una funzione di disturbo Perlin non viene visualizzata direttamente ma viene utilizzata per modificare altre immagini e applicarvi delle variazioni pseudo casuali.

Le funzioni semplici di disturbo casuale digitale spesso producono immagini con punti molto contrastati. Questo tipo di forte contrasto non è tuttavia frequente in natura. L'algoritmo Perlin per il disturbo mescola più funzioni di disturbo che operano a diversi livelli di dettaglio. L'algoritmo crea variazioni più piccole tra valori di pixel adiacenti.

Parametri

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

Esegue una dissolvenza pixel da un'immagine di origine a una di destinazione oppure utilizzando la stessa immagine. I runtime Flash utilizzano un valore randomSeed per generare una dissolvenza pixel casuale. Il valore restituito dalla funzione deve essere passato nelle successive chiamate per continuare la dissolvenza pixel fino al suo completamento.

Se l'immagine di origine non è uguale a quella di destinazione, i pixel vengono copiati dall'origine alla destinazione mediante tutte le proprietà. Questo processo consente di effettuare una dissolvenza da un'immagine vuota a un'immagine ricca di elementi.

Se le immagini di origine e di destinazione sono uguali, i pixel vengono riempiti con il parametro color. Questo processo consente di effettuare una dissolvenza in uscita da un'immagine ricca di elementi. Il parametro point di destinazione viene ignorato.

Parametri

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

Scorre un'immagine di una certa quantità di pixel (x, y). Le aree dei bordi fuori dell'area di scorrimento vengono lasciate invariate.

Parametri

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

Imposta un singolo pixel di un oggetto BitmapData. Durante l'operazione, il valore corrente del canale alfa dei pixel dell'immagine viene conservato. Il valore del parametro di colore RGB viene gestito come un valore di colore non moltiplicato.

Nota: per migliorare le prestazioni, quando usate ripetutamente il metodo setPixel() o setPixel32(), chiamate il metodo lock() prima di setPixel() o setPixel32(), quindi chiamate il metodo unlock() dopo aver apportato tutte le modifiche necessarie ai pixel. Questa procedura impedisce che gli oggetti che fanno riferimento a questa istanza BitmapData vengano aggiornati finché non sono state effettuate tutte le modifiche dei pixel.

Parametri

Elementi API correlati

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

Imposta il colore e la trasparenza alfa di un singolo pixel di un oggetto BitmapData. Questo metodo è simile al metodo setPixel(); la differenza principale consiste nel fatto che il metodo setPixel32() accetta un valore di colore ARGB che contiene le informazioni sul canale alfa.

Tutti i pixel di un oggetto BitmapData vengono memorizzati sotto forma di valori di colore premoltiplicati. In un pixel di immagine premoltiplicato i valori dei canali rosso, verde e blu sono già moltiplicati per i dati dell'alfa. Ad esempio, se il valore dell'alfa è 0, anche i canali RGB sono 0, indipendentemente dai relativi valori non moltiplicati. Questa perdita di dati può provocare dei problemi durante l'esecuzione delle operazioni. Tutti i metodi BitmapData accettano e restituiscono valori non moltiplicati. La rappresentazione in pixel interni viene convertita dal formato premoltiplicato a non moltiplicato prima di essere restituita come valore. Durante un'operazione di impostazione, il valore in pixel viene premoltiplicato prima di impostare il pixel dell'immagine grezza.

Nota: per migliorare le prestazioni, quando usate ripetutamente il metodo setPixel() o setPixel32(), chiamate il metodo lock() prima di setPixel() o setPixel32(), quindi chiamate il metodo unlock() dopo aver apportato tutte le modifiche necessarie ai pixel. Questa procedura impedisce che gli oggetti che fanno riferimento a questa istanza BitmapData vengano aggiornati finché non sono state effettuate tutte le modifiche dei pixel.

Parametri

Elementi API correlati

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

Converte un array di byte in un'area rettangolare di dati pixel. Per ciascun pixel, viene chiamato il metodo ByteArray.readUnsignedInt() e il valore restituito viene scritto nel pixel. Se l'array di byte termina prima che il rettangolo sia stato disegnato per intero, la funzione viene restituita. I dati previsti nell'array di byte sono valori di pixel ARGB a 32 bit. Sull'array di byte non viene eseguita alcuna ricerca prima o dopo la lettura dei pixel.

Parametri

Elementi API correlati

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;

Converte un vettore in un'area rettangolare di dati pixel. Per ciascun pixel, un elemento Vector viene letto e scritto nel pixel BitmapData. I dati previsti nel vettore sono valori di pixel ARGB a 32 bit.

Parametri

Prova i valori in pixel di un'immagine in base a una soglia specificata e imposta i pixel che superano la prova a nuovi valori di colore. Se si utilizza il metodo threshold(), è possibile isolare e sostituire le gamme di colore in un'immagine ed eseguire altre operazioni logiche su pixel di immagine.

La logica di verifica del metodo threshold() è la seguente:

1. Se ((pixelValue & mask) operation (threshold & mask)), il pixel viene impostato su color;
2. Altrimenti, se copySource == true, il pixel viene impostato sul valore di pixel corrispondente di sourceBitmap.

Il parametro specifica operation l'operatore di confronto da utilizzare per la verifica di soglia. Ad esempio, se utilizzate "==" come parametro operation, potete isolare il valore di un colore specifico in un'immagine. Oppure, se utilizzate {operation: "<", mask: 0xFF000000, threshold: 0x7F000000, color: 0x00000000}, potete impostare tutti i pixel di destinazione in modo che siano trasparenti quando l'alfa del pixel dell'immagine di origine è inferiore a 0x7F. Questa tecnica è utilizzabile per transizioni animate ed altri effetti.

Parametri

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

Sblocca un'immagine in modo che gli eventuali oggetti che fanno riferimento all'oggetto BitmapData, ad esempio gli oggetti Bitmap, vengano aggiornati quando questo oggetto BitmapData viene modificato. Per migliorare le prestazioni, utilizzate questo metodo in combinazione con lock() prima e dopo numerose chiamate al metodo setPixel() o setPixel32().

Parametri

Elementi API correlati

import flash.display.BitmapData;

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

1. Viene creata una proprietà url, che corrisponde alla posizione e al nome del file di immagine.
2. La funzione di costruzione della classe crea un oggetto Loader, il quale crea quindi un'istanza di un listener di eventi che viene inviata quando il metodo completeHandler() completa la manipolazione delle immagini.
3. L'oggetto URLRequest request viene quindi passato a loader.load(), che carica l'immagine in memoria utilizzando un oggetto di visualizzazione.
4. L'immagine viene quindi posizionata nell'elenco di visualizzazione, che visualizza l'immagine sullo schermo in corrispondenza delle coordinate x = 0, y = 0.
5. Il metodo completeHandler() esegue quindi le seguenti operazioni:
   • Crea un secondo Loader, insieme a un oggetto Bitmap, il quale viene inizializzato con l'oggetto Loader.
   • Crea un secondo oggetto Bitmap, duplicate, che a propria volta chiama il metodo duplicateImage(), che crea un duplicato dell'immagine originale.
   • Crea un nuovo oggetto BitmapData che viene assegnato all'oggetto BitmapData dell'oggetto duplicate.
   • Crea un nuovo oggetto Rectangle inizializzato con le stesse coordinate e gli stessi valori di larghezza e altezza dell'immagine originale.
   • Crea un nuovo oggetto Point, che ha come valore predefinito x = 0, y = 0.
   • Crea le variabili seguenti:
     • operation — Applica il nuovo colore quando il valore di soglia è superiore o uguale all'originale.
     • threshold — Il valore rispetto al quale viene confrontato ogni pixel (in questo esempio, il grigio chiaro con un'impostazione alfa pari a 0xCC).
     • color — Il colore su cui sono impostati i pixel per passare la prova della soglia (in questo caso, giallo uniforme).
     • mask — L'esatto opposto del colore (blu trasparente).
     • copySource — Impostata su false, indica che i valori dei pixel non vengono copiati se il valore di soglia non viene superato. Questo valore non ha alcun significato poiché l'immagine viene duplicata e vengono modificati solo i pixel che passano la prova della soglia.
   • Chiama il metodo threshold() mediante le variabili che lo precedono. L'equazione della soglia risultante è la seguente: if (current pixel Value & 0x000000FF) >= (0xCCCCCCCC & 0x000000FF) then set pixel to 0xFFFFFF00.

Note:

• È necessario compilare il file SWF con Sicurezza riproduzione locale impostato su Accedi solo ai file locali.
• Questo esempio richiede che un file di nome Image.gif venga collocato nella stessa directory del file SWF.
• Si consiglia di utilizzare un'immagine con una larghezza massima di circa 80 pixel.

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