PorterDuffXfermode使用

尊重原创转载请注明：From AigeStudio（http://blog.csdn.net/aigestudio）Power by Aige

该类同样有且只有一个含参的构造方法PorterDuffXfermode(PorterDuff.Mode mode)，这个PorterDuff.Mode大家看后是否会有些面熟，它跟上面我们讲ColorFilter时候用到的PorterDuff.Mode是一样的！麻雀虽小五脏俱全，虽说构造方法的签名列表里只有一个PorterDuff.Mode的参数，但是它可以实现很多酷毙的图形效果！！而PorterDuffXfermode就是图形混合模式的意思，其概念最早来自于SIGGRAPH的Tomas Proter和Tom Duff，混合图形的概念极大地推动了图形图像学的发展，延伸到计算机图形图像学像Adobe和AutoDesk公司著名的多款设计软件都可以说一定程度上受到影响，而我们PorterDuffXfermode的名字也来源于这俩人的人名组合PorterDuff，那PorterDuffXfermode能做些什么呢？我们先来看一张API DEMO里的图片：

这张图片从一定程度上形象地说明了图形混合的作用，两个图形一圆一方通过一定的计算产生不同的组合效果，在API中Android为我们提供了18种（比上图多了两种ADD和OVERLAY）模式：

来定义不同的混合效果，这18种模式Android还为我们提供了它们的计算方式比如LIGHTEN的计算方式为[Sa + Da - Sa*Da, Sc*(1 - Da) + Dc*(1 - Sa) + max(Sc, Dc)]，其中Sa全称为Source alpha表示源图的Alpha通道；Sc全称为Source color表示源图的颜色；Da全称为Destination alpha表示目标图的Alpha通道；Dc全称为Destination color表示目标图的颜色，细心的朋友会发现“[……]”里分为两部分，其中“,”前的部分为“Sa + Da - Sa*Da”这一部分的值代表计算后的Alpha通道而“,”后的部分为“Sc*(1 - Da) + Dc*(1 - Sa) + max(Sc, Dc)”这一部分的值代表计算后的颜色值，图形混合后的图片依靠这个矢量来计算ARGB的值，如果大家感兴趣可以查看维基百科中对Alpha合成的解释：http://en.wikipedia.org/wiki/Alpha_compositing。作为一个猿，我们不需要知道复杂的图形学计算但是一定要知道这些模式会为我们提供怎样的效果，当大家看到上面API DEMO给出的效果时一定会觉得PorterDuffXfermode其实就是简单的图形交并集计算，比如重叠的部分删掉或者叠加等等，事实上呢！PorterDuffXfermode的计算绝非是根据于此！上面我们也说了PorterDuffXfermode的计算是要根据具体的Alpha值和RGB值的，既然如此，我们就来看一个比API DEMO稍微复杂的例子来更有力地说明PorterDuffXfermode是如何工作而我们又能用它做些什么，在这个例子中我将用到两个带有Alpha通道的渐变图形Bitmap：

我们将在不同的模式下混合这两个Bitmap来看看这两个渐变色的颜色值在不同的混合模式下究竟发生了什么？先看看我们的测试代码：

[java] view plaincopyprint?

