BitmapData  - AS3

Bitmappsbildens höjd i pixlar.

Den rektangel som definierar bitmappsbildens storlek och placering. Över- och vänsterdelen av rektangeln är 0; bredden och höjden är lika som bredden och höjden i pixlar i BitmapData-objektet.

Definierar om bitmappsbilden stöder genomskinlighet per pixel. Du kan endast ange det här värdet när du skapar ett BitmapData-objekt genom att ange true för parametern transparent för konstruktorn. När du har skapat ett BitmapData-objekt kan du sedan kontrollera om det stöder genomskinlighet per pixel genom att se efter om värdet för egenskapen transparent är true.

Bitmappsbildens bredd i pixlar.

Skapar ett nytt BitmapData-objekt med angiven bredd och höjd. Om du anger ett värde för parametern fillColor ställs alla pixlar i bitmappen in på den färgen.

Som standard är den bitmapp som skapas genomskinlig, såvida du inte skickar värdet false för parametern transparent. Om du har skapat en ogenomskinlig bitmapp kan du inte ändra den till en genomskinlig bitmapp. Varje pixel i en ogenomskinlig bitmapp använder endast 24-bitars färgkanalinformation. Om du definierar bitmappen som genomskinlig använder varje pixel 32-bitars färgkanalinformation, inklusive en alfagenomskinlighetskanal.

I AIR 1.5 och Flash Player 10 är maxstorleken för ett BitmapData-objekt 8 191 pixlar i bredd eller höjd, och det totala antalet pixlar får inte överskrida 16 777 215 pixlar. (Om ett BitmapData-objekt är 8 191 pixlar brett kan det därför bara vara 2 048 pixlar högt.) I Flash Player 9 och tidigare och i AIR 1.1 och tidigare är begränsningen 2 880 pixlar i höjd och 2 880 pixlar i bredd. Om du anger ett bredd- eller höjdvärde som är större än 2 880, skapas ingen ny instans.

Tar en källbild och ett filterobjekt och skapar den filtrerade bilden.

Den här metoden förlitar sig på beteendet i inbyggda filterobjekt, som bestämmer vilken målrektangel som påverkas av en indatakällrektangel.

När filtret har använts kan den resulterande bilden vara större än indatabilden. Om du till exempel använder en BlurFilter-klass för att göra en källrektangel på (50,50,100,100) och en målpunkt på (10,10) oskarpa, blir området som ändras i målbilden större än (10,10,60,60) på grund av oskärpan. Detta inträffar internt under applyFilter()-anropet.

Om parametern sourceRect för parametern sourceBitmapData är en intern region, till exempel (50,50,100,100) i en 200 x 200-bild, använder filtret källpixlarna utanför parametern sourceRect för att skapa målrektangeln.

Om BitmapData-objektet och det objekt som specificeras som sourceBitmapData-parametern utgör samma objekt använder programmet en tillfällig kopia av objektet för att tillämpa filtret. Undvik denna situation för bästa möjliga prestanda.

Parametrar

Relaterade API-element

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

Returnerar ett nytt BitmapData-objekt som är en klon av den ursprungliga instansen med en exakt kopia av bitmappen som objektet innehåller.

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

Justerar färgvärdena i ett angivet område i en bitmappsbild med ett ColorTransform-objekt. Om rektangeln matchar gränserna för bitmappsbilden, transformerar den här metoden färgvärdena i hela bilden.

Parametrar

Relaterade API-element

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

Jämför två BitmapData-objekt. Om de två BitmapData-objekten har samma dimensioner (bredd och höjd), returnerar metoden ett nytt BitmapData-objekt, där varje pixel är "skillnaden" mellan pixlarna i de två källobjekten:

• Om de två pixlarna är lika är skillnadspixeln 0x00000000.
• Om två pixlar har olika RGB-värden (alfavärdet ignoreras), är skillnadspixeln 0xRRGGBB, där RR/GG/BB är de enskilda differensvärdena mellan röda, gröna och blå kanaler (källobjektets pixelvärde minus otherBitmapData-objektets pixelvärde). Alfakanalsskillnader ignoreras i det här fallet.
• Om endast alfakanalvärdet skiljer sig är pixelvärdet 0xZZFFFFFF där ZZ är skillnaden i alfavärde (källobjektets alfavärde minus otherBitmapData-objektets alfavärde).

