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;

Rellena una imagen con píxeles que representan ruido aleatorio.

Parámetros

Véase también

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;

Reasigna los valores del canal de color en una imagen proporcionada a cuatro conjuntos de datos de la paleta de colores, una por cada canal.

Flash Player utiliza los siguientes pasos para generar la imagen resultante:

1. Después de calcular los valores rojo, verde, azul y alfa, se suman utilizando aritmética estándar de enteros de 32 bits.
2. Los valores del canal rojo, azul, verde y alfa de cada píxel se extraen en valores entre 0 y 255 independientes. A continuación se utilizan estos valores para consultar nuevos valores de color en la matriz adecuada: redArray, greenArray, blueArray y alphaArray. Cada una de estas cuatro matrices debe contener 256 valores.
3. Después de recuperar los cuatro valores de canal nuevos, se combinan en un valor ARGB estándar que se aplica al píxel.

Este método admite efectos intercanal. Cada matriz de entrada puede contener valores completos de 32 bits, y no se produce desplazamiento cuando se suman los valores. Esta rutina no admite fijación de canales individuales.

Si no se especifica ninguna matriz para un canal, el canal de color se copia desde la imagen de origen hasta la de destino.

Puede emplear este método para diversos efectos, como asignación de paleta general (tomando un canal y convirtiéndolo en una imagen de color falso). También puede utilizarlo para una gran variedad de algoritmos de manipulación de color avanzados, como gamma, curvas, niveles y cuantificación.

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

Genera una imagen de ruido Perlin.

El algoritmo de generación de ruido Perlin interpola y combina funciones individuales de ruido aleatorio (denominadas octavas) en una función única que genera ruido aleatorio de aspecto más natural. Como las octavas musicales, cada función de octava es dos veces la frecuencia de la anterior. El ruido Perlin se ha descrito como una "suma fractal de ruido", ya que combina múltiples conjuntos de datos de ruido con distintos niveles de detalle.

Las funciones de ruido Perlin pueden emplearse para simular fenómenos naturales y paisajes, como la fibra de la madera, nubes o montañas. En la mayoría de los casos, el resultado de esta función no se muestra directamente, sino que se utiliza para procesar otras imágenes y darles variaciones seudo-aleatorias.

Las funciones digitales sencillas de ruido aleatorio producen a menudo imágenes con puntos contrastados y discordantes. Este tipo de contraste no suele darse en la naturaleza. El algoritmo de ruido Perlin combina varias funciones de ruido que funcionan en distintos niveles de detalle. Este algoritmo produce menores variaciones entre los valores de píxel colindantes.

Nota: el algoritmo de ruido Perlin recibe su nombre de Ken Perlin, que lo desarrolló después de generar gráficos para la película Tron en 1982. En 1997, Perlin ganó un Oscar en la categoría de logros tecnológicos por la función de ruido que había desarrollado.

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 una disolución de píxeles de una imagen de origen a una imagen de destino o utilizando la misma imagen. Flash Player utiliza un valor randomSeed para generar una disolución de píxeles aleatoria. El valor devuelto por la función debe pasarse en llamadas posteriores para continuar la disolución de píxeles hasta terminar.

Si la imagen de origen no es igual a la de destino, los píxeles se copiarán desde el origen hasta el destino utilizando todas las propiedades. Este proceso permite disolver desde una imagen en blanco hasta una imagen completamente llena.

Si las imágenes de origen y destino son iguales, los píxeles se rellenan con el parámetro color. Este proceso permite disolver desde una imagen completamente llena. En este modo se ignora el parámetro point de destino.

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

Desplaza una imagen una determinada cantidad de píxeles (x, y). Las regiones del borde fuera del área de desplazamiento permanecen sin modificar.

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

Establece un solo píxel de un objeto BitmapData. Durante esta operación se mantiene el valor del canal alfa actual del píxel de la imagen. El valor del parámetro de color RGB se trata como un valor de color no multiplicado.

Nota: para aumentar el rendimiento al utilizar el método setPixel() o setPixel32() repetidamente, llame al método lock() antes de llamar a setPixel() o setPixel32() y luego llame al método unlock() cuando haya realizado todos los cambios de píxeles. Este proceso evita que los objetos que hacen referencia a esta instancia de BitmapData se actualicen hasta que termine de realizar los cambios en los píxeles.

Parámetros

Véase también

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

Establece los valores de color y transparencia alfa de un solo píxel de un objeto BitmapData. Este método es similar a setPixel(); la diferencia principal radica en que el método setPixel32() toma un valor de color ARGB que contiene información 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.

