AS3之BitmapData学习整理

http://www.cnblogs.com/psj2002/archive/2011/02/17/1957277.html

最近在看BitmapData这个类，对这个东西也不是很熟悉，所以在网上看了一些资料，现在把他们都整理了一下，我想通过以下这些会让大家会对BitmapData这东西有个深刻的了解，对大家的理解有所帮助。

利用BitmapData的优势： 

我们知道传统的矢量渲染模式下，任何元件的位移和变型以及任何改变显示的变化都会使得Flashplayer对其进行绘制，并渲染到显示器。（Fl9以后有所优化，但改变不了根本）而BitmapData可以先进行像素数据的操作，操作之后在进行渲染。并且跳过FP的绘制，直接将像素数据交给显示渲染。 

开发游戏的角色使用mc（影片）还是BitmapData？

很多的游戏，都是使用mc的，mc的优点是很直观，所见即所得，占用内存很少，缺点是效率不高（当效率是瓶颈的时候是缺点，其他时候可能也不算）。

BitmapData的优点是效率高，管理有些麻烦，占用内存高。

小问题，为什么mc效率没Bitmap高呢？
mc中的位图在编译后，是以shape形式存在，也就是说，使用的是矢量渲染器渲染，进行位图填充，效率很低。
mc中的矢量图片，也是用矢量渲染器渲染，复杂的图像，非常耗cpu。
BitmapData的是将数据存在内存中，真正的位图渲染，效率非常高。

BitmapData的理解

 

BitmapData主要提供的是对图像的“像素级”的操作，如果你想切实感受一下，有个挺好的办法，打开Flash，然后CTRL+R导入一张图片，然后再按CTRL+B打散，这时得到的图片状态就有点BitmapData的味道了···而其他用FLASH矢量工具画出来的都可以理解为BitmapData的一种。

下面再深一步说，BitmapData的名字可以拆开来看，就是Bitmap+Data，翻译成中文就是：位图数据，所以它可以看作数据储存的一种，而不是真正的显示对象，要想看到BitmapData，我们需要把Bitmapdata赋到一个Bitmap对象中，然后addChild(Bitmap),那么就能看到具体的画面了

那么BitmapData的像素级操作作用在哪呢?比较大家喜欢津津乐道的就是粒子效果,作为一个需要大量计算的应用来说,1像素长宽的粒子无疑是能存在的最小的粒子；另外一个是作为数据传输,大家如果想实现上传图片或者下载图片的效果,基本的理念就是将Bitmapdata使用JPEGEncoder编码成二进制数据，把二进制发送给服务器端；第三种是滤镜视觉特效，例如一些水波划动特效；第四种是视频摄像头的视频检测；当然还有很多有趣的玩法，例如通过Bitmapdata压缩数据之类的。

（注：从上面性能来看，对数据的传输，对数据的压缩，和运用的效率来看，利用BitmapData还是一种很有效的方式。）；

 

使用Bitmap和BitmapData时很容易犯一个错误

flash.display.Bitmap
The Bitmap class represents display objects that represent bitmap images.

flash.display.BitmapData
The BitmapData class lets you work with the data (pixels) of a Bitmap object.

由此可知Bitmap Class的主要功能是显示点阵影像，而BitmapData Class的功能主要是处理Bitmap每个像素资料
所以当我们要处理影像时千千万万不要对Bitmap下手，因为Bitmap的功能只能把影像的资料显示出來，而要处理影像必須先把Bitmap的次料交給BitmapData，再由BitmapData来对每个pixels处理才行，还有一个也是经常有人会发生的错误是直接把BitmapA的bitmapData Assign給BitmapB的bitmapData，当对BitmapB的BitmapData做更动时BitmapA也会跟著更动因为这两个Bitmap根本就Bindding同一个BitmapData，就像两个DataGrid Bindding同一份DataProvider的意思是一样的，当其中的DataGrid的dataProvider做修改,两个同时都会修改，所以当希望两个影像能各做各的事的话记得要再new一个新的BitmapData才行，否则只会把两个影像的资料绑死在一起。

二，公共属性

BitmapData的公共属性很少，只有4种，而且都属于Read-Only(只读)，只读的意思就是“只能读”（好废话），所以我们可以取出BitmapData的属性来做运算，但是却不能赋值给它们，跟只读区别的就是Read-Write（读写）。

有时程序有莫名其妙的问题，可以查看帮助文档，是不是因为你尝试对只读属性进行了赋值导致的。

1，height

就是Bitmapdata存储像素数据的高度

2，width

同理，就是Bitmapdata存储数据的宽度，这里扯多一句，一般保存长宽的都是Number属性，因为长宽可能存在小数点，而有些其他的属性可能是int的，把带有小数点的值赋值给int的属性的话，会自动把小数点后面的数值去掉，造成一些莫名其妙的错误，所以写代码的时候要多注意看代码提示里的属性说明。

3，transparent

是一个Boolen值，表示此Bitmapdata是否支持透明像素，一般的颜色分为16位颜色0xRRGGBB和32位颜色0xAARRGGBB。其中0x是16进制数字的意思，后面的每两位都代表着0~F，16个范围，所以每个颜色通道都有16*16=256位的数值，其中32位颜色就是多了一个AA（透明度）通道。

4，rect

返回BiamapData所占的矩形对象（Rectangle），你可以暂时理解为一个对象，这个对象储存了x,y,width,height等数值。

三，公共方法

BitmapData一共有32个公共方法，当然一部分是成对出现的get/set方法，让我们来一一介绍。

1，构造方法

BitmapData(width:int, height:int, transparent:Boolean = true, fillColor:uint = 0xFFFFFFFF)

构造方法有4个参数，其中两个必填，就是长宽，这两个值的输入保持“用多少填多少”的原则，因为Bitmapdata也是一种形式的内存开销,所以能省就省。第三个是transparent，就是是否允许透明像素，原则同上，如果能确定不用的话，最好关掉，默认为允许，第四个为填充颜色，bitmapdata既然是data,那肯定要有初始数据的存在，一开始是一些纯色的填充，默认为白色。

2，应用滤镜

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

这个函数很有意思，在我的印象里，bitmapdata.applyFilter就是直接对bitmapdata进行一次滤镜算法，然后把其中的像素进行从新赋值，那为什么会有这么四个参数呢。

我印象中的处理过程是：BMD--->滤镜算法--->得到的新BMD

而实际上确是：

Step1:

sourceBitmapData--->(sourceRect滤镜的作用矩形区域)--->filter(滤镜)--->新的BMD(长宽为作用矩形区域sourceRect的长宽)

Step2:

原来的BitmapData--->在destPoint的x,y位置上--->画上新的BMD

这样一来，除了可以实现对自己实施滤镜，还有了更多的可操作性。

3，复制

clone():BitmapData

这个与之前介绍的复杂类型一样，这里就不多说了，详情可参考之前的Matrix的clone方法介绍部分。

4，变色

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

这个有点头疼，牵扯到ColorTransform类，也是一个大家比较陌生的类，那么这个hold一hold，大家先知道这个函数作用就是将某一rect的区域按colorTransform的定义进行变色。

5，与其他BitmapData进行像素值的"比较",其实就是求差异（或者叫各像素相减得的差）

compare(otherBitmapData:BitmapData):Object

首先这两个BMD的比较分为几种情况：