Titta exempelvis på följande två BitmapData-objekt.

     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
     

Obs! Färgerna som fyller de två BitmapData-objekten har något annorlunda RGB-värden (0xFF0000 och 0xFFAA00). Resultatet av metoden compare() är ett nytt BitmapData-objekt där varje pixel visar skillnaden i RGB-värdena mellan de två bitmapparna.

Exempel: Här är två BitmapData-objekt där RGB-färgerna är desamma men alfavärdena är annorlunda:

     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
     

Resultatet av metoden compare() är ett nytt BitmapData-objekt där varje pixel visar skillnaden i RGB-värdena mellan de två bitmapparna.

Om BitmapData-objekten är likvärdiga (med samma bredd, höjd och identiska pixelvärden), returnerar metoden talet 0.

Om BitmapData-objektens bredder inte är lika returnerar metoden talet -3.

Om höjden på BitmapData-objekten inte är likvärdiga men bredden är den samma, returnerar metoden talet -4.

I följande exempel jämförs två Bitmap-objekt med olika bredder (50 och 60):

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

Parametrar

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;

Överför data från en kanal i ett annat BitmapData-objekt eller det aktuella BitmapData-objektet till en kanal i det aktuella BitmapData-objektet. Alla data i de andra kanalerna i mål-BitmapData-objektet bevaras.

Källkanalvärdet och målkanalvärdet kan vara något av följande värden:

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

Parametrar

Relaterade API-element

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

Ger en snabb rutin som utför pixelmanipulering mellan bilder utan utsträckning, rotation eller färgeffekter. Den här metoden kopierar ett rektangulärt område av en källbild till ett rektangulärt område av samma storlek vid målpunkten i mål-BitmapData-objektet.

Om du inkluderar parametrarna alphaBitmap och alphaPoint kan du använda en sekundär bild som en alfakälla för källbilden. Om källbilden har alfadata används båda uppsättningarna alfadata för att sätta samman pixlar från källbilden till målbilden. Parametern alphaPoint är den punkt i alfabilden som motsvarar det övre vänstra hörnet i källrektangeln. Om det finns pixlar utanför korsningsområdet i källbilden och alfabilden kopieras de inte till målbilden.

Egenskapen mergeAlpha styr huruvida alfakanalen används när en genomskinlig bild kopieras till en annan genomskinlig bild. För att kopiera pixlar med alfakanaldata sätter man mergeAlpha-egenskapen till true. Egenskapen mergeAlpha är som standard false.

Parametrar

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;

Fyller en bytearray från ett rektangulärt område med pixeldata. Börjar vid indexet position för ByteArray. Med denna metod skrivs ett osignerat heltal (ett 32-bitars icke-multiplicerat pixelvärde) för varje pixel i bytearrayen. Vid behov ökas bytearrayens storlek till nödvändigt antal byte för att rymma alla pixeldata.

Parametrar

Relaterade API-element

Frigör minne som används för att lagra BitmapData-objektet.

Om dispose()-metoden anropas för en bild sätts bildens bredd och höjd till 0. Alla senare anrop till metoder eller egenskaper som hör till denna BitmapData-instans misslyckas och ett undantag uppstår.

BitmapData.dispose() frisläpper omedelbart minnet som verkliga bitmappsdata upptar (en bitmapp kan förbruka upp till 64 MB minne). När BitmapData.dispose() har använts kan BitmapData-objektet inte längre användas och Flash-miljön genererar ett undantag om du anropar funktioner för BitmapData-objektet. BitmapData.dispose() samlar dock inte upp BitmapData-objektet (cirka 128 byte); minnet som det verkliga BitmapData-objektet upptar frisläpps när BitmapData-objektet samlas upp av skräpinsamlaren.