1. @TargetApi(Build.VERSION_CODES.HONEYCOMB)  
2. public class PorterDuffView extends View {  
3.     /* 
4.      * PorterDuff模式常量 
5.      * 可以在此更改不同的模式测试 
6.      */  
7.     private static final PorterDuff.Mode MODE = PorterDuff.Mode.ADD;  
8.   
9.     private static final int RECT_SIZE_SMALL = 400;// 左右上方示例渐变正方形的尺寸大小  
10.     private static final int RECT_SIZE_BIG = 800;// 中间测试渐变正方形的尺寸大小  
11.   
12.     private Paint mPaint;// 画笔  
13.   
14.     private PorterDuffBO porterDuffBO;// PorterDuffView类的业务对象  
15.     private PorterDuffXfermode porterDuffXfermode;// 图形混合模式  
16.   
17.     private int screenW, screenH;// 屏幕尺寸  
18.     private int s_l, s_t;// 左上方正方形的原点坐标  
19.     private int d_l, d_t;// 右上方正方形的原点坐标  
20.     private int rectX, rectY;// 中间正方形的原点坐标  
21.   
22.     public PorterDuffView(Context context, AttributeSet attrs) {  
23.         super(context, attrs);  
24.   
25.         // 实例化画笔并设置抗锯齿  
26.         mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);  
27.   
28.         // 实例化业务对象  
29.         porterDuffBO = new PorterDuffBO();  
30.   
31.         // 实例化混合模式  
32.         porterDuffXfermode = new PorterDuffXfermode(MODE);  
33.   
34.         // 计算坐标  
35.         calu(context);  
36.     }  
37.   
38.     /** 
39.      * 计算坐标 
40.      *  
41.      * @param context 
42.      *            上下文环境引用 
43.      */  
44.     private void calu(Context context) {  
45.         // 获取包含屏幕尺寸的数组  
46.         int[] screenSize = MeasureUtil.getScreenSize((Activity) context);  
47.   
48.         // 获取屏幕尺寸  
49.         screenW = screenSize[0];  
50.         screenH = screenSize[1];  
51.   
52.         // 计算左上方正方形原点坐标  
53.         s_l = 0;  
54.         s_t = 0;  
55.   
56.         // 计算右上方正方形原点坐标  
57.         d_l = screenW - RECT_SIZE_SMALL;  
58.         d_t = 0;  
59.   
60.         // 计算中间方正方形原点坐标  
61.         rectX = screenW / 2 - RECT_SIZE_BIG / 2;  
62.         rectY = RECT_SIZE_SMALL + (screenH - RECT_SIZE_SMALL) / 2 - RECT_SIZE_BIG / 2;  
63.     }  
64.   
65.     @Override  
66.     protected void onDraw(Canvas canvas) {  
67.         super.onDraw(canvas);  
68.         // 设置画布颜色为黑色以便我们更好地观察  
69.         canvas.drawColor(Color.BLACK);  
70.   
71.         // 设置业务对象尺寸值计算生成左右上方的渐变方形  
72.         porterDuffBO.setSize(RECT_SIZE_SMALL);  
73.   
74.         /* 
75.          * 画出左右上方两个正方形 
76.          * 其中左边的的为src右边的为dis 
77.          */  
78.         canvas.drawBitmap(porterDuffBO.initSrcBitmap(), s_l, s_t, mPaint);  
79.         canvas.drawBitmap(porterDuffBO.initDisBitmap(), d_l, d_t, mPaint);  
80.   
81.         /* 
82.          * 将绘制操作保存到新的图层（更官方的说法应该是离屏缓存）我们将在1/3中学习到Canvas的全部用法这里就先follow me 
83.          */  
84.         int sc = canvas.saveLayer(0, 0, screenW, screenH, null, Canvas.ALL_SAVE_FLAG);  
85.   
86.         // 重新设置业务对象尺寸值计算生成中间的渐变方形  
87.         porterDuffBO.setSize(RECT_SIZE_BIG);  
88.   
89.         // 先绘制dis目标图  
90.         canvas.drawBitmap(porterDuffBO.initDisBitmap(), rectX, rectY, mPaint);  
91.   
92.         // 设置混合模式  
93.         mPaint.setXfermode(porterDuffXfermode);  
94.   
95.         // 再绘制src源图  
96.         canvas.drawBitmap(porterDuffBO.initSrcBitmap(), rectX, rectY, mPaint);  
97.   
98.         // 还原混合模式  
99.         mPaint.setXfermode(null);  
100.   
101.         // 还原画布  
102.         canvas.restoreToCount(sc);  
103.     }  
104. }  

代码中我们使用到了View的离屏缓冲，也通俗地称之为层，这个概念很简单，我们在绘图的时候新建一个“层”，所有的绘制操作都在该层上而不影响该层以外的图像，比如代码中我们在绘制了画布颜色和左右上方两个方形后就新建了一个图层来绘制中间的大正方形，这个方形和左右上方的方形是在两个不同的层上的：

注：图中所显示色彩效果与我们的代码不同，上图只为演示图层概念

当我们绘制完成后要通过restore将所有缓冲（层）中的绘制操作还原到画布以结束绘制，具体关于画布的知识在自定义控件其实很简单1/3，这里就不多说了，下面我们看具体各种模式的计算效果

