The BitmapData class lets you work with the data(pixels) of a Bitmap object. You can use the methods of the BitmapData class to create arbitrarily sized transparent or opaque bitmap images and manipulate them in various ways at runtime. You can also access the BitmapData for a bitmap image that you load with the `openfl.Assets` or `openfl.display.Loader` classes.

This class lets you separate bitmap rendering operations from the internal display updating routines of OpenFL. By manipulating a BitmapData object directly, you can create complex images without incurring the per-frame overhead of constantly redrawing the content from vector data.

The methods of the BitmapData class support effects that are not available through the filters available to non-bitmap display objects.

A BitmapData object contains an array of pixel data. This data can represent either a fully opaque bitmap or a transparent bitmap that contains alpha channel data. Either type of BitmapData object is stored as a buffer of 32-bit integers. Each 32-bit integer determines the properties of a single pixel in the bitmap.

Each 32-bit integer is a combination of four 8-bit channel values(from 0 to 255) that describe the alpha transparency and the red, green, and blue (ARGB) values of the pixel.(For ARGB values, the most significant byte represents the alpha channel value, followed by red, green, and blue.)

The four channels(alpha, red, green, and blue) are represented as numbers when you use them with the `BitmapData.copyChannel()` method or the `DisplacementMapFilter.componentX` and `DisplacementMapFilter.componentY` properties, and these numbers are represented by the following constants in the BitmapDataChannel class:

- `BitmapDataChannel.ALPHA`
- `BitmapDataChannel.RED`
- `BitmapDataChannel.GREEN`
- `BitmapDataChannel.BLUE`

You can attach BitmapData objects to a Bitmap object by using the `bitmapData` property of the Bitmap object.

You can use a BitmapData object to fill a Graphics object by using the `Graphics.beginBitmapFill()` method.

You can also use a BitmapData object to perform batch tile rendering using the `openfl.display.Tilemap` class.

In Flash Player 10, the maximum size for a BitmapData object is 8,191 pixels in width or height, and the total number of pixels cannot exceed 16,777,215 pixels.(So, if a BitmapData object is 8,191 pixels wide, it can only be 2,048 pixels high.) In Flash Player 9 and earlier, the limitation is 2,880 pixels in height and 2,880 in width.

### Hierarchy

- BitmapData

### Implements

- IBitmapDrawable

## Index

### Constructors

- constructor

### Properties

- height
- image
- readable
- rect
- transparent
- width

### Methods

- applyFilter
- clone
- colorTransform
- compare
- copyChannel
- copyPixels
- dispose
- disposeImage
- draw
- drawWithQuality
- encode
- fillRect
- floodFill
- generateFilterRect
- getColorBoundsRect
- getPixel
- getPixel32
- getPixels
- getVector
- histogram
- hitTest
- lock
- merge
- noise
- paletteMap
- perlinNoise
- scroll
- setPixel
- setPixel32
- setPixels
- setVector
- threshold
- unlock
- fromBase64
- fromBytes
- fromCanvas
- fromFile
- fromImage
- loadFromBase64
- loadFromBytes
- loadFromFile

## Constructors

### constructor

- new BitmapData(width: number, height: number, transparent?: boolean, fillColor?: number): BitmapData

- - Defined in lib/openfl/display/BitmapData.d.ts:127

  Creates a BitmapData object with a specified width and height. If you specify a value for the `fillColor` parameter, every pixel in the bitmap is set to that color.

  By default, the bitmap is created as transparent, unless you pass the value `false` for the transparent parameter. After you create an opaque bitmap, you cannot change it to a transparent bitmap. Every pixel in an opaque bitmap uses only 24 bits of color channel information. If you define the bitmap as transparent, every pixel uses 32 bits of color channel information, including an alpha transparency channel.

  #### Parameters

  - ##### width: number

    The width of the bitmap image in pixels.

  - ##### height: number

    The height of the bitmap image in pixels.

  - ##### Optional transparent: boolean

    Specifies whether the bitmap image supports per-pixel transparency. The default value is `true`(transparent). To create a fully transparent bitmap, set the value of the `transparent` parameter to `true` and the value of the `fillColor` parameter to 0x00000000(or to 0). Setting the `transparent` property to `false` can result in minor improvements in rendering performance.

  - ##### Optional fillColor: number

    A 32-bit ARGB color value that you use to fill the bitmap image area. The default value is 0xFFFFFFFF(solid white).

  #### Returns BitmapData

## Properties

### height

height: number

- Defined in lib/openfl/display/BitmapData.d.ts:84

The height of the bitmap image in pixels.

### image

image: Image

- Defined in lib/openfl/display/BitmapData.d.ts:91

The Lime image that holds the pixels for the current image.

In Flash Player, this property is always `null`.

### readable

readable: boolean

- Defined in lib/openfl/display/BitmapData.d.ts:105

Defines whether the bitmap image is readable. Hardware-only bitmap images do not support `getPixels`, `setPixels` and other BitmapData methods, though they can still be used inside a Bitmap object or other display objects that do not need to modify the pixels.

As an exception to the rule, `bitmapData.draw` is supported for non-readable bitmap images.

Since non-readable bitmap images do not have a software image buffer, they will need to be recreated if the current hardware rendering context is lost.

### rect

rect: Rectangle

