BitmapData  - AS3

A altura da imagem bitmap, em pixels.

O retângulo que define o tamanho e a localização da imagem bitmap. As partes superior e esquerda do retângulo são 0; a largura e a altura são iguais à largura e à altura em pixels do objeto BitmapData.

Define se a imagem bitmap oferece suporte à transparência por pixel. Você pode definir esse valor apenas ao construir um objeto BitmapData transmitindo true para o parâmetro transparente do construtor. Em seguida, depois de criar um objeto BitmapData, você poderá verificar se ele oferece suporte à transparência por pixel determinando se o valor da propriedade transparent é true.

A largura da imagem bitmap, em pixels.

Cria um objeto BitmapData com uma largura e altura especificadas. Se você especificar um valor para o parâmetro fillColor, cada pixel no bitmap será definido como essa cor.

Por padrão, o bitmap é criado como transparente, a não ser que você transmita o valor false para o parâmetro transparent. Depois de criar um bitmap opaco, não é possível alterá-lo para um bitmap transparente. Cada pixel em um bitmap opaco usa apenas 24 bits de informações de canais de cor. Se você definir o bitmap como transparente, cada pixel usará 32 bits de informações de canais de cor, incluindo um canal de transparência alfa.

No AIR 1.5 e no Flash Player 10, o tamanho máximo de um objeto BitmapData é de 8.191 pixels de largura ou de altura, e o número total de pixels não pode exceder 16.777.215 pixels. (Dessa forma, caso um objeto BitmapData tenha 8.191 pixels de largura, ele só pode ter 2.048 pixels de altura.) No Flash Player 9 e anteriores e no AIR 1.1 e anteriores, a limitação é de 2.880 pixels de altura e de 2.880 pixels de largura. Se você especificar um valor de altura ou largura maior do que 2.880, uma nova ocorrência não será criada.

Usa uma imagem de origem e um objeto de filtro e gera a imagem filtrada.

Esse método depende do comportamento de objetos de filtro embutidos, que determinam o retângulo de destino que é afetado por um retângulo de origem de entrada.

Após a aplicação de um filtro, a imagem resultante pode ser maior do que a imagem de entrada. Por exemplo, se você uma classe BlurFilter para aplicar desfoque a um retângulo de origem de (50,50,100,100) e um ponto de destino de (10,10), a área que será alterada na imagem de destino será maior do que (10,10,60,60) por causa do desfoque. Isso acontece internamente durante a chamada applyFilter().

Se o parâmetro retOrigem do parâmetro dadosBitmapOrigem for uma região interior, como (50,50,100,100) em uma imagem de 200 x 200, o filtro usará os pixels de origem fora do parâmetro retOrigem para gerar o retângulo de destino.

Se o objeto BitmapData e o objeto especificado como o parâmetro sourceBitmapData forem o mesmo objeto, o aplicativo usará uma cópia temporária do objeto para realizar a filtragem. Para obter o melhor desempenho, evite essa situação.

Parâmetros

Elementos da API relacionados

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

Retorna um novo objeto BitmapData que é clone da ocorrência original com uma cópia exata do bitmap contido.

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

Ajusta os valores de cor em uma área especificada de uma imagem bitmap usando um objeto ColorTransform. Se o retângulo corresponder aos limites da imagem bitmap, esse método transformará os valores de cor da imagem inteira.

Parâmetros

Elementos da API relacionados

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

Compara dois objetos BitmapData. Se dois objetos BitmapData tiverem as mesmas dimensões (largura e altura), o método retornará um novo objeto BitmapData, no qual cada pixel é a "diferença" entre os pixels nos dois objetos de origem:

• Se dois pixels forem iguais, o pixel de diferença será 0x00000000.
• Se dois pixels tiverem valores RGB diferentes (ignorando o valor alfa), o pixel de diferença será 0xRRGGBB, em que RR/GG/BB são os valores de diferença individuais entre os canais de vermelho, verde e azul (o valor de pixel no objeto de origem menos o valor de pixel no objeto otherBitmapData). Diferenças de canais alfa são ignoradas nesse caso.
• Se apenas o valor do canal alfa for diferente, o valor do pixel será 0xZZFFFFFF, em que ZZ é a diferença nos valores alfa (o valor alfa no objeto de origem menos o valor alfa no objeto otherBitmapData).