（1）如果宽度不相同，函数返回-3。

（2）如果高度不相同，函数返回-4；

（3）如果宽高都不相同，先算宽，即函数返回-3；

（4）如果两个BMD完全相同，函数返回0；

（5）如果两个BMD长宽相同，颜色不同，则返回一个新的Bitmapdata对象，新BMD对象特征如下：

bmd1.compare(bmd2);

新BMD的每一点像素值为bmd1减bmd2所得，由于有Alpha存在，当RRGGBB不相同时，忽略Alpha的比较，新值为0xFF（RRGGBB差）；当RRGGBB相同时，则返回Alpha的差，新值则为0xZZ(Alpha差)XXXXX(RGB值)。

总的来说就是先比较颜色，颜色不同的情况下就不考虑透明度。颜色相同就看透明度的差异。不修改原对象，只返回一个新的BitmapData对象。具体玩法还不明，呵呵。

6，复制通道

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

这个就是对某一区域内所有像素的颜色通道的替换。sourceBitmapData:BitmapData, sourceRect:Rectangle, destPoint:Point这三个参数分别对应作用BMD，作用区域，和生成图在原BMD的位置。sourceChannel:uint, destChannel:uint这两个参数就是分别对应用哪个通道的值，去替换哪个通道。具体的通道保存在BitmapDataChannel类中。

注意，这类替换过程并不影响sourceBitmapData的像素信息，他只是将计算的结果重新赋值到原BMD的对应位置上。

7，复制像素

copyPixels(sourceBitmapData:BitmapData, sourceRect:Rectangle, destPoint:Point, alphaBitmapData:BitmapData = null, alphaPoint:Point = null, mergeAlpha:Boolean = false):void

sourceBitmapData, sourceRect, destPoint老三样，就不说了，说说其他三个参数。

alphaBitmapData和alphaPoint貌似是在Copy时有关Alpha通道的Map映射，作为Alpah通道值传入，而mergeAlpha则为是否复制Alpha通道的开关。

后面三个参数其实也不是太确定用法···不过平常的使用前面的就可以了，在涉及到Alpha通道的复制时可以再深入研究。这个函数可以用作截图，当然另外的一个draw方法也可以。

8，释放内存

dispose():void

这个主要作用是释放掉分配给BitmapData的内存，并将宽高设置为0，此后的所有对BitmapData的操作都将不生效。

9，draw方法，显示对象BitmapData化

draw(source:IBitmapDrawable, matrix:Matrix = null, colorTransform:ColorTransform = null, blendMode:String = null, clipRect:Rectangle = null, smoothing:Boolean = false):void

这里的六个参数，除了第一个是必选外，其余的都是可选：

source：要被“画”的对象。

matrix：一个变型矩阵，作用于BitmapData。

colorTransform：一个颜色变换，作用于BitmapData。

blendMode：图层叠加模式。具体的模式可以在BlendMode 类中找到。将BitmapData与source进行图层叠加。

clipRect：定义了draw source的区域。

smoothing：定义是否进行图像平滑。只对source是BitmapData时起作用。

这个绝对是BitmapData的重头戏，非常常用的方法。画一切可以“画”的对象，就是文章开头提到的实现了IBitmapDrawable接口的对象都可被“画”。BitmapData和DisplayObject都实现了这个接口。

这样做的好处是可以在显示对象不需要被使用的时候Draw一个假的放在舞台上，或者有很多元件在舞台上运动的时候，统一把结果Draw在一张BitmapData上，节省CPU的开销，实现用内存换取CPU性能。

注意，如果跨域没有安全文件的话，draw方法是无法draw到内容的，不过这种情况在一般的内容里不会出现。

 

10，填充矩形

fillRect(rect:Rectangle, color:uint):void

这个应该很好理解，就是输入一个矩形对象，然后用对应的颜色填充这块矩形对象的区域就OK了。

11，颜料桶填充

floodFill(x:int, y:int, color:uint):void

这个也是另外的一种填充，模拟的是我们平常在IDE里进行的颜料桶填充方式（选中颜色，选中填充的点，就会将所有附近相同颜色的像素一起填充）。对应的x,y就是点的坐标，color自然就是颜色啦。

12，计算滤镜作用区域

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

因为滤镜的作用区域不一定总等于输入的作用区域，所以这个函数是用来计算滤镜的实际作用区域的，输入的是一个矩形区域sourceRect和需要作用的滤镜filter，返回的是实际滤镜会影响到的矩形。

13，获取颜色区域

getColorBoundsRect(mask:uint, color:uint, findColor:Boolean = true):Rectangle

这个在做摄像头应用的常用来检测颜色的区域。返回的是由所有符合条件的像素组成的最大矩形。

color：就是要查找的颜色

findColor：为true时，是查找与color相同的颜色；为false则是查找与color不相同的颜色。

mask：是一个与输入color的掩码操作，作用是例如我只想进行某个通道的颜色比对时，可以不必管其他通道的的具体值。具体的运算方法是&（按位 AND），即逻辑与或非中的“与”操作，具体的结果是1&1=1,1&0=0&1=0&0=0,是二进制下的运算。

至于怎么比对？其实0xF = 二进制下的1111，类似的转化而已。

14，取得某点颜色（16位版）

getPixel(x:int, y:int):uint

很简单，就是取得x,y点的颜色（不包含Alpha通道）。

15，取得某点颜色，（32位版）

getPixel32(x:int, y:int):uint

同上，不过这次包含了Alpha通道

16，取得区域的像素二进制信息

getPixels(rect:Rectangle):ByteArray

这个函数是将一片区域rect内的所有图形信息，打包成一个二进制数组类ByteArray，作用是可以在头像上传时上传用户选择的部分。二进制数组类ByteArray也是一个高级的类，以后会有介绍。

17，获取区域内的像素矢量数组Vector

getVector(rect:Rectangle):Vector.<uint>

Vector这种数据结构是FP10以后新加的，那么这个方法对应的也只能在FP10或以上版本里使用。学过Java的同学可能很熟悉，其实Vector是一种固定数据类型的数组。即这个数组里的所有内容都必须是某种数据类型的。这样做的好处是因为事先规定好了数组的类型，那么在使用时不用花时间去判断弱类型，大大提高了运行效率，其他的使用方法大概跟Array一样。

那么这个函数其实没有太多的难点，就是返回一个Vector，里面包含的都是每一个像素的颜色信息而已。

18，获取区域内通道信息矢量数组Vector

histogram(hRect:Rectangle = null):Vector.<Vector>

这个也是FP10的新API，具体作用跟getVector很像，只是将getVector的结果继续拆分了而已。

返回的Vector里面有4个Vector，4个Vector里面装的是4个通道（Alpha,Red Green,Blue）的值0～255。再巩固一下Vector是有类型的数组，所以返回的是Vector.<Vector>，而4个Vector则是Vector.<Number>。

19，不规则碰撞检测（高级碰撞检测）

hitTest(firstPoint:Point, firstAlphaThreshold:uint, secondObject:Object, secondBitmapDataPoint:Point = null, secondAlphaThreshold:uint = 1):Boolean

详细的介绍可以参考《ActionScript Animation》，中文译名好像就Flash高级动画教程还是啥的，封面是个长颈鹿的··这本书挺出名的···