- Defined in lib/openfl/display/BitmapData.d.ts:112

The rectangle that defines the size and location of the bitmap image. The top and left of the rectangle are 0; the width and height are equal to the width and height in pixels of the BitmapData object.

### transparent

transparent: boolean

- Defined in lib/openfl/display/BitmapData.d.ts:122

Defines whether the bitmap image supports per-pixel transparency. You can set this value only when you construct a BitmapData object by passing in `true` for the `transparent` parameter of the constructor. Then, after you create a BitmapData object, you can check whether it supports per-pixel transparency by determining if the value of the `transparent` property is `true`.

### width

width: number

- Defined in lib/openfl/display/BitmapData.d.ts:127

The width of the bitmap image in pixels.

## Methods

### applyFilter

- applyFilter(sourceBitmapData: BitmapData, sourceRect: Rectangle, destPoint: Point, filter: BitmapFilter): void

- - Defined in lib/openfl/display/BitmapData.d.ts:172

  Takes a source image and a filter object and generates the filtered image.

  This method relies on the behavior of built-in filter objects, which determine the destination rectangle that is affected by an input source rectangle.

  After a filter is applied, the resulting image can be larger than the input image. For example, if you use a BlurFilter class to blur a source rectangle of(50,50,100,100) and a destination point of(10,10), the area that changes in the destination image is larger than(10,10,60,60) because of the blurring. This happens internally during the applyFilter() call.

  If the `sourceRect` parameter of the sourceBitmapData parameter is an interior region, such as(50,50,100,100) in a 200 x 200 image, the filter uses the source pixels outside the `sourceRect` parameter to generate the destination rectangle.

  If the BitmapData object and the object specified as the `sourceBitmapData` parameter are the same object, the application uses a temporary copy of the object to perform the filter. For best performance, avoid this situation.

  #### Parameters

  - ##### sourceBitmapData: BitmapData

    The input bitmap image to use. The source image can be a different BitmapData object or it can refer to the current BitmapData instance.

  - ##### sourceRect: Rectangle

    A rectangle that defines the area of the source image to use as input.

  - ##### destPoint: Point

    The point within the destination image(the current BitmapData instance) that corresponds to the upper-left corner of the source rectangle.

  - ##### filter: BitmapFilter

    The filter object that you use to perform the filtering operation.

  #### Returns void

### clone

- clone(): BitmapData

- - Defined in lib/openfl/display/BitmapData.d.ts:179

  Returns a new BitmapData object that is a clone of the original instance with an exact copy of the contained bitmap.

  #### Returns BitmapData

  A new BitmapData object that is identical to the original.

### colorTransform

- colorTransform(rect: Rectangle, colorTransform: ColorTransform): void

- - Defined in lib/openfl/display/BitmapData.d.ts:189

  Adjusts the color values in a specified area of a bitmap image by using a `ColorTransform` object. If the rectangle matches the boundaries of the bitmap image, this method transforms the color values of the entire image.

  #### Parameters

  - ##### rect: Rectangle

    A Rectangle object that defines the area of the image in which the ColorTransform object is applied.

  - ##### colorTransform: ColorTransform

    A ColorTransform object that describes the color transformation values to apply.

  #### Returns void

### compare

- compare(otherBitmapData: BitmapData): BitmapData | number

- - Defined in lib/openfl/display/BitmapData.d.ts:202

  Compares two BitmapData objects. If the two BitmapData objects have the same dimensions (width and height), the method returns a new BitmapData object, in which each pixel is the "difference" between the pixels in the two source objects:

  - If two pixels are equal, the difference pixel is 0x00000000.
  - If two pixels have different RGB values (ignoring the alpha value), the difference pixel is 0xFFRRGGBB where RR/GG/BB are the individual difference values between red, green, and blue channels. Alpha channel differences are ignored in this case.
  - If only the alpha channel value is different, the pixel value is 0xZZFFFFFF, where ZZ is the difference in the alpha value.

  #### Parameters

  - ##### otherBitmapData: BitmapData

    The BitmapData object to compare with the source BitmapData object.

  #### Returns BitmapData | number

  If the two BitmapData objects have the same dimensions (width and height), the method returns a new BitmapData object that has the difference between the two objects (see the main discussion).If the BitmapData objects are equivalent, the method returns the number 0. If no argument is passed or if the argument is not a BitmapData object, the method returns -1. If either BitmapData object has been disposed of, the method returns -2. If the widths of the BitmapData objects are not equal, the method returns the number -3. If the heights of the BitmapData objects are not equal, the method returns the number -4.

### copyChannel

- copyChannel(sourceBitmapData: BitmapData, sourceRect: Rectangle, destPoint: Point, sourceChannel: BitmapDataChannel, destChannel: BitmapDataChannel): void