Relaterade API-element

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
}

Ritar source-visningsobjektet på bitmappsbilden med vektorrenderaren i Flash-miljön. Du kan ange matris, colorTransform, blendMode och en destinations-clipRect-parameter för att kontrollera hur återgivningen utförs. Alternativt kan du bestämma om bitmappen ska utjämnas när den skalas (fungerar bara om källobjektet är ett BitmapData-objekt).

Obs! Metoden drawWithQuality() fungerar på samma sätt som metoden draw(), men i stället för att använda egenskapen Stage.quality för att ange kvaliteten på vektoråtergivningen, så anger du parametern quality för metoden drawWithQuality().

Den här metoden styr direkt hur objekt ritas med hjälp av den förvalda vektorrenderaren för objekt i utvecklingsverktygets gränssnitt.

Med käll-MovieClip-objekt används inte omvandling på scenen för det här anropet. Det behandlas så som det är i biblioteket eller filen, utan matrisomvandling, färgomvandling och blandningsläge. För att rita ett visningsobjekt (exempelvis ett filmklipp) genom att använda dess egna omvandlingsegenskaper kan du kopiera dess transform-egenskapsobjekt till transform-egenskapen hos det Bitmap-objekt som använder BitmapData-objektet.

Metoden stöds över RTMP i Flash Player 9.0.115.0 och senare och i Adobe AIR. Du kan styra åtkomst till flöden på Flash Media Server i ett skript på servern. Du hittar mer information i avsnitten om egenskaperna Client.audioSampleAccess och Client.videoSampleAccess i Server-Side ActionScript Language Reference for Adobe Flash Media Server.

Om source-objektet och (för ett Sprite- eller MovieClip-objekt) alla dess underordnade objekt inte kommer från samma domän som anroparen, eller om det inte finns i innehåll som är tillgängligt för anroparen efter anrop av Security.allowDomain()-metoden, kommer att anrop till draw() att returnera ett fel av typen SecurityError. Denna begränsning gäller inte AIR-innehåll i programmets säkerhetssandlåda.

Det finns också begränsningar för hur du kan använda en inläst bitmappsbild som source. Ett anrop till metoden draw() lyckas om den inlästa bilden kommer från samma domän som anroparen. En domänprincipfil på bildens server kan också ge behörighet till domänen för SWF-innehållet som anropar metoden draw(). I det här fallet måste du ställa in egenskapen checkPolicyFile för ett LoaderContext-objekt, och använda det här objektet som context-parameter när du anropar metoden load() för Loader-objektet som används för att läsa in bilden. Dessa begränsningar gäller inte AIR-innehåll i programmets säkerhetssandlåda.

I Windows kan inte draw()-metoden fånga SWF-innehåll som är inbäddat i en HTML-sida i ett HTMLLoader-objekt i Adobe AIR.

Metoden draw() kan inte fånga PDF-innehåll i Adobe AIR. Den kan heller inte fånga in SWF-innehåll som är inbäddat i HTML där wmode-attributet ställs in på "window" i Adobe AIR.

Parametrar

Relaterade API-element

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

Ritar source-visningsobjektet på bitmappsbilden med vektorrenderaren i Flash-miljön. Du kan ange matris, colorTransform, blendMode och en destinations-clipRect-parameter för att kontrollera hur återgivningen utförs. Alternativt kan du bestämma om bitmappen ska utjämnas när den skalas (fungerar bara om källobjektet är ett BitmapData-objekt).

Obs! Metoden drawWithQuality() fungerar på samma sätt som metoden draw(), men i stället för att använda egenskapen Stage.quality för att ange kvaliteten på vektoråtergivningen, så anger du parametern quality för metoden drawWithQuality().

Den här metoden styr direkt hur objekt ritas med hjälp av den förvalda vektorrenderaren för objekt i utvecklingsverktygets gränssnitt.