这里转一些介绍（其实配合上调用函数的对象，是6个参数）高手介绍的比我清楚得多：

注意到这5个参数被分成了两组：一个和另一个。每组都需要一个点来确定位图的左上角起点。

接着每组都还有一个透明阈值。之前提到过，支持透明的位图对象，每个像素的透明度取值范围在0（完全透明）到255（完全不透明）。参数透明阈值即指定， 透明度在多少的时候就算碰撞。

最后还剩一个参数，另一个对象。注意它的类型是Object。允许传递的可以是一个点(Point)，一个矩形(Rectangle)或者另一个位图对象 (BitmapData)。如果传一个点或者一个矩形，那么后面的两个参数可以忽略。

到此，测试都是围绕着Bitmap对象。而大多情况下的MovieClip，Sprite和Shape对象是没法用hitTest的。有个办法就是暗中准备一些BitmapData，不把它们加入到显示列表。当要对两个显示对象进行碰撞检测时，先把它们分别绘制到一个准备好的位图对象中，然后如法炮制。要知道，这不是唯一的办法，却是个不错的办法。

20，锁定变化

lock():void

因为对像素的操作涉及很多中间步骤，如果每操作一次都更新一次，那么如此大的计算量会把CPU拖垮的，这个函数的作用就是把BMD锁住，只保存更新步骤，而不更新实际像素。在做粒子效果时如果没有这一步绝对卡死人。

21，图像合并

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

头三个参数又是老三样，不多说。

后面的4个参数分别是AARRGGBB通道Multiplier

计算方法为新值=Source通道*Multiplier;

22,生成噪点

noise(randomSeed:int, low:uint = 0, high:uint = 255, channelOptions:uint = 7, grayScale:Boolean = false):void

生成一堆杂乱无章的图像填充BMD，意义何在？？一般是做贴图的MAP映射吧···创造出凹凸不平的效果，一般很少人会直接用吧···

randomSeed：随机的一个种子，就是从这个数字生成一大堆噪点图

low，high各通道在0～255区间取的最低和最高值

channelOptions:uint (default =7) — 一个数字，可以是四个颜色通道值的任意组合。 您可以使用逻辑 OR 运算符（|）来组合通道值。 （谁看的懂谁告诉我···我是不知道他想怎样了）

grayScale：这个如果设为true,则生成像素的RGB值将相等，即生成“灰度图”。如果是false则是为有色彩的。

23，调色板

paletteMap(sourceBitmapData:BitmapData, sourceRect:Rectangle, destPoint:Point, redArray:Array = null, greenArray:Array = null, blueArray:Array = null, alphaArray:Array = null):void

这个API在摄像头检测中有很重要的应用，回想刚刚的getColorBoundsRect(不用回想了，如果你能看一次就记住才有鬼了，还是拖上去看看吧)，：D，检测一个0xRRGGBB的颜色？见鬼！256x256x256=16777216种颜色，才定义其中一种？？除非是我自己填的，不然找啥啊～～

paletteMap函数的作用就是重新映射各个通道的范围，例如你可以把Red通道的颜色区间从原来的256种红映射成16种红，大大提高了你的检测成功率。

头三个参数还是老三样（我发现这句都成我口头禅了，哈）。不多说。

后面4个参数其实是一类的，四个通道AARRGGBB。

那么我们应该输入什么进这些数组呢·？答案是256长度的内容，对应各个通道的256个值，但是这个值是我们来定义的。

这里注意的是，由于最后的颜色是四个通道相加出来的，所以redArray的值应该是0x00000000~0x00FF0000，要将具体的值移位到正确的位置上。这里介绍两个大家平常很少用的二进制位操作符<<和>>，作用就是将二进制数全部向左或者向右移一位。

只要按你想要的把4个数组的映射保存好，作为参数传入就可以了。

 

 

http://hi.baidu.com/miracle5460/item/cb3ba3e94eab36e3fa42bae9

 

Macromedia Flash8 Image API 描述了一个的新的actionscirpt class类BitmapData 以及与其相关的各式各样的方法所带来的新的特性。这些新的方法使flash开发人员通过Actionscript在运行时创建并操作32位图像。这些Image Api非常类似于macromedia的产品Director中的lingo api.然而在flash8 的image api更细致准备，有更强的功能。在这篇文章中，我们将来研究如何开始使用Image Api并讨论它的一些能力。

在Actionscript 中使用Bitmaps

      新的BitmapData 类用来描述在内存中的bitmap对象，当你创建一个新的类实例时，一个空的图像就已经保存在内存中了，你可以使用BitmapData类所提供的各种方法来操作这个原始的bitmap.在你开始应用BitmapData类之前，你需要先了解一个关于bitmaps的前前后后。
    Bitmap是一个数字格式图形，它使用色彩数据网格来描述一张图像，在网格中的每一个单元格代表一个像素，每一个像素是都是由指定的色值渲染成的一个图像。Bitmap在flash player中被保存成32位色彩深度。这意味着每一个被指定了色彩的像素都是以二进制数保存，它的长度为32bit.在32位图像中的一个像素的颜色它可能只是16.7万色中的一种。每一种颜色又是由四种颜色通道如红，绿，蓝和alpha通道组成。
16进制颜色值
         在Actionscript中与BitmapData类相关联的颜色值是以32位的十六进制数形式表示的。一个32位的十六进制数包含了4个十六进制数对，每一对是两个数。每一对十六进制数定义4色通道（红，绿，蓝，alpha）之中一种通道的强度，每一个颜色通道的强度是一个十六进制数，强度范围是0-255的十进数,FF代表最强(255),00代到在这个通道中没有颜色（0）。正如你所看的，每一个通道是两个数的长度，例如是01而不能写成1，这样确保在一个十六进制数中你总是有8个数，同时不要忘记需要加上十六进制数的前缀0x,例如纯白色用十六进制表示为0xFFFFFFFF。黑色正好相反，在红，绿蓝三个通道中都没有颜色所以我们写成0xFF000000。注意alpha通道，在十六进制数对中，它是第一对，它仍处于最强状态，alpha通道为FF为最强状态意味着没有alpha,也就是说完全不透明，00意味着完全alpha,也就是说完全透明。所以一个透明像素的颜色值为0x00FFFFFF。
ARGB转换为十六进制值
        在通常情况下大多数人熟知的颜色值是ARGB格式也说每个值都使用的是0-255之前的数值，如果是这样，你需要知道如何将ARGB值转换为十六进制值，下面的代码告诉你如何来转换它们：如下代码：

function argbtohex(a:Number, r:Number, g:Number, b:Number)
{
    return (a<<24 | r<<16 | g<<8 | b)
}

使用方法：

hex=argbtohex(255,0,255,0)

十六进制转换为ARGB值
要将十六进制值转换为ARGB十进制形式，使用下面的代码：

function hextoargb(val:Number)
{
    var col={}
    col.alpha = (val >> 24) & 0xFF
    col.red = (val >> 16) & 0xFF
    col.green = (val >> 8) & 0xFF
    col.blue = val & 0xFF
    return col
}

使用方法：

argb=hextoargb(0xFFFFCC00);
alpha=argb.alpha;
red=argb.red;
green=argb.green;
blue=argb.blue;

使用actionscirpt创建Bitmap
在actionscrpt运行创建bitmap,需要我们先创建bitmap类实例，如下代码：