Por exemplo, considere os dois objetos BitmapData a seguir:

     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
     

Observação: As cores usadas para preencher os dois objetos BitmapData têm valores RGB um pouco diferentes (0xFF0000 e 0xFFAA00). O resultado do método compare() é um novo objeto BitmapData com cada pixel mostrando a diferença nos valores RGB entre os dois bitmaps.

Considere os dois objetos BitmapData a seguir, nos quais as cores RGB são as mesmas, mas os valores alfa são diferentes:

     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
     

O resultado do método compare() é um novo objeto BitmapData com cada pixel mostrando a diferença nos valores alfa entre os dois bitmaps.

Se os objetos BitmapData forem equivalentes (com as mesmas largura e altura e valores de pixels idênticos), o método retornará o número 0.

Se as larguras dos objetos BitmapData não forem iguais, o método retornará o número -3.

Se as alturas dos objetos BitmapData não forem iguais, mas as larguras forem as mesmas, o método retornará o número -4.

O exemplo a seguir compara dois objetos Bitmap com larguras diferentes (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
     

Parâmetros

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;

Transfere dados de um canal de outro objeto BitmapData ou do objeto BitmapData atual para um canal do objeto BitmapData atual. Todos os dados nos outros canais do objeto BitmapData são preservados.

O valor do canal de origem e o valor do canal de destino podem ser um dos seguintes:

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

Parâmetros

Elementos da API relacionados

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

Fornece uma rotina rápida para executar a manipulação de pixels entre imagens sem estiramento, giro ou efeitos de cor. Esse método copia uma área retangular de uma imagem de origem em uma área retangular com o mesmo tamanho no ponto de destino do objeto BitmapData de destino.

Se você incluir os parâmetros alfaBitmap e pontoAlfa, poderá usar uma imagem secundária como origem alfa para a imagem de origem. Se a imagem de origem tiver dados alfa, ambos os conjuntos de dados alfa serão usados para compor pixels da imagem de origem para a imagem de destino. O parâmetro pontoAlfa é o ponto na imagem alfa que corresponde ao canto superior esquerdo do retângulo de origem. Nenhum dos pixels fora da interseção da imagem de origem e da imagem alfa é copiado para a imagem de destino.

A propriedade mergeAlpha controla se o canal alfa é o não usado quando uma imagem transparente é copiada em outra imagem transparente. Para copiar pixels com os dados de canal alfa, defina a propriedade mergeAlpha como true. Por padrão, a propriedade mergeAlpha é false.

Parâmetros

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;

Preenche uma matriz de bytes com base em uma região retangular dos dados de pixels. Iniciando-se do índice da posição do ByteArray, este método escreve um inteiro sem sinal (um valor de pixel não multiplicado de 32 bits) para cada pixel em uma matriz de bytes. Se for necessário, o tamanho da matriz de bytes é aumentada para o número necessário de bytes para armazenar todos os dados de pixels.

Parâmetros

Elementos da API relacionados

Libera a memória usada para armazenar o objeto BitmapData.

Quando o método dispose() é chamado em uma imagem, a largura e a altura dessa imagem são definidas como 0. Todas as chamadas subsequentes a métodos ou propriedades dessa ocorrência de BitmapData falharão e uma exceção será lançada.

BitmapData.dispose() libera a memória ocupada pelos dados de reais do bitmap, imediatamente (um bitmap pode consumir até 64 Mb da memória). Depois de usar BitmapData.dispose(), o objeto de BitmapData não é mais utilizável e o tempo de execução de Flash lança uma exceção se você chamar funções no objeto BitmapData. No entanto, BitmapData.dispose() não faz a coleta do lixo do objeto BitmapData (aproximadamente 128 bytes); a memória ocupada pelo objeto BitmapData real é liberada no momento em que o objeto de BitmapData é reunido pelo coletor de lixo.

Elementos da API relacionados

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
}