PS：Src为源图像，意为将要绘制的图像；Dis为目标图像，意为我们将要把源图像绘制到的图像……是不是感脚很拗口 = = ！Fuck……意会意会~~

PorterDuff.Mode.ADD

计算方式：Saturate(S + D)；Chinese：饱和相加

从计算方式和显示的结果我们可以看到，ADD模式简单来说就是对图像饱和度进行相加，这个模式在应用中不常用，我唯一一次使用它是通过代码控制RGB通道的融合生成图片。

PorterDuff.Mode.CLEAR

计算方式：[0, 0]；Chinese：清除

清除图像，很好理解不扯了。

PorterDuff.Mode.DARKEN

计算方式：[Sa + Da - Sa*Da, Sc*(1 - Da) + Dc*(1 - Sa) + min(Sc, Dc)]；Chinese：变暗

这个模式计算方式目测很复杂，其实效果很好理解，两个图像混合，较深的颜色总是会覆盖较浅的颜色，如果两者深浅相同则混合，如图，黄色覆盖了红色而蓝色和青色因为是跟透明混合所以不变。细心的朋友会发现青色和黄色之间有一层类似橙色的过渡色，这就是混合的结果。在实际的测试中源图和目标图的DARKEN混合偶尔会有相反的结果比如红色覆盖了黄色，这源于Android对颜色值“深浅”的定义，我暂时没有在官方查到有关资料不知道是否与图形图像学一致。DARKEN模式的应用在图像色彩方面比较广泛我们可以利用其特性来获得不同的成像效果，这点与之前介绍的ColorFilter有点类似。

PorterDuff.Mode.DST

计算方式：[Da, Dc]；Chinese：只绘制目标图像

如Chinese所说，很好理解。

PorterDuff.Mode.DST_ATOP

计算方式：[Sa, Sa * Dc + Sc * (1 - Da)]；Chinese：在源图像和目标图像相交的地方绘制目标图像而在不相交的地方绘制源图像

PorterDuff.Mode.DST_IN

计算方式：[Sa * Da, Sa * Dc]；Chinese：只在源图像和目标图像相交的地方绘制目标图像

最常见的应用就是蒙板绘制，利用源图作为蒙板“抠出”目标图上的图像，这里我讲一个很简单的例子，如果大家用过PS就很容易理解，我这里有两张图：

一张是一个很漂亮的手绘古典美女：

而另一张是一张只有黑色和透明通道的遮罩图：

我们把这张美女图画在我们的屏幕上：

[java] view plaincopyprint?

1. public class DisInView extends View {  
2.     private Paint mPaint;// 画笔  
3.     private Bitmap bitmapDis;// 位图  
4.   
5.     private int x, y;// 位图绘制时左上角的起点坐标  
6.     private int screenW, screenH;// 屏幕尺寸  
7.   
8.     public DisInView(Context context) {  
9.         this(context, null);  
10.     }  
11.   
12.     public DisInView(Context context, AttributeSet attrs) {  
13.         super(context, attrs);  
14.   
15.         // 初始化画笔  
16.         initPaint();  
17.   
18.         // 初始化资源  
19.         initRes(context);  
20.     }  
21.   
22.     /** 
23.      * 初始化画笔 
24.      */  
25.     private void initPaint() {  
26.         // 实例化画笔  
27.         mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);  
28.     }  
29.   
30.     /** 
31.      * 初始化资源 
32.      */  
33.     private void initRes(Context context) {  
34.         // 获取位图  
35.         bitmapDis = BitmapFactory.decodeResource(context.getResources(), R.drawable.a3);  
36.   
37.         // 获取包含屏幕尺寸的数组  
38.         int[] screenSize = MeasureUtil.getScreenSize((Activity) context);  
39.   
40.         // 获取屏幕尺寸  
41.         screenW = screenSize[0];  
42.         screenH = screenSize[1];  
43.   
44.         /* 
45.          * 计算位图绘制时左上角的坐标使其位于屏幕中心 
46.          * 屏幕坐标x轴向左偏移位图一半的宽度 
47.          * 屏幕坐标y轴向上偏移位图一半的高度 
48.          */  
49.         x = screenW / 2 - bitmapDis.getWidth() / 2;  
50.         y = screenH / 2 - bitmapDis.getHeight() / 2;  
51.   
52.     }  
53.   
54.     @Override  
55.     protected void onDraw(Canvas canvas) {  
56.         super.onDraw(canvas);  
57.   
58.         // 绘制美女图  
59.         canvas.drawBitmap(bitmapDis, x, y, mPaint);  
60.     }  
61. }  