myBitmap=new flash.display.BitmapData(width,height,transparent,fillColor)

Bitmap类存在于flash.display类包中，为了减少我们的输入量，在创建类实例时可以先导入类，如下代码：

import flash.display.BitmapData;

然后你就可以创建bitmap类的实例了，如下代码：

var myBitmap = new BitmapData(width,height,transparent,fillcolor);

        BitmapData类构造函数接收四个参数分别是width(宽),height(高),transparent(透明度)和fillcolor（添充色）。Width和height用来指定所创建的bitmap的大小，如果你把bitmap想象为一个网格，那么宽就是水平方向的像素个数，高就是垂直方的像素个数。Tansparent是一个布尔值（true/false），它用来指定你是否打算让bitmap包含透明。Fillcolor参数用来指定在bitmap中每个像素的32位颜色。然而，如果你设置你的transparent值为false,那么前8bit所指定的颜色就会被忽略，因为在那种情况下就没有必要在传输32位的十六进制数了。取而代之的是，你可以传传输24位的十六进制数如0xFFFFFF的白色像素。Transparent和fillcolor两个参数是可选参数，如果你忽略他们，那么在内存中的bitmap就不会有透明并且每个像素都默认是白色如0xffffffff.
      例如，你要创建一个黑色的100*100大小的，完全不透明的bitmap. 你需要用到如下代码：

import flash.display.BitmapData;
myBitmap = new BitmapData(100,100,false,0Xff00000000);

注意：bitmap在flash player的限制大小为2880像素，如果你想创建超过这个大小的bitmap,那么bitmap是不会被创建的。因为创建超过限制大小的bitmap的会吞掉许掉客户端的RAM.
      一旦你创建完了bitmapData 类的实例，你就有了众多的bitmapData方法可以使用，用来操作你的bitmap。例如，你可以指定滤镜效果，添充色彩，编辑色彩，使某个区域透明等等，可能性是无穷的。然而在这篇文章中我们主要研究一些基础的内容，帮助你开始，并发现。
清除BitmapData
       一个BitmapData对象实例可以很快的吃掉访问者的内存，bitmap中的每个像素都要使用内存中的4个字节来保存。如果你创建的bitmap有500*500的大小，它将消耗掉1M左右的内存，如果你不在需要一个Bitmap对象，那最好的习惯是释放Bitmap所使用的内存，BitmapData提供了一个方法，帮你处理此事，dispose()方法，你只需要如下操作：

myBitmap.dispose();

记得要在你不使用BitmapData时，清掉bitmapData.以释放内存。

显示图像

     一个BitmapData类的实例保存在内存中,它是不可见的直到你决定是时候让它显示时,你需要将bitmap贴加(attche)到舞台(stage)上以使它可以被渲染。你可以使用方法MovieClip.attachBitmap让BitmapData对象显不在任何movieclip当中。

import flash.display.BitmapData;
myBitmap = new BitmapData(100,100,false,0Xff000000);
this.createEmptyMovieClip(“holder_mc”,1);
holder_mc.attachBitmap(myBitmap,1);

     创建一个空的影片剪辑来显示bitmap是一个不错的主意，当你贴加bitmap到你的影片剪辑中时，是没有方法移除的，而如果你单独创建了一个空影片剪辑用来显示bitmap,那么你在不需要时可能通过移除movieclip来移除bitmap.
如下代码：

holder_mc.removeMovieClip();

当你贴加bitmap到影片剪辑时，你对bitmapData的任何修改，影片剪辑中的bitmap都会自动的更新，你不需要每次都重新贴加。
快照
       BitmapData类有一个非常好的特性是它可以对任何动态的视觉元素做快照生成一个bitmap实例，如影片剪辑，video对象，文本域，这种特性可以让我们针对流式视频，摄像头或影片剪辑制作出一系列的静帧。
从一个movieClip或舞台上的其它实例对象创建bitmap，你需要使用BitmapData的draw()方法。默认情况下，这个方法绘制一个表现对象当前状态并且没有进行任何变形的bitmap，这意味着如果你正在获取一个视频对象的快照，视频对象发生了旋转，但是创建出来的bitmap是没有被旋转的。我们将在后面讨论它的细节。
         现在，我们把精力完全集中在BitmapData.draw()方法上，从它的简单结构上看，这个方法只是用矢量渲染来绘制指定对象的bitmap.这个方法还可以用来指定融合模式给一个bitmap或是通过ColorTransform类来计算颜色的bitmap.
例如，假设你有一个movieclip对象存在于场景中名称为animation_mc,在它的内部有一些矢量动画。当在动画时，你可以获取到当前动画状态的bitmap.如下代码：

import flash.display.BitmapData;
myBitmap = new BitmapData(animation_mc._width,animation_mc._height,true,0x00ffffff);
myBitmap.draw(animation_mc);

变换矩阵
       在flash8中增加了一个新的Matrix ActionScript类它可以把我们从创建变换矩阵的困难中摆脱出来。一个变换矩阵是一个3行*3列的数字，它反映的是从一个位置到另一个的点阵图。使用变换矩阵，你可以在同一时间内进行斜切，旋转，缩放和移动bitmap或是movieclip.仔细讨论Matrix 类已经超出了此文的范围。这里将介绍给你Matrix 类的一些方法，以满足你的日常应用。它是draw()方法中的第二个参数。
要创建变换矩阵，需要你先导入Matrix类，matrix类存在于flash.geom类包中。如下代码：

import flash.geom.Matrix;

然后你就可以创建Matrix类实例：

m= new Matrix();

      这样我们就创建了一个默认单位矩阵，当指定给对象时，矩阵并没有改变对象的缩放，旋转，斜切和位置。当你创建了一个矩阵之后，你可以使用矩阵所带的各种方法来编辑对象的属性和指定各种变换给对象。
      你可以使用Matrix.scale()方法来编辑矩阵，当它指定给对象时，它就会针对对象进行缩放。例如，创建一个变换矩阵它将缩放对象到它之前两倍的大的大小，使用下面的代码：

import flash.geom.Matrix;
m = new Matrix();
m.scale(2,2);

      如果当你在变换矩阵时你想旋转你的对象，那么你可以使用Matrix.rotate()方法。这个方法接受弧度。要将旋转角度值转换弧度你需要用到下面的简单的数学方法：

radians =(degree/180)*Math.PI;

下面代码编辑变换矩阵，当你将这段代码应用到对象时，它将旋转对象45度。

m.rotate((45/180)*Math.PI);

      要移动一个指定了矩阵的对象，你可以使用Matrix.translate()方法，当你指定给一个对象时，对象就会显示在指定位置上。

m.translate(100,100)

      现在你已经有了一个矩阵，当它指定给一个对象时，缩放到对象的两倍大小，旋转45度，并设定它的位置为x=100,y=100.