Desenha o objeto de exibição source na imagem bitmap, usando o renderizador de vetores do tempo de execução do Flash. Você pode especificar o parâmetro matrix, transformaçãoCor, modoMesclagem e um parâmetro retCorte de destino para controlar como é feita a renderização. Opcionalmente, é possível especificar se o bitmap deve ser suavizado quando dimensionado (isso apenas funcionará se o objeto de origem for um objeto BitmapData).

Nota: O método drawWithQuality() funciona exatamente como o método draw(), mas em vez de usar a propriedade Stage.quality para determinar a qualidade da renderização de vetor, você especifica o parâmetro quality para o método drawWithQuality().

Esse método corresponde diretamente a como os objetos são desenhados com o renderizador de vetores padrão para objetos na interface da ferramenta de autoria.

O objeto de exibição de origem não usa nenhuma de suas transformações aplicadas para essa chamada. Ele é tratado como existente na biblioteca ou no arquivo, sem transformação de matriz, transformação de cor e modo de mesclagem. Para desenhar um objeto de exibição (como um clipe de filme) usando suas próprias propriedades de transformação, você pode copiar a propriedade transform do objeto para a propriedade transform do objeto Bitmap que usa o objeto BitmapData.

Este método é suportado pelo RTMP no Flash Player 9.0.115.0 e posterior e no Adobe AIR. Você pode controlar o acesso a fluxos no Flash Media Server em um script do lado do servidor. Para obter mais informações, consulte as propriedades Client.audioSampleAccess e Client.videoSampleAccess na Referência de lado do servidor do ActionScript para Adobe Flash Media Server.

Se o objeto source e (no caso de um objeto Sprite ou MovieClip) todos os seus objetos filhos não são provenientes do mesmo domínio do chamador ou não estão em um conteúdo acessível ao chamador depois que ele chamar o métodoSecurity.allowDomain(), uma chamada para o draw() lança uma exceção de SecurityError. Esta restrição não se aplica ao conteúdo do AIR na área de segurança do aplicativo.

Também há restrições quanto ao uso de uma imagem bitmap carregada como source. Uma chamada para o método draw() é bem-sucedida caso a imagem carregada esteja no mesmo domínio do chamador. Além disso, um arquivo de política em vários domínios no servidor da imagem pode conceder a permissão ao domínio do conteúdo SWF que chama o método draw(). Nesse caso, você deve definir a propriedade checkPolicyFile de um objeto LoaderContext, além de usar esse objeto como o parâmetro context durante a chamada do método load() do objeto Loader usado para carregar a imagem. Essas restrições não se aplicam ao conteúdo do AIR na área de segurança do aplicativo.

No Windows, o método draw() não pode capturar o conteúdo SWF incorporado em uma página HTML em um objeto HTMLLoader no Adobe AIR.

O método draw() não pode capturar conteúdo PDF no Adobe AIR. Ele também não pode capturar ou incorporar conteúdo SWF em HTML em que o atributo wmode é definido como "window" no Adobe AIR.

Parâmetros

Elementos da API relacionados

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

Desenha o objeto de exibição source na imagem bitmap, usando o renderizador de vetores do tempo de execução do Flash. Você pode especificar o parâmetro matrix, transformaçãoCor, modoMesclagem e um parâmetro retCorte de destino para controlar como é feita a renderização. Opcionalmente, é possível especificar se o bitmap deve ser suavizado quando dimensionado (isso apenas funcionará se o objeto de origem for um objeto BitmapData).

Nota: O método drawWithQuality() funciona exatamente como o método draw(), mas em vez de usar a propriedade Stage.quality para determinar a qualidade da renderização de vetor, você especifica o parâmetro quality para o método drawWithQuality().

Esse método corresponde diretamente a como os objetos são desenhados com o renderizador de vetores padrão para objetos na interface da ferramenta de autoria.

