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. È possibile impostare questo valore solo quando si crea un oggetto BitmapData passando true per il parametro transparent della funzione di costruzione. Quindi, dopo aver creato un oggetto BitmapData, è possibile 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 viene specificato 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 venga passato 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 si definisce l'immagine bitmap come trasparente, ogni pixel utilizza 32 bit di informazioni dei canali di colore, compreso il canale di trasparenza alfa.

La larghezza e l'altezza massime di un oggetto BitmapData corrispondono a 2880 pixel. 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, Flash Player utilizza una copia temporanea dell'oggetto per eseguire il filtro. Per ottenere risultati ottimali, è necessario evitare questa situazione.

Parametri

Vedere anche

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

Vedere anche

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, esaminare 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 (0xFF8800 e 0xCC6600). Il risultato del metodo compare() è un nuovo oggetto BitmapData in cui ogni pixel mostra la differenza nei valori RGB tra le due bitmap.

Osservare 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

Vedere anche

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 vengono inclusi i parametri alphaBitmap e alphaPoint, è possibile 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 dell'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, impostare 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;

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.

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 di Flash Player. È possibile specificare matrix, colorTransform, blendMode e un parametro clipRect di destinazione per controllare l'esecuzione del rendering. Facoltativamente, è possibile specificare se la bitmap deve essere smussata quando viene modificata in scala (questa soluzione funziona solo con un oggetto di origine BitmapData).

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, è possibile copiarne la proprietà transform nella proprietà transform dell'oggetto Bitmap che utilizza l'oggetto BitmapData.

Nota: l'oggetto source e (nel caso di un oggetto Sprite o MovieClip) tutti i suoi oggetti secondari devono provenire dallo stesso dominio del chiamante oppure essere inclusi in un file SWF accessibile al chiamante mediante una chiamata al metodo Security.allowDomain(). Se queste condizioni non sono soddisfatte, il metodo draw() non disegna nulla.

questo metodo è supportato attraverso RTMP in Flash Player Aggiornamento 3 e versioni successive. È possibile controllare l'accesso agli streaming su Flash Media Server in uno script lato server. Per ulteriori informazioni, vedere le proprietà Client.audioSampleAccess e Client.videoSampleAccess in Guida di riferimento di ActionScript lato server per Adobe Flash Media Server.

Parametri

	source:IBitmapDrawable — L'oggetto di visualizzazione o l'oggetto BitmapData da disegnare nell'oggetto BitmapData. (Le classi DisplayObject e BitmapData implementano l'interfaccia IBitmapDrawable.)
	matrix:Matrix (default = null) — Un oggetto Matrix utilizzato per modificare in scala, ruotare o convertire le coordinate della bitmap. Se non si vuole applicare una matrice di trasformazione all'immagine, impostare questo parametro su una matrice di identità creata con la funzione di costruzione predefinita new Matrix(), oppure passare un valore null.
	colorTransform:ColorTransform (default = null) — Un oggetto ColorTransform utilizzato per regolare i valori del colore della bitmap. Se non viene fornito alcun oggetto, i colori dell'immagine bitmap non vengono trasformati. Se si deve passare questo parametro ma non si desidera trasformare l'immagine, impostare il parametro su un oggetto ColorTransform creato con la funzione di costruzione predefinita new ColorTransform().
	blendMode:String (default = null) — Un valore stringa, della classe flash.display.BlendMode, che specifica il metodo di fusione da applicare alla bitmap risultante.
	clipRect:Rectangle (default = null) — Un oggetto Rectangle che definisce l'area dell'oggetto di origine da disegnare. Se questo valore non viene fornito, non si verifica alcun troncamento e l'oggetto di origine viene disegnato per intero.
	smoothing:Boolean (default = false) — Un valore booleano che determina se un oggetto BitmapData viene smussato quando viene modificato in scala o ruotato, in base a un'impostazione di modifica in scala o di rotazione nel parametro matrix. Il parametro smoothing viene applicato solo se il parametro source è un oggetto BitmapData. Con smoothing impostato su false, l'immagine BitmapData ruotata o modificata in scala può apparire pixelizzata o frastagliata. Ad esempio, le due immagini seguenti utilizzano lo stesso oggetto BitmapData per il parametro source, ma il parametro smoothing è impostato su true a sinistra e su false a destra: Per disegnare una bitmap con smoothing impostato su true occorre più tempo che con smoothing impostato su false.

Vedere anche

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

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

Parametri

Vedere anche

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 si dispone di un'immagine di origine e si desidera determinare il rettangolo che contiene un canale alfa diverso da 0, passare {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, passare {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

Vedere anche

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;

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

Vedere anche

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

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

Vedere anche

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

Esegue un rilevamento per zone a livello di pixel tra una singola immagine bitmap e un punto, un rettangolo o un'altra immagine bitmap. 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, utilizzare questo metodo in combinazione con unlock() prima e dopo numerose chiamate al metodo setPixel() o setPixel32().

Vedere anche

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 valoire 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. Utilizzare 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

Vedere anche

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.

Flash Player utilizza 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). È possibile anche utilizzare questo metodo 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.

Nota: l'algoritmo Perlin prende il nome da Ken Perlin, che lo ha sviluppato dopo aver generato la grafica computerizzata per il film Tron del 1982. Nel 1997 Perlin ha ricevuto un Oscar nella categoria "Technical Achievement" per la funzione del disturbo Perlin.

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. Flash Player utilizza 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 si usa ripetutamente il metodo setPixel() o setPixel32(), chiamare il metodo lock() prima di setPixel() o setPixel32(), quindi chiamare 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

Vedere anche

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 si usa ripetutamente il metodo setPixel() o setPixel32(), chiamare il metodo lock() prima di setPixel() o setPixel32(), quindi chiamare 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

Vedere anche

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

Vedere anche

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;

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)), impostare il pixel su color;
2. Altrimenti, se copySource == true, impostare il pixel 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 si utilizza "==" come parametro operation, è possibile isolare il valore di un colore specifico in un'immagine. Oppure, se si utilizza {operation: "<", mask: 0xFF000000, threshold: 0x7F000000, color: 0x00000000}, è possibile 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, utilizzare questo metodo in combinazione con lock() prima e dopo numerose chiamate al metodo setPixel() o setPixel32().

Parametri

Vedere anche

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 width e height 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, che 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);
        }
    }
}