变换快照
     我们注意到之前我们提到的BitmapData.draw()方法接受一个变换矩阵做为第二参数。这使得你可以获取屏幕上的对象的快照，并且可能通过matrix对它进行编辑。
     当你获取到一个影片剪辑的快照，在默认状态绘制的快照是没有应用过任何变换的。这意味着如果你旋转了场景中的movieclip并且缩放它的大小，但是快照并不会旋转或是缩放。然而，如果你指定了变换矩阵作为matrix.draw()的第二个参数，那么你就可以将上述的这些变换应用到绘制出来快照bitmap上。
     当你缩放，旋转或是使用Actionscripta移动一个影片剪辑时。在flash player内部是使用变换矩阵来显示movieclip的正确位置。在flash8 播放器中你可以使用Movieclip.transform.matrix属性访问低级变换矩阵，这个属性返回正确变换值的Matrix类的实例。你可以使用这个属性来决定哪一种变换被应用到影片剪辑上。你还可创建与另一具有相同变换的影片剪辑。如下代码：

Movieclip1.transform.matrix=movieclip2.transform.matrix

下面的代码创建了一个包含square三角块的影片剪辑，使用Actiosncript对它进行缩放和旋转。如下代码：

import flash.display.BitmapData
this.createEmptyMovieClip("square_mc",1)
//绘制一个黄色的矩形
with(square_mc)
{
    beginFill(0xFFCC00)
    lineStyle(1,0x000000)
    lineTo(0,100)
     lineTo(100,100)
    lineTo(100,0)
    lineTo(0,0)
    endFill()
}
//旋转矩形方块
square_mc._rotation=45
//缩放两倍
square_mc._xscale=square_mc._yscale=200

      如果你要获取上面影片剪辑的快照，这个三角形bitmap不会被旋转和缩放,除非你指定了matarix变换。如果你想让这个矩形影片剪辑在bitmap中呈现出与场景中一样的状态，你需要指定影片剪辑的变换矩阵做为draw()方法的第二个参数。
如下代码：

//创建一个透明的bitmapData.它的大小与三角形相同
myBitmap =new BitmapData(square_mc._width,square_mc._height,true,0x00FFFFFF)

//绘制出与场景中相同大小的三角形bitmap 快照。
myBitmap.draw(square_mc,square_mc.transform.matrix)

       如果你不想让绘制的影片剪辑与场景中的一模一样，例如你可能想让bitmap的大小是movieclip大小的一半，你可以访问影片剪辑的变换矩阵编辑它，当它指定给对象时，你所做的编辑就会生效：
如下代码：

myBitmap = new BitmapData(square_mc._width/2,square_mc._height/2,true,0x00FFFFFF)
//获取影片剪辑的变换矩阵
m=square_mc.transform.matrix

//编辑影片剪辑的变换矩阵
m.scale(0.5,0.5)
//快照影片剪辑
myBitmap.draw(square_mc,m)

使用载入的图像

       直接载入外部文件如(jpeg,gif,png或是flash影片)做为BitmapData类的实例是不可能的事情，你能做的就是将这些外部文件载入到一个影片剪辑中，当它载入完成后，然后你才能对影片剪辑应用bitmap快照。

import flash.display.BitmapData;
//创建holder_mc用来载入外部文件
this.createEmptyMovieClip("holder_mc", this.getNextHighestDepth());
//创建show_mc用来显示bitmap
this.createEmptyMovieClip("show_mc",this.getNextHighestDepth());
//使用moviecliploader载入外部图片
loader = new MovieClipLoader();
//侦听主时间轴
loader.addListener(this);
//载入外部文件可以是png,gif,jpeg,swf
loader.loadClip("flower.jpg", holder_mc);
//定义onLoadInit事件
function onLoadInit() {
    //创建bitmap类实例
    myBitmap = new BitmapData(holder_mc._width, holder_mc._height, true, 0x00FFFFFF);
    //bitmap快照
    myBitmap.draw(holder_mc);
    //移除没有用的holder_mc
    holder_mc.removeMovieClip();
    //显示bitmap
    show_mc.attachBitmap(myBitmap,this.getNextHighestDepth());
}
//定义载入出错事件
function onLoadError(){
    holder_mc.removeMovieClip();
}

应用滤镜
        完全讨论滤镜超出了这篇教程的范围。然而通过图片为了减少锯齿或是硬边，我们一般情况要针对图像就用模糊，因此我们来看如何针对bitmap应用滤镜。你可以使用BitmapData.applyFilter()方法直接对bitmap应用各种各样的滤镜，Flash player支持各种滤镜如Displacement,Blur,Glow,DropShadow,和Bevel.你可应用所有的滤镜到bitmap中的一个矩形区域或是整个bitmap对象。下面的代码针对从库中载入的bitmap应用模糊滤镜。如下代码：

import flash.display.BitmapData;
import flash.filters.BlurFilter;
//使用loadBitmap方法载入库中的图像
myBitmap = BitmapData.loadBitmap("flower");
//定义模糊滤镜
blur = new BlurFilter(10, 10, 5);
//应用滤镜
myBitmap.applyFilter(myBitmap,myBitmap.rectangle,myBitmap.rectangle.topLeft,blur);
//创建holder_mc用来显示bitmap
this.createEmptyMovieClip("holder_mc", 0);
holder_mc.attachBitmap(myBitmap, 1);

       ApplyFilter()方法的第二个参数可以让你在指定的矩形区域上应用滤镜，在上面的例子中，我们使用的是bitmap的rectangle属性，它返回的是flash.geom..Rectangle类实例，它的大小就是图像的大小，因此我们可以对整个图像应用滤镜。然而，在你需要的时候你可以改变这个矩形区域的大小来指定滤镜，你需要创建一个Rectangle类的实例并将它传给applyFilter方法做为第二个参数。如下代码：

import flash.display.BitmapData;
import flash.filters.BlurFilter;
import flash.geom.Rectangle;
import flash.geom.Point;
//使用loadBitmap方法载入库中的图像
myBitmap = BitmapData.loadBitmap("flower");
//定义模糊滤镜
blur = new BlurFilter(10, 10, 5);
rectangle = new Rectangle(50,50,200,100);
//应用滤镜
myBitmap.applyFilter(myBitmap,rectangle,myBitmap.rectangle.topLeft,blur);
//创建holder_mc用来显示bitmap
this.createEmptyMovieClip("holder_mc", 0);
holder_mc.attachBitmap(myBitmap, -1);

       当你针对整个bitmap应用滤镜时,最终结果的bitmap可能要大于源图bitmap,例如，DropShadow滤镜要在bitmap四周增加像素.这使得生成的bitmap图像大于源bitmap图像，假设我们应用DropShadow滤镜到一个100像素宽高的bitmaph 上，它的距离是20像素45度角,当应用完滤镜后，结果的bitmap图像会超出16像素的大小，但是在这之前你并不清楚，只到你创建完bitmap对象之后，可能才会发现，当BitmapData对象创建完成后你是无法去修改它的。
还好有一种方式可以让你在应用滤镜之前决定最终bitmap的大小，因此你可以根据它来定义你的最终bitmap的大小。

import flash.display.BitmapData;
import flash.filters.DropShadowFilter;
//使用loadBitmap方法载入库中的图像
myBitmap = BitmapData.loadBitmap("logo");
//定义模糊滤镜
dropShadow = new DropShadowFilter(5,45);
//查看应用滤镜后bitmap的大小
filteredSize = myBitmap.generateFilterRect(myBitmap.rectangle, dropShadow);
trace(filteredSize);
//如果左上角为负数,你需要增加宽和高
w = (filteredSize.x<0) ? filteredSize.width-filteredSize.x : filteredSize.width;
h = (filteredSize.y<0) ? filteredSize.height-filteredSize.y : filteredSize.height;
//
fillColor = (myBitmap.transparent) ? 0x00FFFFFF : 0xFFFFFFFF;
//创建一个新的Bitmap用来存应用滤镜后的bimap
filteredBitmap = new BitmapData(w, h, myBitmap.transparent, fillColor);
//对载入的bitmap应用滤镜
filteredBitmap.applyFilter(myBitmap, myBitmap.rectangle, myBitmap.rectangle.topLeft, dropShadow);