运行后如下：

美女脑袋上有个文字标识巨恶心而且因为图片画质问题美图周围还有一片淡黄色的不好看，那我们就通过刚才那个黑色的透明通道图把美女“抠”出来：

[java] view plaincopyprint?

1. public class DisInView extends View {  
2.     private Paint mPaint;// 画笔  
3.     private Bitmap bitmapDis, bitmapSrc;// 位图  
4.     private PorterDuffXfermode porterDuffXfermode;// 图形混合模式  
5.   
6.     private int x, y;// 位图绘制时左上角的起点坐标  
7.     private int screenW, screenH;// 屏幕尺寸  
8.   
9.     public DisInView(Context context) {  
10.         this(context, null);  
11.     }  
12.   
13.     public DisInView(Context context, AttributeSet attrs) {  
14.         super(context, attrs);  
15.   
16.         // 实例化混合模式  
17.         porterDuffXfermode = new PorterDuffXfermode(PorterDuff.Mode.DST_IN);  
18.   
19.         // 初始化画笔  
20.         initPaint();  
21.   
22.         // 初始化资源  
23.         initRes(context);  
24.     }  
25.   
26.     /** 
27.      * 初始化画笔 
28.      */  
29.     private void initPaint() {  
30.         // 实例化画笔  
31.         mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);  
32.     }  
33.   
34.     /** 
35.      * 初始化资源 
36.      */  
37.     private void initRes(Context context) {  
38.         // 获取位图  
39.         bitmapDis = BitmapFactory.decodeResource(context.getResources(), R.drawable.a3);  
40.         bitmapSrc = BitmapFactory.decodeResource(context.getResources(), R.drawable.a3_mask);  
41.   
42.         // 获取包含屏幕尺寸的数组  
43.         int[] screenSize = MeasureUtil.getScreenSize((Activity) context);  
44.   
45.         // 获取屏幕尺寸  
46.         screenW = screenSize[0];  
47.         screenH = screenSize[1];  
48.   
49.         /* 
50.          * 计算位图绘制时左上角的坐标使其位于屏幕中心 
51.          * 屏幕坐标x轴向左偏移位图一半的宽度 
52.          * 屏幕坐标y轴向上偏移位图一半的高度 
53.          */  
54.         x = screenW / 2 - bitmapDis.getWidth() / 2;  
55.         y = screenH / 2 - bitmapDis.getHeight() / 2;  
56.   
57.     }  
58.   
59.     @Override  
60.     protected void onDraw(Canvas canvas) {  
61.         super.onDraw(canvas);  
62.         canvas.drawColor(Color.WHITE);  
63.   
64.         /* 
65.          * 将绘制操作保存到新的图层（更官方的说法应该是离屏缓存）我们将在1/3中学习到Canvas的全部用法这里就先follow me 
66.          */  
67.         int sc = canvas.saveLayer(0, 0, screenW, screenH, null, Canvas.ALL_SAVE_FLAG);  
68.   
69.         // 先绘制dis目标图  
70.         canvas.drawBitmap(bitmapDis, x, y, mPaint);  
71.   
72.         // 设置混合模式  
73.         mPaint.setXfermode(porterDuffXfermode);  
74.   
75.         // 再绘制src源图  
76.         canvas.drawBitmap(bitmapSrc, x, y, mPaint);  
77.   
78.         // 还原混合模式  
79.         mPaint.setXfermode(null);  
80.   
81.         // 还原画布  
82.         canvas.restoreToCount(sc);  
83.     }  
84. }  

看！只剩米女了~~~~：

当然该混合模式的用法绝不止这么简单，这只是阐述了一个原理，更棒的用法就看你怎么用了~~~~

PorterDuff.Mode.DST_OUT