O objeto de exibição de origem não usa nenhuma de suas transformações aplicadas para essa chamada. Ele é tratado como existente na biblioteca ou no arquivo, sem transformação de matriz, transformação de cor e modo de mesclagem. Para desenhar um objeto de exibição (como um clipe de filme) usando suas próprias propriedades de transformação, você pode copiar a propriedade transform do objeto para a propriedade transform do objeto Bitmap que usa o objeto BitmapData.

Este método é suportado pelo RTMP no Flash Player 9.0.115.0 e posterior e no Adobe AIR. Você pode controlar o acesso a fluxos no Flash Media Server em um script do lado do servidor. Para obter mais informações, consulte as propriedades Client.audioSampleAccess e Client.videoSampleAccess na Referência de lado do servidor do ActionScript para Adobe Flash Media Server.

Se o objeto de origem e (no caso de um objeto Sprite ou MovieClip) todos os seus objetos filhos não são provenientes do mesmo domínio do chamador ou não estão em um conteúdo acessível ao chamador depois que ele chamar o métodoSecurity.allowDomain(), uma chamada para o drawWithQuality() lança uma exceção de SecurityError. Esta restrição não se aplica ao conteúdo do AIR na área de segurança do aplicativo.

Também há restrições quanto ao uso de uma imagem bitmap carregada como source. Uma chamada para o método drawWithQuality() será bem-sucedida caso a imagem carregada esteja no mesmo domínio do chamador. Além disso, um arquivo de política em vários domínios no servidor da imagem pode conceder a permissão ao domínio do conteúdo SWF que chama o método drawWithQuality(). Nesse caso, você deve definir a propriedade checkPolicyFile de um objeto LoaderContext, além de usar esse objeto como o parâmetro context durante a chamada do método load() do objeto Loader usado para carregar a imagem. Essas restrições não se aplicam ao conteúdo do AIR na área de segurança do aplicativo.

No Windows, o método drawWithQuality() não pode capturar o conteúdo SWF incorporado em uma página HTML em um objeto HTMLLoader no Adobe AIR.

O método drawWithQuality() não pode capturar conteúdo PDF no Adobe AIR. Ele também não pode capturar ou incorporar conteúdo SWF em HTML em que o atributo wmode é definido como "window" no Adobe AIR.

Parâmetros

Elementos da API relacionados

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

Compacta este objeto BitmapData usando o algoritmo de compactação selecionado e retorna um novo objeto ByteArray. Como alternativa, grava os dados resultantes na ByteArray especificada. O argumento compressor especifica o algoritmo de codificação e pode ser PNGEncoderOptions, JPEGEncoderOptions, ou JPEGXREncoderOptions.

O exemplo a seguir compacta um objeto de BitmapData usando 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); 

Parâmetros

Elementos da API relacionados

Preenche uma área retangular de pixels com uma cor ARGB especificada.

Parâmetros

Elementos da API relacionados

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

Realiza uma operação de preenchimento em uma imagem, começando em uma coordenada (x, y) e preenchendo com uma certa cor. O método floodFill() é semelhante à ferramenta lata de tinta em vários programas de pintura. A cor é uma cor ARGB que contém informações alfa e informações de cores.

Parâmetros

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 o retângulo de destino afetado pela chamada do método applyFilter(), considerando um objeto BitmapData, um retângulo de origem e um objeto de filtro.

Por exemplo, um filtro de desfoque normalmente afeta uma área maior do que o tamanho da imagem original. Uma imagem de 100 x 200 pixels que está sendo filtrada por uma ocorrência de BlurFilter padrão, em que blurX = blurY = 4 gera um retângulo de destino de (-2,-2,104,204). O método generateFilterRect() permite descobrir o tamanho desse retângulo de destino com antecedência, para que você possa dimensionar a imagem de destino apropriadamente antes de realizar uma operação de filtro.

Alguns filtros cortam seu retângulo de destino com base no tamanho da imagem de origem. Por exemplo, um filtro DropShadow interno não gera um resultado maior do que sua imagem de origem. Nessa API, o objeto BitmapData é usado como os limites de origem e não o parâmetro ret de origem.