- - Defined in lib/openfl/display/BitmapData.d.ts:248

  Transfers data from one channel of another BitmapData object or the current BitmapData object into a channel of the current BitmapData object. All of the data in the other channels in the destination BitmapData object are preserved.

  The source channel value and destination channel value can be one of following values:

  - `BitmapDataChannel.RED`
  - `BitmapDataChannel.GREEN`
  - `BitmapDataChannel.BLUE`
  - `BitmapDataChannel.ALPHA`
  throws

    TypeError The sourceBitmapData, sourceRect or destPoint are null.

  #### Parameters

  - ##### sourceBitmapData: BitmapData

    The input bitmap image to use. The source image can be a different BitmapData object or it can refer to the current BitmapData object.

  - ##### sourceRect: Rectangle

    The source Rectangle object. To copy only channel data from a smaller area within the bitmap, specify a source rectangle that is smaller than the overall size of the BitmapData object.

  - ##### destPoint: Point

    The destination Point object that represents the upper-left corner of the rectangular area where the new channel data is placed. To copy only channel data from one area to a different area in the destination image, specify a point other than (0,0).

  - ##### sourceChannel: BitmapDataChannel

    The source channel. Use a value from the BitmapDataChannel class (`BitmapDataChannel.RED`, `BitmapDataChannel.BLUE`, `BitmapDataChannel.GREEN`, `BitmapDataChannel.ALPHA`).

  - ##### destChannel: BitmapDataChannel

    The destination channel. Use a value from the BitmapDataChannel class (`BitmapDataChannel.RED`, `BitmapDataChannel.BLUE`, `BitmapDataChannel.GREEN`, `BitmapDataChannel.ALPHA`).

  #### Returns void

### copyPixels

- copyPixels(sourceBitmapData: BitmapData, sourceRect: Rectangle, destPoint: Point, alphaBitmapData?: BitmapData, alphaPoint?: Point, mergeAlpha?: boolean): void

- - Defined in lib/openfl/display/BitmapData.d.ts:290

  Provides a fast routine to perform pixel manipulation between images with no stretching, rotation, or color effects. This method copies a rectangular area of a source image to a rectangular area of the same size at the destination point of the destination BitmapData object.

  If you include the `alphaBitmap` and `alphaPoint` parameters, you can use a secondary image as an alpha source for the source image. If the source image has alpha data, both sets of alpha data are used to composite pixels from the source image to the destination image. The `alphaPoint` parameter is the point in the alpha image that corresponds to the upper-left corner of the source rectangle. Any pixels outside the intersection of the source image and alpha image are not copied to the destination image.

  The `mergeAlpha` property controls whether or not the alpha channel is used when a transparent image is copied onto another transparent image. To copy pixels with the alpha channel data, set the `mergeAlpha` property to `true`. By default, the `mergeAlpha` property is `false`.

  throws

    TypeError The sourceBitmapData, sourceRect, destPoint are null.

  #### Parameters

  - ##### sourceBitmapData: BitmapData

    The input bitmap image from which to copy pixels. The source image can be a different BitmapData instance, or it can refer to the current BitmapData instance.

  - ##### sourceRect: Rectangle

    A rectangle that defines the area of the source image to use as input.

  - ##### destPoint: Point

    The destination point that represents the upper-left corner of the rectangular area where the new pixels are placed.

  - ##### Optional alphaBitmapData: BitmapData

    A secondary, alpha BitmapData object source.

  - ##### Optional alphaPoint: Point

    The point in the alpha BitmapData object source that corresponds to the upper-left corner of the `sourceRect` parameter.

  - ##### Optional mergeAlpha: boolean

    To use the alpha channel, set the value to `true`. To copy pixels with no alpha channel, set the value to `false`.

  #### Returns void

### dispose

- dispose(): void

- - Defined in lib/openfl/display/BitmapData.d.ts:317

  Frees memory that is used to store the BitmapData object.

  When the `dispose()` method is called on an image, the width and height of the image are set to 0. All subsequent calls to methods or properties of this BitmapData instance fail, and an exception is thrown.

  `BitmapData.dispose()` releases the memory occupied by the actual bitmap data, immediately(a bitmap can consume up to 64 MB of memory). After using `BitmapData.dispose()`, the BitmapData object is no longer usable and an exception may be thrown if you call functions on the BitmapData object. However, `BitmapData.dispose()` does not garbage collect the BitmapData object(approximately 128 bytes); the memory occupied by the actual BitmapData object is released at the time the BitmapData object is collected by the garbage collector.

  #### Returns void

### disposeImage

- disposeImage(): void

- - Defined in lib/openfl/display/BitmapData.d.ts:332

  Frees the backing Lime image buffer, if possible.

  When using a software renderer, such as Flash Player or desktop targets without OpenGL, the software buffer will be retained so that the BitmapData will work properly. When using a hardware renderer, the Lime image buffer will be available to garbage collection after a hardware texture has been created internally.

  `BitmapData.disposeImage()` will immediately change the value of the `readable` property to `false`.

  #### Returns void

### draw

- draw(source: IBitmapDrawable, matrix?: Matrix, colorTransform?: ColorTransform, blendMode?: BlendMode, clipRect?: Rectangle, smoothing?: boolean): void

