Altura de la imagen de mapa de bits, expresada en píxeles.

Rectángulo que define el tamaño y la ubicación de la imagen de mapa de bits. Las partes superior e izquierda del rectángulo son 0; el ancho y el alto son iguales al ancho y al alto en píxeles del objeto BitmapData.

Define si la imagen de mapa de bits admite transparencia por píxel. Solamente puede definir este valor cuando cree un objeto BitmapData pasando true para el parámetro transparent del constructor. Posteriormente, tras crear un objeto BitmapData, puede comprobar si admite transparencia por píxel determinando si el valor de la propiedad transparent es true.

Anchura de la imagen de mapa de bits, expresada en píxeles.

Crea un nuevo objeto BitmapData con una determinada anchura y altura. Si especifica un valor para el parámetro fillColor, todos los píxeles del mapa de bits utilizan ese color.

De forma predeterminada, el mapa de bits se crea como transparente, a menos que pase el valor false para el parámetro transparent. Una vez que se ha creado un mapa de bits opaco, no se puede cambiar a uno transparente. Todos los píxeles de un mapa de bits opaco utilizan 24 bits de información del canal de color. Si define el mapa de bits como transparente, todos los píxeles utilizan 32 bits de información del canal de color, incluido un canal de transparencia alfa.

Un objeto BitmapData puede tener una altura y una anchura máximas de 2.880 píxeles. Si especifica un valor de anchura o altura mayor que 2.880, no se creará una instancia nueva.

Toma una imagen de origen y un objeto de filtro y genera la imagen filtrada.

Este método se basa en el comportamiento de los objetos de filtro incorporados, que determinan el rectángulo de destino que se ve afectado por un rectángulo de origen de entrada.

Después de aplicar un filtro, la imagen resultante puede ser mayor que la imagen de entrada. Por ejemplo, si se utiliza una clase BlurFilter para desenfocar un rectángulo de origen de (50,50,100,100) y un punto de destino de (10,10), el área que cambia en la imagen de destino será mayor que (10,10,60,60) debido al desenfoque. Esto sucede internamente durante la llamada a applyFilter().

Si el parámetro sourceRect del parámetro sourceBitmapData es una región interior, como (50,50,100,100) en una imagen de 200 x 200, el filtro utilizará los píxeles de origen fuera del parámetro sourceRect para generar el rectángulo de destino.

Si el objeto BitmapData y el objeto especificado como parámetro sourceBitmapData son el mismo objeto, Flash Player utilizará una copia temporal del objeto para ejecutar el filtro. Para lograr el máximo rendimiento, evite esta situación.

Parámetros

Véase también

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

Devuelve un objeto BitmapData nuevo que es un clon de la instancia original con una copia exacta del mapa de bits contenido.

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 los valores de color en una determinada área de una imagen de mapa de bits mediante un objeto ColorTransform. Si el rectángulo coincide con los límites de la imagen de mapa de bits, este método transformará los valores de color de toda la imagen.

Parámetros

Véase también

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 dos objetos BitmapData. Si los dos objetos BitmapData tienen las mismas dimensiones (anchura y altura), el método devolverá un nuevo objeto BitmapData, en el que cada píxel es la "diferencia" entre los píxeles de los dos objetos de origen:

• Si dos píxeles son iguales, el píxel de diferencia será 0x00000000.
• Si dos píxeles tiene diferentes valores RGB (omitiendo el valor alfa), el píxel de diferencia es 0xRRGGBB, donde RR/GG/BB son los valores de diferencia individuales entre los canales rojo, verde y azul (el valor de píxel en el objeto de origen menos el valor de píxel en el objeto otherBitmapData). Las diferencias del canal alfa se omiten en este caso.
• Si sólo es diferente el valor del canal alfa, el valor de píxel será 0xZZFFFFFF, donde ZZ es la diferencia en los valores alfa (el valor alfa del objeto de origen menos el valor alfa del objeto otherBitmapData).