Parâmetros

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 uma região retangular que delimita totalmente todos os pixels de uma cor especificada dentro da imagem bitmap (se o parâmetro localizarCor estiver definido como true) ou que delimita totalmente todos os pixels que não incluem a cor especificada (se o parâmetro localizarCor estiver definido como false).

Por exemplo, se você tiver uma imagem de origem e quiser determinar o retângulo da imagem que contém um canal alfa diferente de zero, transmita {máscara: 0xFF000000, cor: 0x00000000} como parâmetros. Se o parâmetro localizarCor estiver definido como true, a imagem inteira será pesquisada quanto aos limites de pixels para os quais (valor e máscara) == cor (em que value é o valor de cor do pixel). Se o parâmetro localizarCor estiver definido como false, a imagem inteira será pesquisada quanto aos limites de pixels para os quais (valor e máscara) != cor (em que value é o valor de cor do pixel). Para determinar o espaço em branco em torno de uma imagem, passe o {mask: 0xFFFFFFFF, cor: 0xFFFFFFFF} para localizar os limites de pixels não brancos.

Parâmetros

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

Retorna um inteiro que representa um valor de pixel RGB a partir do objeto BitmapData em um ponto específico (x, y). O método getPixel() retorna um valor de pixel não multiplicado. Nenhuma informação de alfa é retornada.

Todos os pixels em um objeto BitmapData são armazenados como valores de cor não multiplicados. Um pixel de imagem pré-multiplicado que tem os valores dos canais de cores de vermelho, verde e azul já multiplicados pelos dados alfa. Por exemplo, se o valor de alfa for 0, os valores para os canais RGB também serão 0, independentemente dos valores não multiplicados. Essa perda de dados poderá causar alguns problemas quando você realizar operações. Todos os métodos BitmapData usam e retornam valores não multiplicados. A representação de pixels internos é convertida de pré-multiplicada em não multiplicada antes de ser retornada como um valor. Durante uma operação de definição, o valor de pixel é pré-multiplicado antes de o pixel de imagem bruto ser definido.

Parâmetros

Elementos da API relacionados

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;

Retorna um valor de cor ARGB que contém dados de canais alfa e dados RGB. Esse método é semelhante ao método getPixel(), que retorna uma cor RGB sem dados de canais alfa.

Todos os pixels em um objeto BitmapData são armazenados como valores de cor não multiplicados. Um pixel de imagem pré-multiplicado que tem os valores dos canais de cores de vermelho, verde e azul já multiplicados pelos dados alfa. Por exemplo, se o valor de alfa for 0, os valores para os canais RGB também serão 0, independentemente dos valores não multiplicados. Essa perda de dados poderá causar alguns problemas quando você realizar operações. Todos os métodos BitmapData usam e retornam valores não multiplicados. A representação de pixels internos é convertida de pré-multiplicada em não multiplicada antes de ser retornada como um valor. Durante uma operação de definição, o valor de pixel é pré-multiplicado antes de o pixel de imagem bruto ser definido.

Parâmetros

Elementos da API relacionados

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

Gera uma matriz de bytes a partir de uma região retangular dos dados de pixels. Grava um inteiro não sem sinal (um valor de pixel não multiplicado de 32 bits) para cada pixel na matriz de bytes.

Parâmetros

Elementos da API relacionados

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

Gera uma matriz de vetores a partir de uma região retangular dos dados de pixel. Retorna um objeto Vector de inteiros não assinados (um valor de pixel não multiplicado de 32 bits) para o retângulo especificado.

Parâmetros

Calcula um histograma de número binário de valor 256 de um objeto BitmapData. Esse método retorna um objeto Vector contendo quatro ocorrências de Vector.<Number> (quatro objetos Vector que contêm objetos Number). As quatro ocorrências de Vector representam os componentes vermelho, verde, azul e alfa, respectivamente. Cada ocorrência de Vector contém 256 valores que representam a contagem de preenchimento do valor de componente individual, de 0 a 255.

Parâmetros