计算方式：[Da * (1 - Sa), Dc * (1 - Sa)]；Chinese：只在源图像和目标图像不相交的地方绘制目标图像

上面那个例子呢我们把米女抠了出来，而这次我们将从一个色块中把米女的轮廓挖出来~~~~啦啦啦：

[java] view plaincopyprint?

1. public class DisOutView extends View {  
2.     private Paint mPaint;// 画笔  
3.     private Bitmap bitmapSrc;// 位图  
4.     private PorterDuffXfermode porterDuffXfermode;// 图形混合模式  
5.   
6.     private int x, y;// 位图绘制时左上角的起点坐标  
7.     private int screenW, screenH;// 屏幕尺寸  
8.   
9.     public DisOutView(Context context) {  
10.         this(context, null);  
11.     }  
12.   
13.     public DisOutView(Context context, AttributeSet attrs) {  
14.         super(context, attrs);  
15.   
16.         // 实例化混合模式  
17.         porterDuffXfermode = new PorterDuffXfermode(PorterDuff.Mode.DST_OUT);  
18.   
19.         // 初始化画笔  
20.         initPaint();  
21.   
22.         // 初始化资源  
23.         initRes(context);  
24.     }  
25.   
26.     /** 
27.      * 初始化画笔 
28.      */  
29.     private void initPaint() {  
30.         // 实例化画笔  
31.         mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);  
32.     }  
33.   
34.     /** 
35.      * 初始化资源 
36.      */  
37.     private void initRes(Context context) {  
38.         // 获取位图  
39.         bitmapSrc = BitmapFactory.decodeResource(context.getResources(), R.drawable.a3_mask);  
40.   
41.         // 获取包含屏幕尺寸的数组  
42.         int[] screenSize = MeasureUtil.getScreenSize((Activity) context);  
43.   
44.         // 获取屏幕尺寸  
45.         screenW = screenSize[0];  
46.         screenH = screenSize[1];  
47.   
48.         /* 
49.          * 计算位图绘制时左上角的坐标使其位于屏幕中心 
50.          * 屏幕坐标x轴向左偏移位图一半的宽度 
51.          * 屏幕坐标y轴向上偏移位图一半的高度 
52.          */  
53.         x = screenW / 2 - bitmapSrc.getWidth() / 2;  
54.         y = screenH / 2 - bitmapSrc.getHeight() / 2;  
55.   
56.     }  
57.   
58.     @Override  
59.     protected void onDraw(Canvas canvas) {  
60.         super.onDraw(canvas);  
61.         canvas.drawColor(Color.WHITE);  
62.   
63.         /* 
64.          * 将绘制操作保存到新的图层（更官方的说法应该是离屏缓存）我们将在1/3中学习到Canvas的全部用法这里就先follow me 
65.          */  
66.         int sc = canvas.saveLayer(0, 0, screenW, screenH, null, Canvas.ALL_SAVE_FLAG);  
67.   
68.         // 先绘制一层颜色  
69.         canvas.drawColor(0xFF8f66DA);  
70.   
71.         // 设置混合模式  
72.         mPaint.setXfermode(porterDuffXfermode);  
73.   
74.         // 再绘制src源图  
75.         canvas.drawBitmap(bitmapSrc, x, y, mPaint);  
76.   
77.         // 还原混合模式  
78.         mPaint.setXfermode(null);  
79.   
80.         // 还原画布  
81.         canvas.restoreToCount(sc);  
82.     }  
83. }  

看看美女那动人的轮廓~~~~~么么哒：

PorterDuff.Mode.DST_OVER

计算方式：[Sa + (1 - Sa)*Da, Rc = Dc + (1 - Da)*Sc]；Chinese：在源图像的上方绘制目标图像

这个就不说啦，就是两个图片谁在上谁在下的意思

PorterDuff.Mode.LIGHTEN

计算方式：[Sa + Da - Sa*Da, Sc*(1 - Da) + Dc*(1 - Sa) + max(Sc, Dc)]；Chinese：变亮

与DARKEN相反，不多说了

PorterDuff.Mode.MULTIPLY

计算方式：[Sa * Da, Sc * Dc]；Chinese：正片叠底