Por ejemplo, veamos los dos objetos BitmapData siguientes:

  var bmd1:BitmapData = new BitmapData(50, 50, true, 0xFFFF8800);
  var bmd2:BitmapData = new BitmapData(50, 50, true, 0xCCCC6600);
  var diffBmpData:BitmapData = bmd1.compare(bmd2) as BitmapData;
  trace ("0x" + diffBmpData.getPixel(0,0).toString(16); // 0x332200
  

Nota: los colores utilizados para rellenar los dos objetos BitmapData tienen valores RGB ligeramente diferentes (0xFF8800 y 0xCC6600). El resultado del método compare() es un nuevo objeto BitmapData en el que cada píxel muestra la diferencia de los valores RGB entre los dos mapas de bits.

Piense en los dos objetos BitmapData siguientes en los que los colores RGB son iguales pero los valores alfa son 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
  

El resultado del método compare() es un nuevo objeto BitmapData en el que cada píxel muestra la diferencia de los valores alfa entre los dos mapas de bits.

Si los objetos BitmapData son equivalentes (con la misma anchura y altura e idénticos valores de píxeles), el método devolverá el número 0.

Si la anchura de los objetos BitmapData no es la misma, el método devolverá el número -3.

Si la altura de los objetos BitmapData no es la misma pero la anchura sí, el método devolverá el número -4.

En el ejemplo siguiente, se comparan dos objetos Bitmap con anchuras diferentes (50 y 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;

Transfiere datos de un canal de otro objeto BitmapData o del objeto BitmapData actual a un canal del objeto BitmapData actual. Se mantendrán todos los datos de los demás canales del objeto BitmapData de destino.

Los valores del canal de origen y del canal de destino pueden ser los siguientes:

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

Parámetros

Véase también

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

Proporciona una rutina rápida para la manipulación de píxeles entre imágenes sin efectos de color, rotación ni expansión. Este método copia un área rectangular de una imagen de origen en un área rectangular del mismo tamaño en el punto de destino del objeto BitmapData de destino.

Si incluye los parámetros alphaBitmap y alphaPoint, puede utilizar una imagen secundaria como origen de alfa para la imagen de origen. Si la imagen de origen tiene datos alfa, se utilizarán los dos conjuntos de datos alfa para componer píxeles de la imagen de origen en la imagen de destino. El parámetro alphaPoint es el punto de la imagen alfa que corresponde a la esquina superior izquierda del rectángulo de origen. Los píxeles que queden fuera de la intersección de la imagen de origen y la imagen alfa no se copiarán en la imagen de destino.

La propiedad mergeAlpha controla si se utiliza el canal alfa cuando se copia una imagen transparente sobre otra imagen transparente. Para copiar píxeles con los datos del canal alfa, defina la propiedad mergeAlpha como true. De forma predeterminada, la propiedad mergeAlpha es 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;

Libera memoria que se utiliza para almacenar el objeto BitmapData.

Cuando se llama al método dispose() para una imagen, la anchura y la altura de la imagen se establecen en 0. Todas las llamadas posteriores a los métodos o propiedades de esta instancia de BitmapData fallarán y se emitirá una excepción.

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
}

Dibuja el objeto de visualización source en la imagen de mapa de bits empleando el procesador de vectores de Flash Player. Puede especificar matrix, colorTransform, blendMode y un parámetro clipRect de destino para controlar cómo se realiza la representación. También puede especificar si el mapa de bits se debe suavizar cuando se escala (esto sólo funciona si el objeto de origen es un objeto BitmapData).

Este método corresponde directamente a cómo se dibujan los objetos con el procesador de vectores estándar para objetos en la interfaz de la herramienta de edición.

El objeto de visualización de origen no utiliza ninguna de sus transformaciones aplicadas para esta llamada. Se trata tal como se encuentra en la biblioteca o el archivo, sin transformación de matriz, transformación de color ni modo de mezcla. Para dibujar un objeto de visualización (como, por ejemplo, un clip de película) empleando sus propias propiedades de transformación, puede copiar su objeto de propiedad transform en la propiedad transform del objeto Bitmap que utiliza el objeto BitmapData.

Nota: el objeto source y (en el caso de un objeto Sprite o MovieClip) todos sus objetos secundarios deben proceder del mismo dominio que el origen de la llamada o estar en un archivo SWF que sea accesible al origen de la llamada mediante la llamada al método Security.allowDomain(). Si no se cumplen estas condiciones, el método draw() no dibujará nada.

Este método se admite a través de RTMP en Flash Player Update 3 y versiones posteriores. Puede controlar el acceso a transmisiones en Flash Media Server en un script del lado del servidor. Para más información, consulte las propiedades Client.audioSampleAccess y Client.videoSampleAccess en la referencia del lenguaje ActionScript del servidor para Adobe Flash Media Server.

Parámetros

	source:IBitmapDrawable — El objeto de visualización u objeto BitmapData que debe dibujarse en el objeto BitmapData. (Las clases DisplayObject y BitmapData implementan la interfaz IBitmapDrawable.)
	matrix:Matrix (default = null) — Un objeto Matrix empleado para escalar, rotar o convertir las coordenadas del mapa de bits. Si no desea aplicar una transformación de matriz a la imagen, establezca este parámetro con una matriz de identidad, creada con el constructor new Matrix() predeterminado o pase el valor null.
	colorTransform:ColorTransform (default = null) — Un objeto ColorTransform empleado para ajustar los valores de color del mapa de bits. Si no se proporciona ningún objeto, no se transformarán los colores de la imagen de mapa de bits. Si tiene que pasar este parámetro pero no desea transformar la imagen, defina el parámetro con un objeto ColorTransform creado mediante el constructor new ColorTransform() predeterminado.
	blendMode:String (default = null) — Un valor de cadena, de la clase flash.display.BlendMode, que especifica el modo de mezcla que debe aplicarse al mapa de bits resultante.
	clipRect:Rectangle (default = null) — Un objeto Rectangle que define el área del objeto de origen que se va a dibujar. Si no proporciona este valor, no se producirá recorte y se dibujará el objeto de origen completo.
	smoothing:Boolean (default = false) — Un valor booleano que determina si se suavizará un objeto BitmapData cuando se escale o gire, debido a un ajuste de escala o rotación en el parámetro matrix. El parámetro smoothing sólo se aplica si el parámetro source es un objeto BitmapData. Si smoothing se establece como false, la imagen BitmapData girada o escalada puede tener un aspecto pixelado o dentado. Por ejemplo, las dos imágenes siguientes utilizan el mismo objeto BitmapData para el parámetro source, pero el parámetro smoothing se establece como true a la izquierda y como false a la derecha: Dibujar un mapa de bits con smoothing definido como true lleva más tiempo que hacerlo con smoothing definido como false.

Véase también

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

Rellena un área rectangular de píxeles con un determinado color ARGB.

Parámetros

Véase también

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 una operación de relleno en una imagen empezando por una coordenada (x, y) y rellenando con un determinado color. El método floodFill() es similar a la herramienta cubo de pintura que incorporan muchos programas de dibujo. El color es un color ARGB que contiene información alfa y de color.

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 el rectángulo de destino al que afecta la llamada applyFilter(), dados un objeto BitmapData, un rectángulo de origen y un objeto de filtro.

Por ejemplo, un filtro de desenfoque suele afectar a un área mayor que la imagen original. Una imagen de 100 x 200 píxeles que se filtra mediante una instancia BlurFilter predeterminada, donde blurX = blurY = 4, genera un rectángulo de destino de (-2,-2,104,204). El método generateFilterRect() permite conocer el tamaño de este rectángulo de destino de antemano para poder ajustar el tamaño de la imagen de destino convenientemente antes de una operación de filtro.

Algunos filtros recortan su rectángulo de destino de acuerdo con el tamaño de la imagen de origen. Por ejemplo, un DropShadow interior no genera un resultado mayor que su imagen de origen. En esta API, se utiliza como límite de origen el objeto BitmapData y no el parámetro rect de origen.

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 una zona rectangular que encierra totalmente a todos los píxeles de un color determinado dentro de la imagen de mapa de bits (si el parámetro findColor se establece como true) o encierra totalmente a todos los píxeles que no incluyen el color especificado (si el parámetro findColor se ha establecido como false).

Por ejemplo, si tiene una imagen de origen y desea determinar el rectángulo de la imagen que contiene un canal alfa distinto de cero, pase {mask: 0xFF000000, color: 0x00000000} como parámetros. Si el parámetro findColor se define como true, se buscarán en toda la imagen los límites de píxeles para los que (value & mask) == color (donde value es el valor de color del píxel). Si el parámetro findColor se define como false, se buscarán en toda la imagen los límites de píxeles para los que (value & mask) != color (donde value es el valor de color del píxel). Para determinar el espacio blanco alrededor de una imagen, pase {mask: 0xFFFFFFFF, color: 0xFFFFFFFF} para buscar los límites de los píxeles no blancos.

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

Devuelve un entero que representa un valor de píxel RGB de un objeto BitmapData en un punto específico (x, y). El método getPixel() devuelve un valor de píxel no multiplicado. No se devuelve información de alfa.

Todos los píxeles de un objeto BitmapData se almacenan como valores de color premultiplicados. El píxel de imagen premultiplicado ya tiene los valores de canal de color rojo, verde y azul multiplicados por los datos alfa. Por ejemplo, si el valor alfa es cero, los canales RGB también son cero, independientemente de sus valores no multiplicados. Esta pérdida de datos puede ocasionar algunos problemas cuando se realizan operaciones. Todos los métodos BitmapData toman y devuelven valores no multiplicados. La representación interna de píxeles se convierte de premultiplicada a no multiplicada antes de que se devuelva como valor. Durante una operación dada, el valor de píxel se premultiplica antes de establecer el píxel de imagen en bruto.

Parámetros

Véase también

import flash.display.BitmapData;

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

var pixelValue:uint = bmd.getPixel(1, 1);
trace(pixelValue.toString(16)); // ff0000;

Devuelve un valor de color ARGB que contiene datos del canal alfa y datos de RGB. Este método es similar a getPixel(), que devuelve un color RGB sin datos del canal alfa.

Todos los píxeles de un objeto BitmapData se almacenan como valores de color premultiplicados. El píxel de imagen premultiplicado ya tiene los valores de canal de color rojo, verde y azul multiplicados por los datos alfa. Por ejemplo, si el valor alfa es cero, los canales RGB también son cero, independientemente de sus valores no multiplicados. Esta pérdida de datos puede ocasionar algunos problemas cuando se realizan operaciones. Todos los métodos BitmapData toman y devuelven valores no multiplicados. La representación interna de píxeles se convierte de premultiplicada a no multiplicada antes de que se devuelva como valor. Durante una operación dada, el valor de píxel se premultiplica antes de establecer el píxel de imagen en bruto.

Parámetros

Véase también

import flash.display.BitmapData;

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

var pixelValue:uint = bmd.getPixel32(1, 1);
var alphaValue:uint = pixelValue >> 24 & 0xFF;
var red:uint = pixelValue >> 16 & 0xFF;
var green:uint = pixelValue >> 8 & 0xFF;
var blue:uint = pixelValue & 0xFF;

trace(alphaValue.toString(16)); // ff
trace(red.toString(16)); // 44
trace(green.toString(16)); // aa
trace(blue.toString(16)); // cc

Genera una matriz de bytes de una zona rectangular de datos de píxeles. Escribe un entero sin signo (un valor de píxeles de 32 bits no multiplicado) para cada píxel de la matriz de bytes.

Parámetros

Véase también

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

Detecta la zona activa a nivel de píxeles entre una imagen de mapa de bits y un punto, un rectángulo u otra imagen de mapa de bits. Cuando se realiza la prueba de zona activa no se tiene en cuenta expansión, rotación ni ninguna otra transformación de ninguno de los objetos.

Si una imagen es opaca, se considerará un rectángulo totalmente opaco para este método. Las dos imágenes deben ser transparentes para realizar pruebas de zona activa a nivel de píxeles que tengan en cuenta la transparencia. Cuando se comprueban dos imágenes transparentes, los parámetros de umbral alfa controlan qué valores de canal, de 0 a 255, se consideran 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

Bloquea una imagen de manera que los objetos que hacen referencia al objeto BitmapData como, por ejemplo, los objetos Bitmap, no se actualicen cuando cambia este objeto BitmapData. Para mejorar el rendimiento, utilice este método junto con el método unlock() antes y después de realizar numerosas llamadas al método setPixel() o setPixel32().

Véase también

import flash.display.BitmapData;

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

Realiza una mezcla por canal de una imagen de origen a una imagen de destino. Por cada canal y cada píxel, se calcula un nuevo valor basado en los valores de canal de los píxeles de origen y de destino. Por ejemplo, en el canal rojo, el nuevo valor se calcula de la siguiente forma (donde redSrc es el valor del canal rojo para el píxel de la imagen de origen y redDest es el valor del canal rojo en el píxel correspondiente de la imagen de destino):

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

El evento redMultiplier, greenMultiplier, blueMultiplier y alphaMultiplier son los multiplicadores empleados para cada canal de color. Utilice un valor hexadecimal comprendido entre 0 y 0x100 (256) donde 0 especifica que se utiliza en el resultado el valor completo del destino, 0x100 especifica que se utiliza el valor completo del origen, y los números entre estos valores indican que se utiliza una mezcla (como 0x80 para el 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;