Med käll-MovieClip-objekt används inte omvandling på scenen för det här anropet. Det behandlas så som det är i biblioteket eller filen, utan matrisomvandling, färgomvandling och blandningsläge. För att rita ett visningsobjekt (exempelvis ett filmklipp) genom att använda dess egna omvandlingsegenskaper kan du kopiera dess transform-egenskapsobjekt till transform-egenskapen hos det Bitmap-objekt som använder BitmapData-objektet.

Metoden stöds över RTMP i Flash Player 9.0.115.0 och senare och i Adobe AIR. Du kan styra åtkomst till flöden på Flash Media Server i ett skript på servern. Mer information finns i avsnitten om egenskaperna Client.audioSampleAccess och Client.videoSampleAccess i Språkreferens för Serverside ActionScript för Adobe Flash Media Server.

Om källobjektet och (för Sprite- eller MovieClip-objekt) alla dess underordnade objekt inte kommer från samma domän som anroparen, eller om det inte finns i innehåll som är tillgängligt för anroparen efter anrop till metoden Security.allowDomain(), kommer ett anrop till drawWithQuality() att returnera ett fel av typen SecurityError. Denna begränsning gäller inte AIR-innehåll i programmets säkerhetssandlåda.

Det finns också begränsningar för hur du kan använda en inläst bitmappsbild som source. Ett anrop till metoden drawWithQuality() lyckas om den inlästa bilden kommer från samma domän som anroparen. En domänprincipfil på bildens server kan också ge behörighet till domänen för det SWF-innehåll som anropar metoden drawWithQuality(). I det här fallet måste du ställa in egenskapen checkPolicyFile för ett LoaderContext-objekt, och använda det här objektet som context-parameter när du anropar metoden load() för Loader-objektet som används för att läsa in bilden. Dessa begränsningar gäller inte AIR-innehåll i programmets säkerhetssandlåda.

I Windows kan metoden drawWithQuality() inte hämta SWF-innehåll som bäddats in på en HTML-sida i ett HTMLLoader-objekt i Adobe AIR.

Metoden drawWithQuality() kan inte hämta PDF-innehåll i Adobe AIR. Den kan heller inte fånga in SWF-innehåll som är inbäddat i HTML där wmode-attributet ställs in på "window" i Adobe AIR.

Parametrar

Relaterade API-element

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

Komprimerar det här BitmapData-objektet med den valda komprimeringsalgoritmen och returnerar ett nytt ByteArray-objekt. De data som genereras kan även skrivas till angiven ByteArray. Argumentet compressor anger kodningsalgoritmen, som kan vara PNGEncoderOptions, JPEGEncoderOptions eller JPEGXREncoderOptions.

I följande exempel komprimeras ett BitmapData-objekt med 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); 

Parametrar

Relaterade API-element

Fyller i ett rektangulärt område med pixlar med en angiven ARGB-färg.

Parametrar

Relaterade API-element

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

Utför en flödningsfyllning på en bild med början vid en (x, y) koordinat och fyller med en viss färg. Metoden floodFill() liknar färgpytsverktyget i olika ritprogram. Färgen är en ARGB-färg som innehåller alfainformation och färginformation.

Parametrar

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

Bestämmer målrektangeln som påverkas av applyFilter()-metodanropet, givet ett BitmapData-objekt, en källrektangel och ett filterobjekt.

Ett filter för oskärpa påverkar normalt ett större område än storleken på originalbilden. En bild på 100 x 200 pixlar som filtreras genom en förvald BlurFilter-instans, där blurX = blurY = 4 genererar en målrektangel på (-2,-2,104,204). Med metoden generateFilterRect() kan du ta reda på storleken på denna målrektangel i förväg, så att du kan ange rätt storlek på målbilden innan du utför en filteråtgärd.

En del filter klipper sin målrektangel baserat på källbildens storlek. En inre DropShadow genererar till exempel inte ett större resultat än sin källbild. I den här API:n används BitmapData-objektet som källgränser, inte källparametern rect.

Parametrar

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

Definierar ett rektangulärt område som antingen helt omsluter alla pixlar av en viss färg inom bitmappsbilden (om parametern findColor är inställd på true) eller helt omsluter alla pixlar som inte har den angivna färgen (om parametern findColor är inställd på false).