Realiza a detecção de ocorrências em nível de pixels entre uma imagem bitmap e um ponto, um retângulo ou outra imagem bitmap. Uma ocorrência é definida como uma sobreposição de um ponto ou retângulo sobre um pixel opaco, ou dois pixels opacos de sobreposição. Nenhuma operação de estiramento, giro ou outra transformação de qualquer objeto será considerada quando o teste de ocorrência for realizado.

Se uma imagem for opaca, ela será considerada um retângulo totalmente opaco para esse método. Ambas as imagens devem ser transparentes para realizar um teste de ocorrência em nível de pixels que considere a transparência. Quando você testa duas imagens transparentes, os parâmetros de limite de alfa controlam quais valores de canais alfa, de 0 a 255, são considerados opacos.

Parâmetros

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

Bloqueia uma imagem de forma que qualquer objeto que faça referência ao objeto BitmapData, como objetos Bitmap, não seja atualizado quando esse objeto BitmapData for alterado. Para melhorar o desempenho, use esse método junto com o método unlock() antes e depois de várias chamadas ao método setPixel() ou setPixel32().

Elementos da API relacionados

import flash.display.BitmapData;

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

Realiza a mesclagem por canal a partir de uma imagem de origem para uma imagem de destino. Para cada canal e cada pixel, um novo valor é calculado com base nos valores de canal dos pixels de origem e destino. Por exemplo, no canal de vermelho, o novo valor é calculado da seguinte maneira (em que redSrc é o valor do canal de vermelho para um pixel na imagem de origem e redDest é o valor do canal de vermelho no pixel correspondente da imagem de destino):

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

Os valores de redMultiplier, greenMultiplier, blueMultiplier e alphaMultiplier são os multiplicadores usados para cada canal de cor. Use um valor hexadecimal que varia de 0 a 0x100 (256), em que 0 especifica que o valor total a partir do destino é usado no resultado, 0x100 especifica que o valor total a partir da origem é usado e os números intermediários especificam que uma mesclagem é usada (como 0x80 para 50%).

Parâmetros

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;

Preenche uma imagem com pixels que representam ruído aleatório.

Parâmetros

Elementos da API relacionados

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;

Remapeia os valores dos canais de cor em uma imagem que possui até quatro matrizes de dados de paleta de cores, uma para cada canal.

O tempo de execução do Flash usa as etapas a seguir para gerar a imagem resultante:

1. Após o cálculo dos valores de vermelho, verde, azul e alfa, eles são somados com o uso da aritmética padrão de inteiros de 32 bits.
2. Os valores dos canais de vermelho, verde, azul e alfa de cada pixel são extraídos em valores separados de 0 a 255. Esses valores são usados para procurar novos valores de cores na matriz apropriada: redArray, greenArray, blueArray e alphaArray. Cada uma dessas quatro matrizes deve conter 256 valores.
3. Após a recuperação de todos os quatro novos valores de canal, eles serão combinados em um valor ARGB padrão que é aplicado ao pixel.

Efeitos entre canais podem ser suportados com esse método. Cada matriz de entrada pode conter valores completos de 32 bits e não haverá deslocamentos quando os valores forem somados. Essa rotina não oferece suporte à fixação por canal.

Se nenhuma matriz for especificada para um canal, o canal de cor será copiado da imagem de origem para a imagem de destino.

Você pode usar esse método para uma variedade de efeitos, como mapeamento geral de paletas (usando um canal e convertendo-o em uma imagem colorida falsa). Esse método também pode ser usado para vários algoritmos avançados de manipulação de cores, como gama, curvas, níveis e quantização.

Parâmetros

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

Gera uma imagem de ruído Perlin.

O algoritmo de geração de ruído Perlin interpola e combina funções individuais de ruído aleatório (chamadas de oitavas) em uma única função que gera ruído aleatório com aparência mais natural. Como oitavas musicais, cada função de oitava é duas vezes a frequência da anterior. O ruído Perlin foi descrito como uma "soma fractal de ruído" porque combina vários conjuntos de dados de ruído com diferentes camadas de detalhe.