- - Defined in lib/openfl/display/BitmapData.d.ts:407

  Draws the `source` display object onto the bitmap image, using the OpenFL software renderer. You can specify `matrix`, `colorTransform`, `blendMode`, and a destination `clipRect` parameter to control how the rendering performs. Optionally, you can specify whether the bitmap should be smoothed when scaled(this works only if the source object is a BitmapData object).

  The source display object does not use any of its applied transformations for this call. It is treated as it exists in the library or file, with no matrix transform, no color transform, and no blend mode. To draw a display object(such as a movie clip) by using its own transform properties, you can copy its `transform` property object to the `transform` property of the Bitmap object that uses the BitmapData object.

  throws

    ArgumentError The `source` parameter is not a BitmapData or DisplayObject object.

  throws

    ArgumentError The source is null or not a valid IBitmapDrawable object.

  throws

    SecurityError The `source` object and(in the case of a Sprite or MovieClip object) all of its child objects do not come from the same domain as the caller, or are not in a content that is accessible to the caller by having called the `Security.allowDomain()` method. This restriction does not apply to AIR content in the application security sandbox.

  #### Parameters

  - ##### source: IBitmapDrawable

    The display object or BitmapData object to draw to the BitmapData object.(The DisplayObject and BitmapData classes implement the IBitmapDrawable interface.)

  - ##### Optional matrix: Matrix

    A Matrix object used to scale, rotate, or translate the coordinates of the bitmap. If you do not want to apply a matrix transformation to the image, set this parameter to an identity matrix, created with the default `new Matrix()` constructor, or pass a `null` value.

  - ##### Optional colorTransform: ColorTransform

    A ColorTransform object that you use to adjust the color values of the bitmap. If no object is supplied, the bitmap image's colors are not transformed. If you must pass this parameter but you do not want to transform the image, set this parameter to a ColorTransform object created with the default `new ColorTransform()` constructor.

  - ##### Optional blendMode: BlendMode

    A string value, from the openfl.display.BlendMode class, specifying the blend mode to be applied to the resulting bitmap.

  - ##### Optional clipRect: Rectangle

    A Rectangle object that defines the area of the source object to draw. If you do not supply this value, no clipping occurs and the entire source object is drawn.

  - ##### Optional smoothing: boolean

    A Boolean value that determines whether a BitmapData object is smoothed when scaled or rotated, due to a scaling or rotation in the `matrix` parameter. The `smoothing` parameter only applies if the `source` parameter is a BitmapData object. With `smoothing` set to `false`, the rotated or scaled BitmapData image can appear pixelated or jagged. For example, the following two images use the same BitmapData object for the `source` parameter, but the `smoothing` parameter is set to `true` on the left and `false` on the right:

                          Drawing a bitmap with `smoothing` set
                          to `true` takes longer than doing so with
                          `smoothing` set to
                          `false`.

  #### Returns void

### drawWithQuality

- drawWithQuality(source: IBitmapDrawable, matrix?: Matrix, colorTransform?: ColorTransform, blendMode?: BlendMode, clipRect?: Rectangle, smoothing?: boolean, quality?: StageQuality): void

- - Defined in lib/openfl/display/BitmapData.d.ts:410

  #### Parameters

  - ##### source: IBitmapDrawable

  - ##### Optional matrix: Matrix

  - ##### Optional colorTransform: ColorTransform

  - ##### Optional blendMode: BlendMode

  - ##### Optional clipRect: Rectangle

  - ##### Optional smoothing: boolean

  - ##### Optional quality: StageQuality

  #### Returns void

### encode

- encode(rect: Rectangle, compressor: any, byteArray?: ByteArray): ByteArray

- - Defined in lib/openfl/display/BitmapData.d.ts:413

  #### Parameters

  - ##### rect: Rectangle

  - ##### compressor: any

  - ##### Optional byteArray: ByteArray

  #### Returns ByteArray

### fillRect

- fillRect(rect: Rectangle, color: number): void

- - Defined in lib/openfl/display/BitmapData.d.ts:425

  Fills a rectangular area of pixels with a specified ARGB color.

  throws

    TypeError The rect is null.

  #### Parameters

  - ##### rect: Rectangle

    The rectangular area to fill.

  - ##### color: number

    The ARGB color value that fills the area. ARGB colors are often specified in hexadecimal format; for example, 0xFF336699.

  #### Returns void

### floodFill

- floodFill(x: number, y: number, color: number): void

- - Defined in lib/openfl/display/BitmapData.d.ts:439

  Performs a flood fill operation on an image starting at an(_x_, _y_) coordinate and filling with a certain color. The `floodFill()` method is similar to the paint bucket tool in various paint programs. The color is an ARGB color that contains alpha information and color information.

  #### Parameters

  - ##### x: number

    The _x_ coordinate of the image.

  - ##### y: number

    The _y_ coordinate of the image.

  - ##### color: number

    The ARGB color to use as a fill.

  #### Returns void

### generateFilterRect

- generateFilterRect(sourceRect: Rectangle, filter: BitmapFilter): Rectangle

- - Defined in lib/openfl/display/BitmapData.d.ts:480

  Determines the destination rectangle that the `applyFilter()` method call affects, given a BitmapData object, a source rectangle, and a filter object.

  For example, a blur filter normally affects an area larger than the size of the original image. A 100 x 200 pixel image that is being filtered by a default BlurFilter instance, where `blurX = blurY = 4` generates a destination rectangle of `(-2,-2,104,204)`. The `generateFilterRect()` method lets you find out the size of this destination rectangle in advance so that you can size the destination image appropriately before you perform a filter operation.

  Some filters clip their destination rectangle based on the source image size. For example, an inner `DropShadow` does not generate a larger result than its source image. In this API, the BitmapData object is used as the source bounds and not the source `rect` parameter.

  throws

    TypeError The sourceRect or filter are null.

  #### Parameters

  - ##### sourceRect: Rectangle

    A rectangle defining the area of the source image to use as input.

  - ##### filter: BitmapFilter

    A filter object that you use to calculate the destination rectangle.

  #### Returns Rectangle

  A destination rectangle computed by using an image, the `sourceRect` parameter, and a filter.