Om du till exempel har en källbild och vill bestämma vilken rektangel av bilden som innehåller en alfakanal som inte är noll, skickar du {mask: 0xFF000000, färg: 0x00000000} som parametrar. Om findColor-parametern sätts till true genomsöks hela bilden för de pixelgränser för vilka (värde & mask) == färg (där värde är pixelns färgvärde). Om findColor-parametern sätts till false genomsöks hela bilden för de pixelgränser för vilka (värde & mask) != färg (där värde är pixelns färgvärde). För att bestämma tomt utrymme runt en bild skickas {mask: 0xFFFFFFFF, färg: 0xFFFFFFFF} för att hitta gränserna för pixlar som inte är vita.

Parametrar

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

Returnerar ett heltal som representerar ett RGB-pixelvärde från ett BitmapData-objekt vid en viss punkt (x, y). getPixel()-metoden returnerar ett icke-multiplicerat pixelvärde. Ingen alfainformation returneras.

Alla pixlar i ett BitmapData-objekt lagras som förmultiplicerade färgvärden. I en förmultiplicerad pixel har de röda, gröna och blå färgkanalvärdena redan multiplicerats med alfainformationen. Om alfavärdet till exempel är 0 är värdena för RGB-kanalerna också 0, oavsett vilka icke-multiplicerade värden de har. Denna dataförlust kan orsaka vissa problem när du utför åtgärder. Alla BitmapData-metoder accepterar och returnerar icke-multiplicerade värden. Den interna pixelrepresentationen konverteras från förmultiplicerad till icke-multiplicerad innan den returneras som ett värde. Vid en inställningsåtgärd förmultipliceras pixelvärdet innan den okomprimerade pixeln anges.

Parametrar

Relaterade API-element

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;

Returnerar ett ARGB-färgvärde som innehåller alfakanaldata och RGB-data. Den här metoden liknar metoden getPixel(), som returnerar ett RGB-värde utan alfakanaldata.

Alla pixlar i ett BitmapData-objekt lagras som förmultiplicerade färgvärden. I en förmultiplicerad pixel har de röda, gröna och blå färgkanalvärdena redan multiplicerats med alfainformationen. Om alfavärdet till exempel är 0 är värdena för RGB-kanalerna också 0, oavsett vilka icke-multiplicerade värden de har. Denna dataförlust kan orsaka vissa problem när du utför åtgärder. Alla BitmapData-metoder accepterar och returnerar icke-multiplicerade värden. Den interna pixelrepresentationen konverteras från förmultiplicerad till icke-multiplicerad innan den returneras som ett värde. Vid en inställningsåtgärd förmultipliceras pixelvärdet innan den okomprimerade pixeln anges.

Parametrar

Relaterade API-element

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

Skapar en bytearray av ett rektangulärt område med pixeldata. Skriver ett heltal utan tecken (ett icke-multiplicerat 32-bitars pixelvärde) för varje pixel i bytearrayen.

Parametrar

Relaterade API-element

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

Genererar en vektorarray utifrån ett rektangulärt område med pixeldata. Returnerar ett Vector-objekt av positiva heltal (ett 32-bitars omultiplicerat pixelvärde) för angiven rektangel.

Parametrar

Beräknar ett histogram med 256 värden och binära tal i ett BitmapData-objekt. Den här metoden returnerar ett Vector-objekt som innehåller fyra Vector.<Antal> instanser (fyra Vector-objekt som innehåller Number-objekt). De fyra Vector-instanserna representerar i ordning komponenterna röd, grön, blå och alfa. Alla Vector-instanser innehåller 256 värden som representerar antalet bitar för ett enskilt komponentvärde, från 0 till 255.

Parametrar

Utför träffavkänning på pixelnivå mellan en bitmappsbild och en punkt, rektangel eller en annan bitmappsbild. En träff definieras som en överlappning av en punkt eller rektangel över en ogenomskinlig pixel, eller två överlappande ogenomskinliga pixlar. Ingen utsträckning, rotering eller annan omvandling tas hänsyn till på något av objektet när träfftesten utförs.