Você pode usar funções de ruído Perlin para simular paisagens e fenômenos naturais, como fibras de madeira, nuvens e cadeias de montanha. Na maioria dos casos, a saída de uma função de ruído Perlin não é exibida diretamente, mas é usada para melhorar outras imagens e lhes dar variações pseudoaleatórias.

Funções de ruído aleatório digital simples frequentemente produzem imagens com pontos ásperos contrastantes. Em geral, esse tipo de contraste áspero não é encontrado em essência. O algoritmo de ruído Perlin mescla várias funções de ruído que operam em diferentes níveis de detalhes. Esse algoritmo resulta em variações menores entre os valores de pixels vizinhos.

Parâmetros

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

Realiza uma operação de dissolver pixels a partir de uma imagem de origem para uma imagem de destino ou usando a mesma imagem. O tempo de execução do Flash usa um valor randomSeed para gerar uma dissolução de pixels aleatória. O valor de retorno da função deve ser transmitido em chamadas subsequentes para continuar a dissolução de pixels até ela terminar.

Se a imagem de origem não for igual à de destino, os pixels serão copiados da origem para o destino usando todas as propriedades. Esse processo permite a dissolução de uma imagem branca em uma imagem totalmente preenchida.

Se as imagens de origem e destino forem iguais, os pixels serão preenchidos com o parâmetro cor. Esse processo permite a dissolução a partir de uma imagem totalmente preenchida. Nesse modo, o parâmetro ponto de destino é ignorado.

Parâmetros

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

Rola uma imagem em uma certa quantidade de pixels (x, y). As regiões de borda fora da área de rolagem são inalteradas.

Parâmetros

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

Define um único pixel de um objeto BitmapData. O valor do canal alfa atual do pixel de imagem é preservado durante essa operação. O valor do parâmetro de cor RGB é tratado como um valor de cor não multiplicado.

Observação: Para aumentar o desempenho, ao usar o método setPixel() ou setPixel32() repetidamente, chame o método lock() antes de chamar o método setPixel() ou setPixel32() e então chame o método unlock() quando tiver feito todas as alterações de pixel. Esse processo impede que os objetos que fazem referência a essa ocorrência de BitmapData sejam atualizados até você terminar de fazer as alterações de pixel.

Parâmetros

Elementos da API relacionados

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

Define os valores de cor e transparência alfa de um único pixel de um objeto BitmapData. Esse método é semelhante ao método setPixel(); a principal diferença é que o método setPixel32() usa um valor de cor ARGB que contém informações de canais alfa.

Todos os pixels em um objeto BitmapData são armazenados como valores de cor não multiplicados. Um pixel de imagem pré-multiplicado que tem os valores dos canais de cores de vermelho, verde e azul já multiplicados pelos dados alfa. Por exemplo, se o valor de alfa for 0, os valores para os canais RGB também serão 0, independentemente dos valores não multiplicados. Essa perda de dados poderá causar alguns problemas quando você realizar operações. Todos os métodos BitmapData usam e retornam valores não multiplicados. A representação de pixels internos é convertida de pré-multiplicada em não multiplicada antes de ser retornada como um valor. Durante uma operação de definição, o valor de pixel é pré-multiplicado antes de o pixel de imagem bruto ser definido.

Observação: Para aumentar o desempenho, ao usar o método setPixel() ou setPixel32() repetidamente, chame o método lock() antes de chamar o método setPixel() ou setPixel32() e então chame o método unlock() quando tiver feito todas as alterações de pixel. Esse processo impede que os objetos que fazem referência a essa ocorrência de BitmapData sejam atualizados até você terminar de fazer as alterações de pixel.

Parâmetros

Elementos da API relacionados

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 uma matriz de bytes em uma região retangular de dados de pixels. Para cada pixel, o método ByteArray.readUnsignedInt() é chamada e o valor de retorno é gravado no pixel. Se a matriz de bytes terminar antes da gravação de todo o retângulo, a função será retornada. Espera-se que os dados na matriz de bytes sejam valores de pixels ARGB de 32 bits. Nenhuma busca é realizada na matriz de bytes antes ou após a leitura dos pixels.

Parâmetros