### getColorBoundsRect

- getColorBoundsRect(mask: number, color: number, findColor?: boolean): Rectangle

- - Defined in lib/openfl/display/BitmapData.d.ts:517

  Determines a rectangular region that either fully encloses all pixels of a specified color within the bitmap image(if the `findColor` parameter is set to `true`) or fully encloses all pixels that do not include the specified color(if the `findColor` parameter is set to `false`).

  For example, if you have a source image and you want to determine the rectangle of the image that contains a nonzero alpha channel, pass `{mask: 0xFF000000, color: 0x00000000}` as parameters. If the `findColor` parameter is set to `true`, the entire image is searched for the bounds of pixels for which `(value & mask) == color`(where `value` is the color value of the pixel). If the `findColor` parameter is set to `false`, the entire image is searched for the bounds of pixels for which `(value & mask) != color`(where `value` is the color value of the pixel). To determine white space around an image, pass `{mask: 0xFFFFFFFF, color: 0xFFFFFFFF}` to find the bounds of nonwhite pixels.

  #### Parameters

  - ##### mask: number

    A hexadecimal value, specifying the bits of the ARGB color to consider. The color value is combined with this hexadecimal value, by using the `&`(bitwise AND) operator.

  - ##### color: number

    A hexadecimal value, specifying the ARGB color to match (if `findColor` is set to `true`) or not to match(if `findColor` is set to `false`).

  - ##### Optional findColor: boolean

    If the value is set to `true`, returns the bounds of a color value in an image. If the value is set to `false`, returns the bounds of where this color doesn't exist in an image.

  #### Returns Rectangle

  The region of the image that is the specified color.

### getPixel

- getPixel(x: number, y: number): number

- - Defined in lib/openfl/display/BitmapData.d.ts:543

  Returns an integer that represents an RGB pixel value from a BitmapData object at a specific point(_x_, _y_). The `getPixel()` method returns an unmultiplied pixel value. No alpha information is returned.

  All pixels in a BitmapData object are stored as premultiplied color values. A premultiplied image pixel has the red, green, and blue color channel values already multiplied by the alpha data. For example, if the alpha value is 0, the values for the RGB channels are also 0, independent of their unmultiplied values. This loss of data can cause some problems when you perform operations. All BitmapData methods take and return unmultiplied values. The internal pixel representation is converted from premultiplied to unmultiplied before it is returned as a value. During a set operation, the pixel value is premultiplied before the raw image pixel is set.

  #### Parameters

  - ##### x: number

    The _x_ position of the pixel.

  - ##### y: number

    The _y_ position of the pixel.

  #### Returns number

  A number that represents an RGB pixel value. If the(_x_, _y_) coordinates are outside the bounds of the image, the method returns 0.

### getPixel32

- getPixel32(x: number, y: number): number

- - Defined in lib/openfl/display/BitmapData.d.ts:568

  Returns an ARGB color value that contains alpha channel data and RGB data. This method is similar to the `getPixel()` method, which returns an RGB color without alpha channel data.

  All pixels in a BitmapData object are stored as premultiplied color values. A premultiplied image pixel has the red, green, and blue color channel values already multiplied by the alpha data. For example, if the alpha value is 0, the values for the RGB channels are also 0, independent of their unmultiplied values. This loss of data can cause some problems when you perform operations. All BitmapData methods take and return unmultiplied values. The internal pixel representation is converted from premultiplied to unmultiplied before it is returned as a value. During a set operation, the pixel value is premultiplied before the raw image pixel is set.

  #### Parameters

  - ##### x: number

    The _x_ position of the pixel.

  - ##### y: number

    The _y_ position of the pixel.

  #### Returns number

  A number representing an ARGB pixel value. If the(_x_, _y_) coordinates are outside the bounds of the image, 0 is returned.

### getPixels

- getPixels(rect: Rectangle): ByteArray

- - Defined in lib/openfl/display/BitmapData.d.ts:580

  Generates a byte array from a rectangular region of pixel data. Writes an unsigned integer(a 32-bit unmultiplied pixel value) for each pixel into the byte array.

  throws

    TypeError The rect is null.

  #### Parameters

  - ##### rect: Rectangle

    A rectangular area in the current BitmapData object.

  #### Returns ByteArray

  A ByteArray representing the pixels in the given Rectangle.

### getVector

- getVector(rect: Rectangle): Vector<number>

- - Defined in lib/openfl/display/BitmapData.d.ts:592

  Generates a vector array from a rectangular region of pixel data. Returns a Vector object of unsigned integers(a 32-bit unmultiplied pixel value) for the specified rectangle.

  throws

    TypeError The rect is null.

  #### Parameters

  - ##### rect: Rectangle

    A rectangular area in the current BitmapData object.

  #### Returns Vector<number>

  A Vector representing the given Rectangle.

### histogram

- histogram(hRect?: Rectangle): Vector<Vector<number>>