Om en bild är ogenomskinlig räknas den som en helt ogenomskinlig rektangel för den här metoden. Båda bilderna måste vara genomskinliga för att det ska gå att genomföra ett träfftest på pixelnivå som tar hänsyn till genomskinlighet. När du testar två genomskinliga bilder styr parametrarna för alfatröskelvärde vilka alfakanalvärden (mellan 0 och 255) som ska räknas som ogenomskinliga.

Parametrar

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

Låser en bild så att alla objekt som refererar till BitmapData-objektet, till exempel Bitmap-objekt, inte uppdateras när det här BitmapData-objektet ändras. Använd den här metoden tillsammans med unlock()-metoden före och efter flera anrop till setPixel()- eller setPixel32()-metoden för att få bättre prestanda.

Relaterade API-element

import flash.display.BitmapData;

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

Utför blandning per kanal från en källbild till en målbild. För varje kanal och varje pixel beräknas ett nytt värde utifrån kanalvärdena för käll- och målpixlarna. I den röda kanalen beräknas till exempel det nya värdet på följande sätt (där redSrc är det röda kanalvärdet för en pixel i källbilden och redDest är det röda kanalvärdet för motsvarande pixel i målbilden):

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

Värdena för redMultiplier, greenMultiplier, blueMultiplier och alphaMultiplier är de multipler som används för de olika färgkanalerna. Använd ett hexadecimalt värde mellan 0 och 0x100 (256) där 0 innebär att målets hela värde används i resultatet och 0x100 innebär att källans hela värde används. Värden däremellan innebär att en blandning används (till exempel 0x80 för 50 %).

Parametrar

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;

Fyller i en bild med pixlar som representerar slumpmässigt brus.

Parametrar

Relaterade API-element

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;

Mappar om färgkanalvärdena i en bild med upp till fyra arrayer med färgpalettdata, en för varje kanal.

I Flash-miljöerna använder du följande steg för att generera bilden:

1. När de röda, gröna och blå värdena och alfavärdet har beräknas läggs de ihop med hjälp av standardåtgärder för 32-bitars heltalsaritmetik.
2. De röda, gröna och blå kanalvärdena och alfakanalvärdet för varje pixel extraheras till separata värden (0 till 255). Med dessa värden kan nya färgvärden hittas i lämplig array: redArray, greenArray, blueArray och alphaArray. Var och en av dessa fyra arrayer ska innehålla 256 värden.
3. När alla de fyra nya kanalvärdena har hämtats kombineras de till ett standard-ARGB-värde som används på pixeln.

Korskanaleffekter kan hanteras med den här metoden. Varje indataarray kan innehålla fullständiga 32-bitars värden och det görs ingen skiftning när värdena läggs ihop. Den här rutinen stöder inte hopklämning per kanal.

Om ingen array anges för en kanal kopieras färgkanalen från källbilden till målbilden.

Du kan använda den här metoden för olika effekter, till exempel allmän palettmappning (där en kanal konverteras till en falsk färgbild). Du kan också använda metoden för olika avancerade färghanteringsalgoritmer, som gamma, kurvor, nivåer och kvantisering.

Parametrar

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

Skapar en Perlin-brusbild.

Genereringsalgoritmen för Perlin-brus interpolerar och kombinerar enskilda och slumpmässiga brusfunktioner (så kallade oktaver) till en enda funktion som genererar ett mer naturligt brus. På samma sätt som musikaliska oktaver har varje oktavfunktion den dubbla frekvensen jämfört med den föregående. Perlin-brus har beskrivits som en "fraktalsumma av brus" eftersom det kombinerar flera brusdatauppsättningar med olika detaljnivåer.

Du kan använda Perlin-brusfunktioner för att simulera naturliga fenomen och landskap, som träfiber, moln och bergsmassiv. I de flesta fall visas inte resultatet av en Perlin-brusfunktion direkt, utan används för att förstärka andra bilder och ge dem pseudoslumpmässiga variationer.