该模式通俗的计算方式很简单，源图像素颜色值乘以目标图像素颜色值除以255即得混合后图像像素的颜色值，该模式在设计领域应用广泛，因为其特性黑色与任何颜色混合都会得黑色，在手绘的上色、三维动画的UV贴图绘制都有应用，具体效果大家自己尝试我就不说了

PorterDuff.Mode.OVERLAY

计算方式：未给出；Chinese：叠加

这个模式没有在官方的API DEMO中给出，谷歌也没有给出其计算方式，在实际效果中其对亮色和暗色不起作用，也就是说黑白色无效，它会将源色与目标色混合产生一种中间色，这种中间色生成的规律也很简单，如果源色比目标色暗，那么让目标色的颜色倍增否则颜色递减。

PorterDuff.Mode.SCREEN

计算方式：[Sa + Da - Sa * Da, Sc + Dc - Sc * Dc]；Chinese：滤色

计算方式我不解释了，滤色产生的效果我认为是Android提供的几个色彩混合模式中最好的，它可以让图像焦媃幻化，有一种色调均和的感觉：

[java] view plaincopyprint?

1. public class ScreenView extends View {  
2.     private Paint mPaint;// 画笔  
3.     private Bitmap bitmapSrc;// 位图  
4.     private PorterDuffXfermode porterDuffXfermode;// 图形混合模式  
5.   
6.     private int x, y;// 位图绘制时左上角的起点坐标  
7.     private int screenW, screenH;// 屏幕尺寸  
8.   
9.     public ScreenView(Context context) {  
10.         this(context, null);  
11.     }  
12.   
13.     public ScreenView(Context context, AttributeSet attrs) {  
14.         super(context, attrs);  
15.   
16.         // 实例化混合模式  
17.         porterDuffXfermode = new PorterDuffXfermode(PorterDuff.Mode.SCREEN);  
18.   
19.         // 初始化画笔  
20.         initPaint();  
21.   
22.         // 初始化资源  
23.         initRes(context);  
24.     }  
25.   
26.     /** 
27.      * 初始化画笔 
28.      */  
29.     private void initPaint() {  
30.         // 实例化画笔  
31.         mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);  
32.     }  
33.   
34.     /** 
35.      * 初始化资源 
36.      */  
37.     private void initRes(Context context) {  
38.         // 获取位图  
39.         bitmapSrc = BitmapFactory.decodeResource(context.getResources(), R.drawable.a3);  
40.   
41.         // 获取包含屏幕尺寸的数组  
42.         int[] screenSize = MeasureUtil.getScreenSize((Activity) context);  
43.   
44.         // 获取屏幕尺寸  
45.         screenW = screenSize[0];  
46.         screenH = screenSize[1];  
47.   
48.         /* 
49.          * 计算位图绘制时左上角的坐标使其位于屏幕中心 
50.          * 屏幕坐标x轴向左偏移位图一半的宽度 
51.          * 屏幕坐标y轴向上偏移位图一半的高度 
52.          */  
53.         x = screenW / 2 - bitmapSrc.getWidth() / 2;  
54.         y = screenH / 2 - bitmapSrc.getHeight() / 2;  
55.   
56.     }  
57.   
58.     @Override  
59.     protected void onDraw(Canvas canvas) {  
60.         super.onDraw(canvas);  
61.         canvas.drawColor(Color.WHITE);  
62.   
63.         /* 
64.          * 将绘制操作保存到新的图层（更官方的说法应该是离屏缓存）我们将在1/3中学习到Canvas的全部用法这里就先follow me 
65.          */  
66.         int sc = canvas.saveLayer(0, 0, screenW, screenH, null, Canvas.ALL_SAVE_FLAG);  
67.   
68.         // 先绘制一层带透明度的颜色  
69.         canvas.drawColor(0xcc1c093e);  
70.   
71.         // 设置混合模式  
72.         mPaint.setXfermode(porterDuffXfermode);  
73.   
74.         // 再绘制src源图  
75.         canvas.drawBitmap(bitmapSrc, x, y, mPaint);  
76.   
77.         // 还原混合模式  
78.         mPaint.setXfermode(null);  
79.   
80.         // 还原画布  
81.         canvas.restoreToCount(sc);  
82.     }  
83. }  