- - Defined in lib/openfl/display/BitmapData.d.ts:595

  #### Parameters

  - ##### Optional hRect: Rectangle

  #### Returns Vector<Vector<number>>

### hitTest

- hitTest(firstPoint: Point, firstAlphaThreshold: number, secondObject: Rectangle | Point | Bitmap | BitmapData, secondBitmapDataPoint?: Point, secondAlphaThreshold?: number): boolean

- - Defined in lib/openfl/display/BitmapData.d.ts:598

  #### Parameters

  - ##### firstPoint: Point

  - ##### firstAlphaThreshold: number

  - ##### secondObject: Rectangle | Point | Bitmap | BitmapData

  - ##### Optional secondBitmapDataPoint: Point

  - ##### Optional secondAlphaThreshold: number

  #### Returns boolean

### lock

- lock(): void

- - Defined in lib/openfl/display/BitmapData.d.ts:613

  Locks an image so that any objects that reference the BitmapData object, such as Bitmap objects, are not updated when this BitmapData object changes. To improve performance, use this method along with the `unlock()` method before and after numerous calls to the `setPixel()` or `setPixel32()` method.

  #### Returns void

### merge

- merge(sourceBitmapData: BitmapData, sourceRect: Rectangle, destPoint: Point, redMultiplier: number, greenMultiplier: number, blueMultiplier: number, alphaMultiplier: number): void

- - Defined in lib/openfl/display/BitmapData.d.ts:616

  #### Parameters

  - ##### sourceBitmapData: BitmapData

  - ##### sourceRect: Rectangle

  - ##### destPoint: Point

  - ##### redMultiplier: number

  - ##### greenMultiplier: number

  - ##### blueMultiplier: number

  - ##### alphaMultiplier: number

  #### Returns void

### noise

- noise(randomSeed: number, low?: number, high?: number, channelOptions?: number, grayScale?: boolean): void

- - Defined in lib/openfl/display/BitmapData.d.ts:647

  Fills an image with pixels representing random noise.

  #### Parameters

  - ##### randomSeed: number

    The random seed number to use. If you keep all other parameters the same, you can generate different pseudo-random results by varying the random seed value. The noise is a mapping function, not a true random-number generation function, so it creates the same results each time from the same random seed.

  - ##### Optional low: number

    The lowest value to generate for each channel(0 to 255).

  - ##### Optional high: number

    The highest value to generate for each channel(0 to 255).

  - ##### Optional channelOptions: number

    A number that can be a combination of any of the four color channel values (`BitmapDataChannel.RED`, `BitmapDataChannel.BLUE`, `BitmapDataChannel.GREEN`, and `BitmapDataChannel.ALPHA`). You can use the logical OR operator(`|`) to combine channel values.

  - ##### Optional grayScale: boolean

    A Boolean value. If the value is `true`, a grayscale image is created by setting all of the color channels to the same value. The alpha channel selection is not affected by setting this parameter to `true`.

  #### Returns void

### paletteMap

- paletteMap(sourceBitmapData: BitmapData, sourceRect: Rectangle, destPoint: Point, redArray?: Array<number>, greenArray?: Array<number>, blueArray?: Array<number>, alphaArray?: Array<number>): void

- - Defined in lib/openfl/display/BitmapData.d.ts:650

  #### Parameters

  - ##### sourceBitmapData: BitmapData

  - ##### sourceRect: Rectangle

  - ##### destPoint: Point

  - ##### Optional redArray: Array<number>

  - ##### Optional greenArray: Array<number>

  - ##### Optional blueArray: Array<number>

  - ##### Optional alphaArray: Array<number>

  #### Returns void

### perlinNoise

- perlinNoise(baseX: number, baseY: number, numOctaves: number, randomSeed: number, stitch: boolean, fractalNoise: boolean, channelOptions?: number, grayScale?: boolean, offsets?: Array<Point>): void

- - Defined in lib/openfl/display/BitmapData.d.ts:719

  Generates a Perlin noise image.

  The Perlin noise generation algorithm interpolates and combines individual random noise functions(called octaves) into a single function that generates more natural-seeming random noise. Like musical octaves, each octave is twice the frequency of the one before it. Perlin noise has been described as a "fractal sum of noise" because it combines multiple sets of noise data with different levels of detail.

  You can use Perlin noise functions to simulate natural phenomena and landscapes, such as wood grain, clouds, and mountain ranges. In most cases, the output of a Perlin noise is not displayed directly but is used to enhance other images and give them pseudo-random variations.

  Simple digital random noise functions often produce images with harsh, contrasting points. This kind of harsh contrast is not often found in nature. The Perlin noise algorithm blends multiple noise functions that operate at different levels of detail. This algorithm results in smaller variations among neighboring pixel values.

  #### Parameters

  - ##### baseX: number

    Frequency to use in the _x_ direction. For example, to generate a noise that is sized for a 64 x 128 image, pass 64 for the `baseX` value.

  - ##### baseY: number

    Frequency to use in the _y_ direction. For example, to generate a noise that is sized for a 64 x 128 image, pass 128 for the `baseY` value.

  - ##### numOctaves: number

    Number of octaves or individual noise functions to combine to create this noise. Larger numbers of octaves create images with greater detail. Larger numbers of octaves also require more processing time.

  - ##### randomSeed: number

    The random seed number to use. If you keep all other parameters the same, you can generate different pseudo-random results by varying the random seed value. The Perlin noise is a mapping function, not a true random-number generation function, so it creates the same results each time from the same random seed.

  - ##### stitch: boolean

    A Boolean value. If the value is `true`, the method attempts to smooth the transition edges of the image to create seamless textures for tiling as a bitmap fill.

  - ##### fractalNoise: boolean

    A Boolean value. If the value is `true`, the method generates fractal noise; otherwise, it generates turbulence. An image with turbulence has visible discontinuities in the gradient that can make it better approximate sharper visual effects like flames and ocean waves.

  - ##### Optional channelOptions: number

    A number that can be a combination of any of the four color channel values (`BitmapDataChannel.RED`, `BitmapDataChannel.BLUE`, `BitmapDataChannel.GREEN`, and `BitmapDataChannel.ALPHA`). You can use the logical OR operator(`|`) to combine channel values.

  - ##### Optional grayScale: boolean

    A Boolean value. If the value is `true`, a grayscale image is created by setting each of the red, green, and blue color channels to identical values. The alpha channel value is not affected if this value is set to `true`.

  - ##### Optional offsets: Array<Point>

  #### Returns void