获取像素的颜色
       你可以获取到bitmap中的任意像素的颜色,使用BitmapData.getPixel()方法可以返回以十进制式表示的指定x/y位置的RGB颜色值

import flash.display.BitmapData;
myBitmap = new BitmapData(100,100,false,0xFFCC00);
pixelColor = myBitmap.getPixel(50,50);
trace(pixelColor);

要获得16进制格式表示的数值,们可以使用toString()方法:

trace("0x"+pixelColor.toString(16)) //输出为 : 0xffcc00

       然而,你可能会发现,当我们使用getPixel()方法处理包含alpha通道(BitmapData.transparent==true)的bitmap时,你可能会获得意想不到的结果.
BitmapData.getPixel32()方法返回基于十进制表示的指定x/y位置的ARGB像素颜色值。这种方法也会返加alpha通道的数据与getPixel()不同。

import flash.display.BitmapData
myBitmap = new BitmapData(100,100,true,0x11FFCC00)
pixelColor=myBitmap.getPixel32(50,50)
trace("0x"+pixelColor.toString(16)) //outputs : 0x11ffd200

设置像素颜色
      要设置像素颜色，你可以使用BitmapData.setPixel()方法。这个方法可以改变指定了x/y位置的像素颜色值。你指定的颜色是以24bit的十六进制形式表现的如0xFFCC00，alpha通道字节将被忽略。

myBitmap = BitmapData.loadBitmap("photo")
//增加1000个像素
for(i=0;i<1000;++i)
{
    //generate two random x/y co-ordinates
    rx1=Math.floor(Math.random()*myBitmap.width)
    rx2=Math.floor(Math.random()*myBitmap.width)
    ry1=Math.floor(Math.random()*myBitmap.height)
    ry2=Math.floor(Math.random()*myBitmap.height)
    //设置随机的像素颜色为其它的像素的颜色。
    myBitmap.setPixel(rx1,ry1,myBitmap.getPixel(rx2,ry2))
}

        对于当前这个方法你只能用在不包含alpha透明通道（BitmapData.transparent）的图像上，否则你需要使用BitmapData.setPixel32()方法。SetPixel32()方法可以使你指定包含alpha通道数据的32位十六进制数据。

myBitmap.setPixel32(50,50,0xFFFFCC00)

设置像素组颜色
      你可以使用fillRect()方法为一个矩形区域内的像素指定颜色。这个方法通常会用在还原最初bitmap块的颜色。因为你可以添充整个bitmap块的颜色，比擦除的效率要高的多。
     这个方法的第一个参数是你想要添充的矩形区域。它是flash.geom.Rectangle类的实例。第二个参数是你想要改变的颜色。
要指定一个矩形区域，首先要先导入Rectangle类，Rectangle类存在于flash.geom.类包中：
代码如下：

import flash.geom.Rectangle;
myRect = new Rectangle(0,0,100,100);

       前两个参数是矩形的左上角x/y的位置，后两个参数是矩形的宽和高,你可以添充一个指定的颜色在矩形区域内。
如下代码：

myBitmap.fillRect(myRect,0xFFFF0000);

     注意每一个BitmapData类都有一个返回bitmap对象大小和位置的属性。Bitmap对象的位置总在处在0,0的位置，因此它最有用的地方是供bitmap类的方法用来检测位置。这个属称为BitmapData.rectangle它返加一个Rectangle 类实例。

//使用绿色添充整个bitmap.
myBitmap.fillRect(myBitmap.rectangle,0xFF00FF00);

改变颜色范围
      对你来说可能还有一件最复杂的事就是循环出每一像素的颜色然后改变它为其它颜色，如果你发现你需要改变颜色的位置是在同一色系的范围内，那么你不需要循环出每一像素的颜色，你可以使用BitmapData.threshold()方法，你可以分离和替换在同一色域范围内像素颜色。例如你想要一张图像上的所有红色像素透明，你可以使用下面的代码：

import flash.display.BitmapData
import flash.geom.Rectangle
//创建一个100*100大小的添充红色像素的bitmap
myBitmap = new BitmapData(100,100,true,0xFFFF0000)
//定义一个20*20大小的矩形.位于bitmap对像的中心位置
centeredRectangle=new Rectangle(40,40,20,20)
//用黑色像素添充矩形区域
myBitmap.fillRect(centeredRectangle,0xFF000000)
//改变bitmap上所有像素为红色并且透明.
redPixelCount=myBitmap.threshold(myBitmap,myBitmap.rectangle,myBitmap.rectangle.topLeft,"==",0xFFFF0000,0x00FFFFFF)

BitmapData.threshold()方法返回是受影响的所有像素点的数值。

trace(redPixelCount);//结果应是9600

你可以通过threshold来改变操作结果，threshold有四个参数；

你可以通过帮助文档来查看threshold,你还可以这样.如下:

myBitmap.threshold(myBitmap,myBitmap.rectangle,myBitmap.rectangle.topLeft,"!=",0xFFFF0000,0x00FFFFFF)

操作的结果与”==”的结果正是相反的.
复制像素
        复制像素在我们的图像操作中是常用的.你可以使用BitmapData.copyPixels()从一个bitmap复制像素到另一个bitmap.这个方法从源bitmap复制你指定的矩形区域的像素到目标bitmap.你还可以使用一张带有alpha通道的图像做为遮罩来进行复制操作,这可以使用所复制的不是矩形而是一个区域。
下面的例子复制一个矩形区域从一个bitmap到另一个bitmap.

import flash.display.BitmapData
import flash.geom.Rectangle

//贴加一第图像到bitmap中
myBitmap = BitmapData.loadBitmap("logo")

//定义一个复制像素的区域
area=new Rectangle(10,10,50,50)

//创建一个新的bitmap用来存放复制后的像素
bitmapSlot=new BitmapData(50,50)

//开始复制像素
bitmapSlot.copyPixels(myBitmap,area,bitmapSlot.rectangle.topLeft)

下面的这个例子是使用包含有一个圆形透明区域用做alpha遮罩来复制圆形区域的像素到另一个bitmap.

import flash.display.BitmapData
import flash.geom.Rectangle
import flash.geom.Matrix

//从库中加载图像bitmap
myBitmap = BitmapData.loadBitmap('logo')

//在影片剪辑内绘制一个园形
this.createEmptyMovieClip('mask_mc',1)
mask_mc.lineStyle(75,0x00FF00)
//绘制的圆的直径是75
mask_mc.lineTo(0,1)
//创建一个新的bitmap,注意要保有透明alpha通道
maskBitmap = new BitmapData(100,100,true,0x00FFFFFF)
//创建一个matrix
m=new Matrix()
//改变绘制的位置
m.translate(50,50)
//在bitmap中绘制圆形
maskBitmap.draw(mask_mc,m)
//移除mask_mc.不需要了.
mask_mc.removeMovieClip()
//创建一个bitmap,用来存放复制过来的像素.用透明像素来添充
circleBitmap=new BitmapData(100,100,true,0x00FFFFFF)
//开始复制像素.
circleBitmap.copyPixels(myBitmap,myBitmap.rectangle,circleBitmap.rectangle.topLeft,maskBitmap,maskBitmap.rectangle.topLeft)
//显示bitmap
this.attachBitmap(circleBitmap,1)
//清除maskBitmap.
maskBitmap.dispose()

 