Elementos da API relacionados

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 um Vector em uma região retangular de dados de pixels. Para cada pixel, um elemento de Vector é lido e gravado no pixel BitmapData. Espera-se que os dados no Vector sejam valores de pixels ARGB de 32 bits.

Parâmetros

Testa valores de pixels em uma imagem com base em um limite especificado e define os pixels aprovados no texto como novos valores de cor. Usando o método threshold(), você pode isolar e substituir faixas de cores em uma imagem e realizar outras operações lógicas em pixels de imagens.

A lógica de teste do método threshold() é a seguinte:

1. Se ((valorPixel e máscara) operação (limite e máscara)), defina o pixel como cor;
2. Caso contrário, se copiarOrigem == true, defina o pixel como o valor de pixel correspondente a partir de bitmapOrigem.

O parâmetro operação especifica o operador de comparação a ser usado para o teste de limite. Por exemplo, usando "==" como o parâmetro operação, você pode isolar um valor de cor específico em uma imagem. Ou usando o {operação: "<", máscara: 0xFF000000, limite: 0x7F000000, cor: 0x00000000}, é possível definir todos os pixels de destino de forma que eles sejam totalmente transparentes quando o alfa da imagem de origem for menor do que 0x7F. Essa técnica pode ser usada para transições animadas e outros efeitos.

Parâmetros

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

Desbloqueia uma imagem de forma que qualquer objeto que faça referência ao objeto BitmapData, como objetos Bitmap, seja atualizado quando esse objeto BitmapData for alterado. Para melhorar o desempenho, use esse método junto com o método lock() antes e depois de várias chamadas ao método setPixel() ou setPixel32().

Parâmetros

Elementos da API relacionados

import flash.display.BitmapData;

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

1. Uma propriedade url é criada, representando a localização e o nome do arquivo de imagem
2. O construtor da classe cria um objeto Loader, que então instancia um ouvinte de evento que é despachado quando o método completeHandler() completa a manipulação da imagem.
3. O objeto URLRequest request é transmitido a loader.load(), que carrega a imagem na memória usando um objeto de exibição.
4. A imagem é então inserida na lista de exibição, que a exibe nas coordenadas x = 0, y = 0 da tela.
5. O método completeHandler() realiza as seguintes tarefas:
   • Cria um segundo Loader, junto com um objeto Bitmap, que é inicializado com o objeto Loader.
   • Cria um segundo objeto Bitmap, duplicate, que, por sua vez, chama o método duplicateImage(), que cria uma duplicata da imagem original.
   • Cria um objeto BitmapData, que é atribuído ao objeto BitmapData do objeto duplicate.
   • Cria um novo objeto Rectangle inicializado com as mesmas coordenadas, largura e altura que a imagem original.
   • Cria um novo objeto Point, que assume como padrão x = 0, y = 0.
   • Cria as seguintes variáveis:
     • operation – Aplica a nova cor quando o valor de limite é maior do que ou igual ao original.
     • threshold – O valor com base no qual cada pixel é comparado (neste exemplo, cinza-claro com um alfa de 0xCC).
     • color – A cor com a qual serão definidos os pixels que passarem no teste de limite, que é amarelo sólido nesse caso.
     • mask – O oposto exato da cor (azul transparente).
     • copySource – Defina como false, indicando que os valores de pixel não serão copiados se o valor de limite não passar no teste. Esse valor não tem significado, já que a imagem é duplicada e somente os pixels que passarem no teste de limite serão alterados.
   • Chama o método threshold() usando as variáveis anteriores. A equação de limite resultante é a seguinte: se (Valor de pixel atual & 0x000000FF) >= (0xCCCCCCCC & 0x000000FF) defina o pixel como 0xFFFFFF00.

Observações:

• Será necessário compilar o arquivo SWF com a Segurança de reprodução local definida como Acessar somente arquivos locais.
• Esse exemplo requer que um arquivo denominado Image.gif seja inserido no mesmo diretório que o seu arquivo SWF.
• Convém usar uma imagem com aproximadamente até 80 pixels de largura.

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