### scroll

- scroll(x: number, y: number): void

- - Defined in lib/openfl/display/BitmapData.d.ts:734

  Scrolls an image by a certain(_x_, _y_) pixel amount. Edge regions outside the scrolling area are left unchanged.

  #### Parameters

  - ##### x: number

    The amount by which to scroll horizontally.

  - ##### y: number

    The amount by which to scroll vertically.

  #### Returns void

### setPixel

- setPixel(x: number, y: number, color: number): void

- - Defined in lib/openfl/display/BitmapData.d.ts:754

  Sets a single pixel of a BitmapData object. The current alpha channel value of the image pixel is preserved during this operation. The value of the RGB color parameter is treated as an unmultiplied color value.

  Note: To increase performance, when you use the `setPixel()` or `setPixel32()` method repeatedly, call the `lock()` method before you call the `setPixel()` or `setPixel32()` method, and then call the `unlock()` method when you have made all pixel changes. This process prevents objects that reference this BitmapData instance from updating until you finish making the pixel changes.

  #### Parameters

  - ##### x: number

    The _x_ position of the pixel whose value changes.

  - ##### y: number

    The _y_ position of the pixel whose value changes.

  - ##### color: number

    The resulting RGB color for the pixel.

  #### Returns void

### setPixel32

- setPixel32(x: number, y: number, color: number): void

- - Defined in lib/openfl/display/BitmapData.d.ts:788

  Sets the color and alpha transparency values of a single pixel of a BitmapData object. This method is similar to the `setPixel()` method; the main difference is that the `setPixel32()` method takes an ARGB color value that contains alpha channel information.

  All pixels in a BitmapData object are stored as premultiplied color values. A premultiplied image pixel has the red, green, and blue color channel values already multiplied by the alpha data. For example, if the alpha value is 0, the values for the RGB channels are also 0, independent of their unmultiplied values. This loss of data can cause some problems when you perform operations. All BitmapData methods take and return unmultiplied values. The internal pixel representation is converted from premultiplied to unmultiplied before it is returned as a value. During a set operation, the pixel value is premultiplied before the raw image pixel is set.

  Note: To increase performance, when you use the `setPixel()` or `setPixel32()` method repeatedly, call the `lock()` method before you call the `setPixel()` or `setPixel32()` method, and then call the `unlock()` method when you have made all pixel changes. This process prevents objects that reference this BitmapData instance from updating until you finish making the pixel changes.

  #### Parameters

  - ##### x: number

    The _x_ position of the pixel whose value changes.

  - ##### y: number

    The _y_ position of the pixel whose value changes.

  - ##### color: number

    The resulting ARGB color for the pixel. If the bitmap is opaque(not transparent), the alpha transparency portion of this color value is ignored.

  #### Returns void

### setPixels

- setPixels(rect: Rectangle, byteArray: ByteArray): void

- - Defined in lib/openfl/display/BitmapData.d.ts:810

  Converts a byte array into a rectangular region of pixel data. For each pixel, the `ByteArray.readUnsignedInt()` method is called and the return value is written into the pixel. If the byte array ends before the full rectangle is written, the returns. The data in the byte array is expected to be 32-bit ARGB pixel values. No seeking is performed on the byte array before or after the pixels are read.

  throws

    EOFError The `inputByteArray` object does not include enough data to fill the area of the `rect` rectangle. The method fills as many pixels as possible before throwing the exception.

  throws

    TypeError The rect or inputByteArray are null.

  #### Parameters

  - ##### rect: Rectangle

    Specifies the rectangular region of the BitmapData object.

  - ##### byteArray: ByteArray

  #### Returns void

### setVector

- setVector(rect: Rectangle, inputVector: Vector<number>): void

- - Defined in lib/openfl/display/BitmapData.d.ts:822

  Converts a Vector into a rectangular region of pixel data. For each pixel, a Vector element is read and written into the BitmapData pixel. The data in the Vector is expected to be 32-bit ARGB pixel values.

  throws

    RangeError The vector array is not large enough to read all the pixel data.

  #### Parameters

  - ##### rect: Rectangle

    Specifies the rectangular region of the BitmapData object.

  - ##### inputVector: Vector<number>

  #### Returns void