Enkla digitala, slumpmässiga brusfunktioner ger ofta bilder med hårda och kontrasterande punkter. Den här typen av hård kontrast brukar man inte hitta i naturen. Algoritmen för Perlin-brus blandar flera brusfunktioner som fungerar på olika detaljnivå. Den här algoritmen resulterar i mindre variationer bland intilliggande pixelvärden.

Parametrar

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

Utför en pixel upplösning antingen från en källbild till en målbild eller genom att använda samma bild. I Flash-miljöerna använder du ett randomSeed-värde för att generera en slumpmässig pixelupplösning. Returvärdet för funktionen måste skickas i efterföljande anrop för att pixelupplösningen ska fortsätta tills den är klar.

Om källbilden inte är densamma som målbilden kopieras pixlar från källan till målen med alla egenskaper. Denna process gör att upplösning kan ske från en tom bild till en helt fylld bild.

Om käll- och målbilderna är lika fylls pixlar med parametern color. Denna process gör att upplösning kan ske på en annan plats än en helt fylld bild. I det här läget ignoreras parametern point.

Parametrar

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

Rullar en bild med en viss (x, y) pixelmängd. Kantområden utanför rullningsområdet förblir oförändrade.

Parametrar

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

Ställer in en enda pixel i BitmapData-objektet. Det aktuella alfakanalvärdet för pixeln bevaras under den här åtgärden. Värdet på RGB-färgparametern behandlas som ett icke-multiplicerat färgvärde.

Obs! För bättre prestanda när du använder setPixel()- eller setPixel32()-metoden upprepade gånger ska du anropa lock()-metoden innan du anropar setPixel()- eller setPixel32()-metoden, och sedan anropa unlock()-metoden när du har gjort alla pixeländringar. Den här processen förhindrar att objekt som referear till denna BitmapData-instans uppdateras innan du slutar att göra pixeländringar.

Parametrar

Relaterade API-element

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

Ställer in värden för färg och alfagenomskinlighet för en enskild pixel i ett BitmapData-objekt. Metoden liknar metoden setPixel(). Den största skillnaden är att metoden setPixel32() använder ett ARGB-färgvärde som innehåller alfakanalinformation.

Alla pixlar i ett BitmapData-objekt lagras som förmultiplicerade färgvärden. I en förmultiplicerad pixel har de röda, gröna och blå färgkanalvärdena redan multiplicerats med alfainformationen. Om alfavärdet till exempel är 0 är värdena för RGB-kanalerna också 0, oavsett vilka icke-multiplicerade värden de har. Denna dataförlust kan orsaka vissa problem när du utför åtgärder. Alla BitmapData-metoder accepterar och returnerar icke-multiplicerade värden. Den interna pixelrepresentationen konverteras från förmultiplicerad till icke-multiplicerad innan den returneras som ett värde. Vid en inställningsåtgärd förmultipliceras pixelvärdet innan den okomprimerade pixeln anges.

Obs! För bättre prestanda när du använder setPixel()- eller setPixel32()-metoden upprepade gånger ska du anropa lock()-metoden innan du anropar setPixel()- eller setPixel32()-metoden, och sedan anropa unlock()-metoden när du har gjort alla pixeländringar. Den här processen förhindrar att objekt som referear till denna BitmapData-instans uppdateras innan du slutar att göra pixeländringar.

Parametrar

Relaterade API-element

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

Konverterar en bytearray av ett rektangulärt område med pixeldata. För varje pixel anropas ByteArray.readUnsignedInt()-metoden och returvärdet skrivs in i pixeln. Om bytearrayen tar slut innan hela rektangeln skrivits återkommer funktionen. De data som ingår i bytearrayen förväntas vara 32-bitars ARGB-pixelvärden. Ingen sökning utförs i bytearrayen före eller efter läsning av pixlarna.

Parametrar

Relaterade API-element

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;