它比原图多一层蓝紫色调给人感觉更古典~~

PorterDuff.Mode.SRC

计算方式：[Sa, Sc]；Chinese：显示源图

只绘制源图，SRC类的模式跟DIS的其实差不多就不多说了，大家多动手自己试试，我已经写不动了快………………………………………………………………………………………………………………

PorterDuff.Mode.SRC_ATOP

计算方式：[Da, Sc * Da + (1 - Sa) * Dc]；Chinese：在源图像和目标图像相交的地方绘制源图像，在不相交的地方绘制目标图像

PorterDuff.Mode.SRC_IN

计算方式：[Sa * Da, Sc * Da]；Chinese：只在源图像和目标图像相交的地方绘制源图像

PorterDuff.Mode.SRC_OUT

计算方式：[Sa * (1 - Da), Sc * (1 - Da)]；Chinese：只在源图像和目标图像不相交的地方绘制源图像

PorterDuff.Mode.SRC_OVER

计算方式：[Sa + (1 - Sa)*Da, Rc = Sc + (1 - Sa)*Dc]；Chinese：在目标图像的顶部绘制源图像

PorterDuff.Mode.XOR

计算方式：[Sa + Da - 2 * Sa * Da, Sc * (1 - Da) + (1 - Sa) * Dc]；Chinese：在源图像和目标图像重叠之外的任何地方绘制他们，而在不重叠的地方不绘制任何内容

XOR我们在将PixelXorXfermode的时候提到过，不了解的话上去看看~~~实在写不动了

那么这些混合模式究竟有什么用？能够给我们带来什么好处呢？假设我们要画一个闹钟，如下：

注：该闹钟图标为已投入运行项目文件并已有商标，请大家不要以任何盈利手段为目的盗用，当然做练习是没问题的

构思一下怎么做，我们需要画一个圆圈做钟体，两个Path（Path为路径，我们将会在1/3详细学习到，这里就先follow me）作为指针，问题是两个铃铛~~~~如果我们不会混合模式，一定会想怎么计算坐标啊去绘制曲线然后闭合然后填充啊之类………………实际上有必要吗？这个闹铃不就是一个小圆再用一个大圆去遮罩吗：

问题是不是一下子就变简单了？如果等你去计算怎么画路径怎么闭合曲线填充颜色还有多屏幕的匹配………………哥已经死了又活过来又死了…………在学完1/2的View尺寸计算和布局后我会教大家如何做类似的View并匹配在所有的屏幕上~~~~这里就先缓一缓。大家一定要有这样的思维，当你想要去画一个View的时候一定要想想看这个View的图形是不是可以通过基本的几何图形混合来生成，如果可以，那么恭喜你，使用PorterDuffXfermode的混合模式你可以事半功倍！

PorterDuffXfermode的另一个比较常见的应用就是橡皮檫效果，我们可以通过手指不断地触摸屏幕绘制Path，再以Path作遮罩遮掉填充的色块显示下层的图像：

[java] view plaincopyprint?