### threshold

- threshold(sourceBitmapData: BitmapData, sourceRect: Rectangle, destPoint: Point, operation: string, threshold: number, color?: number, mask?: number, copySource?: boolean): number

- - Defined in lib/openfl/display/BitmapData.d.ts:873

  Tests pixel values in an image against a specified threshold and sets pixels that pass the test to new color values. Using the `threshold()` method, you can isolate and replace color ranges in an image and perform other logical operations on image pixels.

  The `threshold()` method's test logic is as follows:

  1. If `((pixelValue & mask) operation(threshold & mask))`, then set the pixel to `color`;
  2. Otherwise, if `copySource == true`, then set the pixel to corresponding pixel value from `sourceBitmap`.

  The `operation` parameter specifies the comparison operator to use for the threshold test. For example, by using "==" as the `operation` parameter, you can isolate a specific color value in an image. Or by using `{operation: "<", mask: 0xFF000000, threshold: 0x7F000000, color: 0x00000000}`, you can set all destination pixels to be fully transparent when the source image pixel's alpha is less than 0x7F. You can use this technique for animated transitions and other effects.

  throws

    ArgumentError The operation string is not a valid operation

  throws

    TypeError The sourceBitmapData, sourceRect destPoint or operation are null.

  #### Parameters

  - ##### sourceBitmapData: BitmapData

    The input bitmap image to use. The source image can be a different BitmapData object or it can refer to the current BitmapData instance.

  - ##### sourceRect: Rectangle

    A rectangle that defines the area of the source image to use as input.

  - ##### destPoint: Point

    The point within the destination image(the current BitmapData instance) that corresponds to the upper-left corner of the source rectangle.

  - ##### operation: string

    One of the following comparison operators, passed as a String: "<", "<=", ">", ">=", "==", "!="

  - ##### threshold: number

    The value that each pixel is tested against to see if it meets or exceeds the threshhold.

  - ##### Optional color: number

    The color value that a pixel is set to if the threshold test succeeds. The default value is 0x00000000.

  - ##### Optional mask: number

    The mask to use to isolate a color component.

  - ##### Optional copySource: boolean

    If the value is `true`, pixel values from the source image are copied to the destination when the threshold test fails. If the value is `false`, the source image is not copied when the threshold test fails.

  #### Returns number

  The number of pixels that were changed.

### unlock

- unlock(changeRect?: Rectangle): void

- - Defined in lib/openfl/display/BitmapData.d.ts:888

  Unlocks an image so that any objects that reference the BitmapData object, such as Bitmap objects, are updated when this BitmapData object changes. To improve performance, use this method along with the `lock()` method before and after numerous calls to the `setPixel()` or `setPixel32()` method.

  #### Parameters

  - ##### Optional changeRect: Rectangle

    The area of the BitmapData object that has changed. If you do not specify a value for this parameter, the entire area of the BitmapData object is considered changed.

  #### Returns void

### Static fromBase64

- fromBase64(base64: string, type: string): BitmapData

- - Defined in lib/openfl/display/BitmapData.d.ts:442

  #### Parameters

  - ##### base64: string

  - ##### type: string

  #### Returns BitmapData

### Static fromBytes

- fromBytes(bytes: ByteArray, rawAlpha?: ByteArray): BitmapData

- - Defined in lib/openfl/display/BitmapData.d.ts:443

  #### Parameters

  - ##### bytes: ByteArray

  - ##### Optional rawAlpha: ByteArray

  #### Returns BitmapData

### Static fromCanvas

- fromCanvas(canvas: HTMLCanvasElement, transparent?: boolean): BitmapData

- - Defined in lib/openfl/display/BitmapData.d.ts:446

  #### Parameters

  - ##### canvas: HTMLCanvasElement

  - ##### Optional transparent: boolean

  #### Returns BitmapData

### Static fromFile

- fromFile(path: string): BitmapData

- - Defined in lib/openfl/display/BitmapData.d.ts:449

  #### Parameters

  - ##### path: string

  #### Returns BitmapData

### Static fromImage

- fromImage(image: Image, transparent?: boolean): BitmapData

- - Defined in lib/openfl/display/BitmapData.d.ts:450

  #### Parameters

  - ##### image: Image

  - ##### Optional transparent: boolean

  #### Returns BitmapData

### Static loadFromBase64

- loadFromBase64(base64: string, type: string): Future<BitmapData>

- - Defined in lib/openfl/display/BitmapData.d.ts:600

  #### Parameters

  - ##### base64: string

  - ##### type: string

  #### Returns Future<BitmapData>

### Static loadFromBytes

- loadFromBytes(bytes: ByteArray, rawAlpha?: ByteArray): Future<BitmapData>

- - Defined in lib/openfl/display/BitmapData.d.ts:601

  #### Parameters

  - ##### bytes: ByteArray

  - ##### Optional rawAlpha: ByteArray

  #### Returns Future<BitmapData>

### Static loadFromFile

- loadFromFile(path: string): Future<BitmapData>

- - Defined in lib/openfl/display/BitmapData.d.ts:602

  #### Parameters

  - ##### path: string

  #### Returns Future<BitmapData>

Generated using TypeDoc