Nota: para aumentar el rendimiento al utilizar el método setPixel() o setPixel32() repetidamente, llame al método lock() antes de llamar a setPixel() o setPixel32() y luego llame al método unlock() cuando haya realizado todos los cambios de píxeles. Este proceso evita que los objetos que hacen referencia a esta instancia de BitmapData se actualicen hasta que termine de realizar los cambios en los píxeles.

Parámetros

Véase también

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

Convierte una matriz de bytes en una zona rectangular de datos de píxeles. Por cada píxel, se llama al método ByteArray.readUnsignedInt() y se escribe el valor devuelto en el píxel. Si la matriz de bytes termina antes de que se escriba en todo el rectángulo, la función devuelve un valor. Se espera que los datos de la matriz de bytes sean valores de píxeles ARGB de 32 bits. No se realiza ninguna búsqueda en la matriz de bytes ni antes ni después de que se lean los píxeles.

Parámetros

Véase también

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;

Prueba valores de píxel en una imagen con un umbral especificado y define los píxeles que se pasan para probar los valores del nuevo color. El método threshold() permite aislar y reemplazar rangos de color en una imagen y realizar otras operaciones lógicas en los píxeles de la imagen.

La lógica de prueba del método threshold() es la siguiente:

1. Si ((pixelValue & mask) operation (threshold & mask)), se debería definir el píxel como color;
2. En caso contrario, si copySource == true, se debe definir el píxel con el correspondiente valor de píxel de sourceBitmap.

El parámetro operation especifica el operador de comparación que se va a utilizar para la prueba de umbral. Por ejemplo, utilizando "==" como parámetro operation, puede aislar el valor de un color específico de una imagen. O bien, si utiliza {operation: "<", mask: 0xFF000000, threshold: 0x7F000000, color: 0x00000000}, puede definir todos los píxeles de destino como totalmente transparentes cuando el alfa del píxel de la imagen de origen sea menor que 0x7F. Puede utilizar esta técnica para transiciones animadas y otros efectos.

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

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

Parámetros

Véase también

import flash.display.BitmapData;

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

1. Se crea una propiedad url, que es la ubicación y el nombre del archivo de imagen.
2. El constructor de la clase crea un objeto Loader, que a su vez crea la instancia de un detector de eventos que se distribuye cuando el método completeHandler() finaliza la manipulación de la imagen.
3. El objeto URLRequest request se transfiere seguidamente a loader.load(), que carga la imagen en la memoria mediante un objeto de visualización.
4. La imagen se incluye entonces en la lista de visualización, que muestra la imagen en la pantalla con las coordenadas x = 0, y = 0.
5. El método completeHandler() realiza lo siguiente:
   • Crea un segundo objeto Loader, junto con Bitmap, que se inicializa con el objeto Loader.
   • Crea un segundo objeto Bitmap, duplicate, que a su vez llama al método duplicateImage(), que crea un duplicado de la imagen original.
   • Crea un objeto BitmapData que se asigna al objeto BitmapData del objeto duplicate.
   • Crea un nuevo objeto Rectangle inicializado con las mismas coordenadas, anchura y altura que la imagen original.
   • Crea un nuevo objeto Point, que se establece de forma predeterminada en x = 0, y = 0.
   • Crea las siguientes variables:
     • operation: aplica el nuevo color cuando el valor del umbral es mayor o igual que el original.
     • threshold: el valor con el que se compara cada píxel (en este ejemplo, gris claro con un alfa de 0xCC).
     • color: el color con el que se definen los píxeles que superan la prueba de umbral, que en este caso es amarillo sólido.
     • mask: el contrario exacto del color (azul transparente).
     • copySource: se establece como false, lo que indica que los valores de píxel no se copian si no se pasa el valor de umbral. Este valor no significa nada porque la imagen está duplicada y sólo se modifican los píxeles que superan la prueba de umbral.
   • Llama al método threshold() mediante las variables anteriores. La ecuación del umbral resultante es la siguiente: if (current pixel Value & 0x000000FF) >= (0xCCCCCCCC & 0x000000FF) then set pixel to 0xFFFFFF00.

Notas:

• Necesitará compilar el archivo SWF con la opción Seguridad de reproducción local establecida como Acceder sólo a archivos locales.
• Este ejemplo requiere la colocación de un archivo llamado Image.gif en el mismo directorio que el archivo SWF.
• Se recomienda utilizar una imagen de una anchura aproximada de 80 píxeles como máximo.

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