Konverterar ett Vector-objekt till ett rektangulärt område med pixeldata. För varje pixel läses ett Vector-element in och skrivs till BitmapData-pixeln. De data som ingår i vektorn förväntas vara 32-bitars ARGB-pixelvärden.

Parametrar

Testar pixelvärden i en bild mot en angiven tröskel och tilldelar pixlar som klarar testet nya färgvärden. Med metoden threshold() kan du isolera och ersätta färgintervall i en bild och utföra andra logiska åtgärder på pixlar.

threshold()-metodens testlogik är följande:

1. Om ((pixelValue & mask)-operationen (threshold & mask)) ska pixeln sättas till color;
2. Om copySource == true ska pixelvärdet sättas till motsvarande pixelvärde från sourceBitmap.

Parametern operation anger vilken jämförelseoperator som ska användas för tröskelvärdestestet. Genom att till exempel använda "==" som operation-parameter kan du isolera ett visst färgvärde i en bild. Eller också kan du använda {operation: "<", mask: 0xFF000000, threshold: 0x7F000000, color: 0x00000000} för att också ange att alla målpixlar ska vara helt genomskinliga när källbildens pixelalfa är mindre än 0x7F. Du kan använda den här tekniken för animerade övergångar och andra effekter.

Parametrar

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

Låser upp en bild så att alla objekt som refererar till BitmapData-objektet, till exempel Bitmap-objekt, uppdateras när det här BitmapData-objektet ändras. Använd den här metoden tillsammans med lock()-metoden före och efter flera anrop till setPixel()- eller setPixel32()-metoden för att få bättre prestanda.

Parametrar

Relaterade API-element

import flash.display.BitmapData;

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

1. En url-egenskap skapas bestående av bildfilens plats och namn
2. Klasskonstruktorn skapar ett inläsningsobjekt, som instansierar en händelseavlyssnare som skickas när completeHandler()-metoden slutför bildmanipuleringen.
3. Begärans URLRequest-objekt skickas sedan till loader.load(), som laddar bilden till minnet med ett visningsobjekt.
4. Bilden läggs därefter in i visningslistan, som visar bilden på skärmen i koordinaterna x = 0, y = 0.
5. Sedan gör completeHandler()-metoden följande:
   • Skapar en andra Loader, tillsammans med ett Bitmap-objekt, som initieras med Loader-objektet.
   • Skapar ett andra Bitmap-objekt, dublett, som i sin tur anropar duplicateImage()-metoden, som skapar en dubblett av originalbilden.
   • Skapar ett BitmapData-objekt som tilldelas till dubblettobjektets BitmapData-objekt.
   • Skapar ett nytt Rectangle-objekt, som initieras med samma koordinater, bredd och höjd som originalbilden.
   • Skapar ett nytt Point-objekt, som har standardvärdena x = 0, y = 0.
   • Skapar följande variabler:
     • operation — Tillämpar en ny färg när tröskelvärdet är högre än eller lika med originalet.
     • tröskel — Det värde som varje pixel jämförs med (i detta exempel ljusgrått med ett alfavärde på 0xCC).
     • färg — Den färg på vilken de pixlar som klarar tröskeltestet ställs in – i det här fallet kraftigt gult.
     • mask — Raka motsatsen till färg (genomskinligt blått).
     • copySource — Inställt på false, vilket medför att pixelvärdena inte kopieras om tröskelvärdet inte godkänns. Detta värde är betydelselöst eftersom bilden är dubblerad och endast de pixlar som klarar tröskeln ändras.
   • Anropar threshold()-metoden med de föregående variablerna. Den resulterande tröskelekvationen ser ut så här: om (aktuellt pixelvärde & 0x000000FF) >= (0xCCCCCCCC & 0x000000FF) sätts pixeln till 0xFFFFFF00.

Obs!

• SWF-filen måste kompileras med parameter Lokal uppspelningssäkerhet satt till Använd bara lokala filer.
• I det här exemplet måste en fil med namnet Image.gif placeras i samma katalog som din SWF-fil.
• Vi rekommenderar att du använder en bild med en bredd på ungefär 80 pixlar.

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