1. public class EraserView extends View {  
2.     private static final int MIN_MOVE_DIS = 5;// 最小的移动距离：如果我们手指在屏幕上的移动距离小于此值则不会绘制  
3.   
4.     private Bitmap fgBitmap, bgBitmap;// 前景橡皮擦的Bitmap和背景我们底图的Bitmap  
5.     private Canvas mCanvas;// 绘制橡皮擦路径的画布  
6.     private Paint mPaint;// 橡皮檫路径画笔  
7.     private Path mPath;// 橡皮擦绘制路径  
8.   
9.     private int screenW, screenH;// 屏幕宽高  
10.     private float preX, preY;// 记录上一个触摸事件的位置坐标  
11.   
12.     public EraserView(Context context, AttributeSet set) {  
13.         super(context, set);  
14.   
15.         // 计算参数  
16.         cal(context);  
17.   
18.         // 初始化对象  
19.         init(context);  
20.     }  
21.   
22.     /** 
23.      * 计算参数 
24.      *  
25.      * @param context 
26.      *            上下文环境引用 
27.      */  
28.     private void cal(Context context) {  
29.         // 获取屏幕尺寸数组  
30.         int[] screenSize = MeasureUtil.getScreenSize((Activity) context);  
31.   
32.         // 获取屏幕宽高  
33.         screenW = screenSize[0];  
34.         screenH = screenSize[1];  
35.     }  
36.   
37.     /** 
38.      * 初始化对象 
39.      */  
40.     private void init(Context context) {  
41.         // 实例化路径对象  
42.         mPath = new Path();  
43.   
44.         // 实例化画笔并开启其抗锯齿和抗抖动  
45.         mPaint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG);  
46.   
47.         // 设置画笔透明度为0是关键！我们要让绘制的路径是透明的，然后让该路径与前景的底色混合“抠”出绘制路径  
48.         mPaint.setARGB(128, 255, 0, 0);  
49.   
50.         // 设置混合模式为DST_IN  
51.         mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));  
52.   
53.         // 设置画笔风格为描边  
54.         mPaint.setStyle(Paint.Style.STROKE);  
55.   
56.         // 设置路径结合处样式  
57.         mPaint.setStrokeJoin(Paint.Join.ROUND);  
58.   
59.         // 设置笔触类型  
60.         mPaint.setStrokeCap(Paint.Cap.ROUND);  
61.   
62.         // 设置描边宽度  
63.         mPaint.setStrokeWidth(50);  
64.   
65.         // 生成前景图Bitmap  
66.         fgBitmap = Bitmap.createBitmap(screenW, screenH, Config.ARGB_8888);  
67.   
68.         // 将其注入画布  
69.         mCanvas = new Canvas(fgBitmap);  
70.   
71.         // 绘制画布背景为中性灰  
72.         mCanvas.drawColor(0xFF808080);  
73.   
74.         // 获取背景底图Bitmap  
75.         bgBitmap = BitmapFactory.decodeResource(context.getResources(), R.drawable.a4);  
76.   
77.         // 缩放背景底图Bitmap至屏幕大小  
78.         bgBitmap = Bitmap.createScaledBitmap(bgBitmap, screenW, screenH, true);  
79.     }  
80.   
81.     @Override  
82.     protected void onDraw(Canvas canvas) {  
83.         // 绘制背景  
84.         canvas.drawBitmap(bgBitmap, 0, 0, null);  
85.   
86.         // 绘制前景  
87.         canvas.drawBitmap(fgBitmap, 0, 0, null);  
88.   
89.         /* 
90.          * 这里要注意canvas和mCanvas是两个不同的画布对象 
91.          * 当我们在屏幕上移动手指绘制路径时会把路径通过mCanvas绘制到fgBitmap上 
92.          * 每当我们手指移动一次均会将路径mPath作为目标图像绘制到mCanvas上，而在上面我们先在mCanvas上绘制了中性灰色 
93.          * 两者会因为DST_IN模式的计算只显示中性灰，但是因为mPath的透明，计算生成的混合图像也会是透明的 
94.          * 所以我们会得到“橡皮擦”的效果 
95.          */  
96.         mCanvas.drawPath(mPath, mPaint);  
97.     }  
98.   
99.     /** 
100.      * View的事件将会在7/12详解 
101.      */  
102.     @Override  
103.     public boolean onTouchEvent(MotionEvent event) {  
104.         /* 
105.          * 获取当前事件位置坐标 
106.          */  
107.         float x = event.getX();  
108.         float y = event.getY();  
109.   
110.         switch (event.getAction()) {  
111.         case MotionEvent.ACTION_DOWN:// 手指接触屏幕重置路径  
112.             mPath.reset();  
113.             mPath.moveTo(x, y);  
114.             preX = x;  
115.             preY = y;  
116.             break;  
117.         case MotionEvent.ACTION_MOVE:// 手指移动时连接路径  
118.             float dx = Math.abs(x - preX);  
119.             float dy = Math.abs(y - preY);  
120.             if (dx >= MIN_MOVE_DIS || dy >= MIN_MOVE_DIS) {  
121.                 mPath.quadTo(preX, preY, (x + preX) / 2, (y + preY) / 2);  
122.                 preX = x;  
123.                 preY = y;  
124.             }  
125.             break;  
126.         }  
127.   
128.         // 重绘视图  
129.         invalidate();  
130.         return true;  
131.     }  
132. }  

运行效果如下：