http://blog.163.com/mdzhg@126/blog/static/163321568201041823325775/

一、构造方法：

var bmd:BitmapData=new BitmapData(200,100,true,0xffff0000);

参数说明：

１、宽

２、高

３、是否使用３２位填充位图（包括alpha)

４、填充色。

 

 

二、属性（注意：所有属性都是只读）

１、widht　宽

２、height 高

３、rect 矩形范围，即：Rectangle

4、transparent　透明度，即：是否使用３２位填充。

 

 

三、方法

１、applyFilter():使用滤镜

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

参数说明：

sourceBitmapData：源位图数据，可以是当前bitmapData,也可以把别的bitmapData作滤镜处理后用于当前bitmapData.

sourceRect：源矩形，决定着对那一块区域使用滤镜。

destPoint：目标点，使用到目标位图数据后对滤镜区域进行坐标偏移。

filter：要应该的滤镜。

 

２、clone():BitmapData

返回一个新的 BitmapData 对象，它是对原始实例的克隆，包含与原始实例所含位图完全相同的副本。

 

3、colorTransform() :对位图数据进行颜色变化。

colorTransform(rect:Rectangle, colorTransform:ColorTransform):

 

４、compare(): 对两个位图数据进行比较。

compare(otherBitmapData:BitmapData):

说明：

1）要求两个位图数据的高、宽要一样，否则无法比较。

2）比较时红色跟红色比，绿色跟绿色比，蓝色跟蓝色比，请注意，他们的差值永远是正的，也就是要取绝对值。

3）比较的结果是返回一个新Object,需要强制转换为BitmapData

4）如果两个位图数据高、宽、颜色完全一样，则比较没有意义。生成的bitmapData=null.

5）上面的比较都在忽略alpha的基础上，如果两个位图数据有不同的alpha，比较可能变得更加复杂，不才经过几次测试后仍不能得到正确的答案。

 

5、copyChannel()：拷贝通道；

copyChannel(sourceBitmapData:BitmapData, sourceRect:Rectangle, destPoint:Point, sourceChannel:uint, destChannel:uint):

参数说明：

sourceBitmapData：源位图数据，当然可以去别的位图数据中拷贝通道。

sourceRect：源矩形，拷贝的范围。

destPoint：目标点，拷贝到目标位图数据后对坐标进行偏移。

sourceChannel：源通道，即：要拷贝的是哪一个通道。

destChannel：目标通道，即：要拷贝到目标位图数据的哪一个通道。

 注意事项，拷贝通道属于一种覆盖型拷贝而非叠加型拷贝，拷贝后目标通道的原有数据将被覆盖。

下面是一种最简单的给图片去色的方法。

bmd1.copyChannel(bmd1,bmd1.rect,new Point(),2,1);//把绿色通道拷贝到红色通道。
bmd1.copyChannel(bmd1,bmd1.rect,new Point(),2,4);//把绿色通道拷贝到蓝色通道。

注意，当三个通道的颜色信息值一样时，图片就变成灰色了。但这样做有一个缺点：它仅仅只是以一个通道为基准而对图片去色。更准确的去色方法请参考滤镜：ColorMatrixFilter () 颜色矩阵滤镜。

 

６、copyPixels() ：拷贝象素。copyPixels(sourceBitmapData:, sourceRect:, destPoint:, alphaBitmapData: = null, alphaPoint: = null, mergeAlpha: = false):费话不想多说，最后三个参数搞不懂也。

 

７、dispose() ：释放内存。

 对此 BitmapData 实例的方法或属性的所有后续调用都将失败，并引发异常。

 

８、draw() ：绘制数据。

draw(source:IBitmapDrawable, matrix:Matrix = null, colorTransform:ColorTransform = null, blendMode:String = null, clipRect:Rectangle = null, smoothing:Boolean = false):

参数说明：

source：要绘制的对象，几乎可以是所有的显示对象。当然，还可是以非显示类的bitmapData

matrix：使用矩阵，因为draw()方法不考虑对象的坐标，缩放，旋转的因素，所在需要使用matrix来达到移动，缩放，旋转等功能。

colorTransform：颜色变化。

blendMode：混合模式。

clipRect：要绘制的矩形区域。

smoothing：是否进行平滑处理，使用matrix后，对象可能会有锯齿，要求source是bitmapData是才有作用。

 

９、fillRect()　：给指定的矩形区域填充颜色。

fillRect(rect:Rectangle, color:uint)

 

10、floodFill() ：倾倒填充

floodFill(x:int, y:int, color:uint)

说明：在坐标x,y处查找点并倾倒颜色，以该点相邻的且着色相同的全部被指定的color倾倒填充

 

11、generateFilterRect () ：返回：Rectangle,得到滤镜后的矩形。

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

参数：

sourceRect:　使用滤镜的矩形区域。

filter:　使用的滤镜。

说明：有些滤镜，比如模糊，使用后所影响到的区域要比原先的区域大一些，此时可以用此方法获得所影响到的区域。

 

12、getColorBoundsRect () ：获得颜色区域。返回：Rectangle.

getColorBoundsRect(mask:uint, color:uint, findColor:Boolean = true):Rectangle

参数说明：

mask：颜色掩码。简单解释一下：最终查找的颜色是mask&color。即mask跟color的逻辑与运算，即转换为二进制后，相同数位都是１则才为１.所以，如果没有特别的要求，请把mask设置为0xffffffff.

color：要查找的颜色。

findColor：匹配颜色还是反向匹配颜色。如果该值设置为 true，则返回图像中颜色值的范围。 如果该值设置为 false，则返回图像中不存在此颜色的范围。

 

13、getPixel(x:int,y:int) :uint 和　getPixel32(x:int,y:int):uint;

获得某个像素的２４位色或３２位色。

 

14、setPixel(x:int,y:int) :uint 和　setPixel32(x:int,y:int):uint;

设置某个像素的２４位色或３２位色。

 

15、getPixels(rect:Rectangle):ByteArray 和 setPixels (rect:Rectangle, inputByteArray:ByteArray) :void

注意；这两方法最后有一个s,是复数，获得或设置某个区域的像素，第一个的返回值是ByteArray.

 

16、hitText() ;高级碰撞检测。

hitTest(firstPoint:Point, firstAlphaThreshold:uint, secondObject:Object, secondBitmapDataPoint:Point = null, secondAlphaThreshold:uint = 1):Boolean

参数说明：

firstPoint：相对于当前bitmapData的坐标点。

firstAlphaThreshold：要检测的当前bitmapData的透明度，有效值是0—255，

secondObject：检测与哪一个对象发生碰撞，即：目标对象。

secondObject：目标对象的坐标点。

secondAlphaThreshold：目标对象的透明度。

注：关于hitText的更详细用法，请参考本Blog的相关文章。

 

17、lock() 和 unlock()

若要提高性能，请在对 setPixel() 或 setPixel32() 方法进行多次调用之前和之后使用 loce() 方法及 unlock() 方法。

 

18、merge()  图像混合。

merge(sourceBitmapData:BitmapData, sourceRect:Rectangle, destPoint:Point, redMultiplier:uint, greenMultiplier:uint, blueMultiplier:uint, alphaMultiplier:uint)

参数说明：

前三个参数：略：

第四、五、六、七个参数：

各通道的乘数，有效值0—255

例如，在红色通道中，新值是按如下方式计算的（其中 redSrc 是源图像中像素的红色通道值，而 redDest 是目标图像中对应像素的红色通道值）：

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

从这个公式可以看出，最终的颜色是靠源颜色和目标颜色合成的，如果目标颜色占了80%的份量，那么源颜色只能占20%。另外，从公式还可以看出，如果原来的BitmapData的透明度是100%的话，设置alphaMultiplier显然变得毫无意义，但们最终的透明度仍然是100%.

 

19、noise()：使用表示随机杂点的像素填充图像

noise(randomSeed:, low: = 0, high: = 255, channelOptions: = 7, grayScale: = false)

参数说明：

randomSeed：要使用的随机种子数。 如果您保持使所有其它参数不变，可以通过改变随机种子值来生成不同的伪随机结果。 杂点函数是一个映射函数，不是真正的随机数生成函数，所以它每次都会根据相同的随机种子创建相同的结果

low：要为每个通道生成的最低值（0 到 255）。 （最暗）

high：要为每个通道生成的最高值（0 到 255）。 (最亮）

channelOptions：一个数字，可以是四个颜色通道值（BitmapDataChannel.RED、BitmapDataChannel.BLUE、BitmapDataChannel.GREEN 和 BitmapDataChannel.ALPHA）的任意组合。 您可以使用逻辑 OR 运算符（|）来组合通道值。

grayScale：一个布尔值。 如果该值为 true，则会通过将所有颜色通道设置为相同的值来创建一个灰度图像。 将此参数设置为 true 不会影响 Alpha 通道的选择

 

20、paletteMap ()  ：调色板

paletteMap(sourceBitmapData:BitmapData, sourceRect:Rectangle, destPoint:Point, redArray:Array = null, greenArray:Array = null, blueArray:Array = null, alphaArray:Array = null)

参数说明：

前三个参数不用多说，后四个参数分别的红、绿、蓝、透明通道的数据映射数组，如果省略在前的参数则需要传递null.

它们都是一组长度为256（0－255）的数组，用于存储每个通道的十六进制映射值，例：

var redArr:Array=[];
 var blurArr:Array=[];
 var greenArr:Array=[];
 for(var i:int=255;i>-1;i--){
  redArr.push(00<<24|i<<16|0<<8|00)
  blurArr.push(00<<24|0<<16|i<<8|00)
  greenArr.push(00<<24|0<<16|0<<8|i)
 }
 bmd1.paletteMap(bmd1,bmd1.rect,new Point(),null,blurArr,greenArr);

上面的代码能让图片颜色反转。

 

21、perlinNoise() ：柏林噪音，能模拟云彩，瀑布等纹理。

perlinNoise(baseX:Number, baseY:Number, numOctaves:uint, randomSeed:int, stitch:Boolean, fractalNoise:Boolean, channelOptions:uint = 7, grayScale:Boolean = false, offsets:Array = null）

参数说明：

baseX 和 baseY ：在X和Y轴方向生成的纹理大小。

numOctaves：数字八度音阶，作用是生成纹理的层数，注意：层数越多，图像越细腻，但渲染速度越慢。

randomSeed：伪随机种子：解释过好多遍了，相同的种子生成的纹理是相同的，所以说这样的纹理并不是真正意义上的随机。

stitch：一个布尔值。 如果该值为 true，则该方法将尝试平滑图像的转变边缘以创建无缝的纹理，用于作为位图填充进行平铺。

fractalNoise:Boolean — 一个布尔值。 如果该值为 true，则该方法将生成碎片杂点（即云彩效果）；否则，它将生成湍流。 带有湍流的图像具有可见的不连续性渐变，可以使其具有更接近锐化的视觉效果，例如火焰或海浪。

channelOptions:uint (default = 7) — 一个数字，可以是四个颜色通道值（BitmapDataChannel.RED、BitmapDataChannel.BLUE、BitmapDataChannel.GREEN 和 BitmapDataChannel.ALPHA）的任意组合。 您可以使用逻辑 OR 运算符（|）来组合通道值。

grayScale：是否是灰度图像；

offsets:Array (default = null) — 与每个 octave 的 x 和 y 偏移量相对应的点数组。 通过操作这些偏移量值，您可以平滑滚动 perlinNoise 图像的图层。 偏移数组中的每个点将影响一个特定的 octave 杂点函数。（注意：这里的数组长度应该和数字八度音阶的层数相等，它们是一一对应的，用相同的伪随机种子，不断的改变offsets偏移量，再不断的使用该方法，纹理就会产生运动的漂亮效果）

 

22、pixelDissolve () ：像素溶解

pixelDissolve(sourceBitmapData:BitmapData, sourceRect:Rectangle, destPoint:Point, randomSeed:int = 0, numPixels:int = 0, fillColor:uint = 0):int

参数说明：

sourceBitmapData：源位图数据：可以是当前位图，也可以是别的位图数据；

randomSeed：伪随机种子（特别需要提醒一下：访方法有一个返回值int,使用该方法的返回值作为种子将让你更“顺利”的完成溶解）。

numPixels：每次执行该方法能够溶解多少像素。

fillColor：溶解时用什么颜色的像素填充（仅限于sourceBitmapData是当前位图）；

特别说明：怎样判断像素已经溶解完毕：

用当前bitmapData的总像素除以numPixels（每次溶解的像素）＝需要溶解的次数。

但是这有一个非常重要的前提就是每次调用方法的种子必须是上次方法结束时返回的值，如：

var i:int=100;//刚开始可以随便给它一个种子

dissolve(i);//注意，这个方法需要用Timer类反复执行，执行的次数上面有述，次处不再重复。

function dissolve(randomNum:Number):void {
    var rect:Rectangle = bmd.rect;
    var pt:Point = new Point(0, 0);
    var numberOfPixels:uint = 1000;
    i=bmd.pixelDissolve(bmd1, rect, pt, randomNum, numberOfPixels);//把方法执行的结果赋值给i
}

 

23、scroll（x,y) ：滚动，又是一个做特效的好方法：

比如：下面是给一下BitmapData滚动两次后的效果：

bmd1.scroll(30,30);//X,Y轴同时滚动30个像素。也可以只滚动X轴或只滚动Y轴。
bmd1.scroll(30,30);//试试用enterFrame让它不停的滚动很小的像素。

 

 

24、threshold() :根据指定的阈值测试图像中的像素值，并将通过测试的像素设置为新的颜色值。 通过使用 threshold() 方法，您可以隔离和替换图像中的颜色范围，并对图像像素执行其它逻辑操作。

threshold(sourceBitmapData:BitmapData, sourceRect:Rectangle, destPoint:Point, operation:String, threshold:uint, color:uint = 0, mask:uint = 0xFFFFFFFF, copySource:Boolean = false):uint