Android学习记录045_PorterDuff

已于 2022-08-08 20:11:04 修改
阅读量906 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： # Android学习记录 文章标签： android 学习 java
于 2022-07-21 20:58:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Duckdan/article/details/125920215
本文详细介绍了Android图形绘制中PorterDuff.Mode的16种模式，包括DST、DST_IN、DST_OUT、DST_ATOP等，并通过代码示例展示了每种模式下源像素与目标像素的混合效果，帮助理解其在图形叠加时的行为。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、PorterDuff.Mode

1.1 PorterDuff.Mode.DST
/**
* The source pixels are discarded, leaving the destination intact.
*/ 
private void test01(Canvas canvas) {
        canvas.drawColor(Color.TRANSPARENT);
        RectF rectF = new RectF(0, 0, 350, 350);
        canvas.saveLayer(rectF, mPaint);
        canvas.drawColor(Color.parseColor("#FFff0000"));
        /**
         *  什么时候调用setXfermode方法很重要
         *  DST：[Da, Dc]
         *  此时DST是画布新建的layer层
         */
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST));
        //0x7F00FF00
        canvas.drawBitmap(srcBmp, 0, 0, mPaint);
        canvas.restore();
     	//混合过后，混合区域中有颜色的结果值是0xffff0000
    }
1.2 PorterDuff.Mode.DST_IN
/**
*Keeps the destination pixels that cover source pixels, discards the remaining source and destination pixels.
*/ 
private void test01(Canvas canvas) {
        canvas.drawColor(Color.TRANSPARENT);
        RectF rectF = new RectF(0, 0, 350, 350);
        canvas.saveLayer(rectF, mPaint);
        canvas.drawColor(Color.parseColor("#FFff0000"));
        /**
         *  什么时候调用setXfermode方法很重要
         *  DST_IN：[Sa * Da, Sa * Dc]
         *  此时DST是画布新建的layer层
         */
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));
        //0x7F00FF00
        canvas.drawBitmap(srcBmp, 0, 0, mPaint);
        canvas.restore();
        //混合过后，混合区域中有颜色的结果值是0x7fff0000
    }
1.3 PorterDuff.Mode.DST_OUT
/**
*
个人认为这个说法有问题，因为跟得到的结果不一致
Keeps the destination pixels that are not covered by source pixels. Discards destination pixels that are covered by source pixels. Discards all source pixels.
*/
private void test01(Canvas canvas) {
        canvas.drawColor(Color.TRANSPARENT);
        RectF rectF = new RectF(0, 0, 350, 350);
        canvas.saveLayer(rectF, mPaint);
        canvas.drawColor(Color.parseColor("#FFff0000"));
        /**
         *  什么时候调用setXfermode方法很重要
         *  DST_OUT：[Da * (1 - Sa), Dc * (1 - Sa)]
         *  此时DST是画布新建的layer层
         */
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_OUT));
        //0x7F00FF00
        canvas.drawBitmap(srcBmp, 0, 0, mPaint);
        canvas.restore();
        //混合过后，混合区域中有颜色的结果值是0x80ff0000
    }
1.4 PorterDuff.Mode.DST_ATOP
/**
* 
个人认为说法有问题，因为跟结果不一致。
Discards the destination pixels that are not covered by source pixels. Draws remaining destination pixels over source pixels.
*/  
private void test01(Canvas canvas) {
        canvas.drawColor(Color.TRANSPARENT);
        RectF rectF = new RectF(0, 0, 350, 350);
        canvas.saveLayer(rectF, mPaint);
        canvas.drawColor(Color.parseColor("#FFff0000"));
        /**
         *  什么时候调用setXfermode方法很重要
         *  DST_ATOP：[Sa, Sa * Dc + Sc * (1 - Da)]
         *  此时DST是画布新建的layer层
         */
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_ATOP));
        //0x7F00FF00
        canvas.drawBitmap(srcBmp, 0, 0, mPaint);
        canvas.restore();
      //混合过后，混合区域中有颜色的结果值是0x7fff0000
    }
1.5 PorterDuff.Mode.SRC
/**
* The source pixels replace the destination pixels
*/ 
private void test01(Canvas canvas) {
        canvas.drawColor(Color.TRANSPARENT);
        RectF rectF = new RectF(0, 0, 350, 350);
        canvas.saveLayer(rectF, mPaint);
        canvas.drawColor(Color.parseColor("#FFff0000"));
        /**
         *  什么时候调用setXfermode方法很重要
         *  SRC：[Sa, Sc]
         *  此时DST是画布新建的layer层
         */
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC));
        //0x7F00FF00
        canvas.drawBitmap(srcBmp, 0, 0, mPaint);
        canvas.restore();
        //混合过后，混合区域中有颜色的结果值是0x7f00ff00
    }
1.6 PorterDuff.Mode.SRC_IN
/**
* Keeps the source pixels that cover the destination pixels, discards the remaining source and destination pixels.
*/ 
private void test01(Canvas canvas) {
        canvas.drawColor(Color.TRANSPARENT);
        RectF rectF = new RectF(0, 0, 350, 350);
        canvas.saveLayer(rectF, mPaint);
        canvas.drawColor(Color.parseColor("#FFff0000"));
        /**
         *  SRC_IN：[Sa * Da, Sc * Da]
         *  此时DST是画布新建的layer层
         */
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
        //0x7F00FF00
        canvas.drawBitmap(srcBmp, 0, 0, mPaint);
        canvas.restore();
     	//混合过后，混合区域中有颜色的结果值是0x7f00ff00
    }
1.7 PorterDuff.Mode.SRC_OUT
/**
* Keeps the source pixels that do not cover destination pixels. Discards source pixels that cover destination pixels. Discards all destination pixels.
*/  
private void test01(Canvas canvas) {
        canvas.drawColor(Color.TRANSPARENT);
        RectF rectF = new RectF(0, 0, 350, 350);
        canvas.saveLayer(rectF, mPaint);
        canvas.drawColor(Color.parseColor("#FFff0000"));
        /**
         *  什么时候调用setXfermode方法很重要
         *  SRC_OUT：[Sa * (1 - Da), Sc * (1 - Da)]
         *  此时DST是画布新建的layer层
         */
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_OUT));
        //0x7F00FF00
        canvas.drawBitmap(srcBmp, 0, 0, mPaint);
        canvas.restore();
      //混合过后，混合区域中有颜色的结果值是0x00000000
    }
1.8 PorterDuff.Mode.SRC_ATOP
/**
* Discards the source pixels that do not cover destination pixels. Draws remaining source pixels over destination pixels.
*/
private void test01(Canvas canvas) {
        canvas.drawColor(Color.TRANSPARENT);
        RectF rectF = new RectF(0, 0, 350, 350);
        canvas.saveLayer(rectF, mPaint);
        canvas.drawColor(Color.parseColor("#FFff0000"));
        /**
         *  什么时候调用setXfermode方法很重要
         *  SRC_ATOP：[Da, Sc * Da + (1 - Sa) * Dc]
         *  此时DST是画布新建的layer层
         */
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_ATOP));
        //0x7F00FF00
        canvas.drawBitmap(srcBmp, 0, 0, mPaint);
        canvas.restore();
    	//混合过后，混合区域中有颜色的结果值是0xff807f00
    }
1.9 PorterDuff.Mode.SRC_OVER
/**
* The source pixels are drawn over the destination pixels.
*/
private void test01(Canvas canvas) {
        canvas.drawColor(Color.TRANSPARENT);
        RectF rectF = new RectF(0, 0, 350, 350);
        canvas.saveLayer(rectF, mPaint);
        canvas.drawColor(Color.parseColor("#FFff0000"));
        /**
         *  什么时候调用setXfermode方法很重要
         *  SRC_OVER：[Sa + (1 - Sa)*Da, Rc = Sc + (1 - Sa)*Dc]
         *  此时DST是画布新建的layer层
         */
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_OVER));
        //0x7F00FF00
        canvas.drawBitmap(srcBmp, 0, 0, mPaint);
        canvas.restore();
    	 //混合过后，混合区域中有颜色的结果值是0xff807f00
    }
1.10 PorterDuff.Mode.XOR
/**
* 
个人认为说法有问题，因为跟结果不一致。
Discards the source and destination pixels where source pixels cover destination pixels. Draws remaining source pixels.
*/ 
private void test01(Canvas canvas) {
        canvas.drawColor(Color.TRANSPARENT);
        RectF rectF = new RectF(0, 0, 350, 350);
        canvas.saveLayer(rectF, mPaint);
        canvas.drawColor(Color.parseColor("#FFff0000"));
        /**
         *  什么时候调用setXfermode方法很重要
         *  XOR：[Sa + Da - 2 * Sa * Da, Sc * (1 - Da) + (1 - Sa) * Dc]
         *  此时DST是画布新建的layer层
         */
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.XOR));
        //0x7F00FF00
        canvas.drawBitmap(srcBmp, 0, 0, mPaint);
        canvas.restore();
      //混合过后，混合区域中有颜色的结果值是0x80ff0000
    }
1.11 PorterDuff.Mode.DARKEN
/**
*Retains the smallest component of the source and destination pixels.
*/
private void test01(Canvas canvas) {
        canvas.drawColor(Color.TRANSPARENT);
        RectF rectF = new RectF(0, 0, 350, 350);
        canvas.saveLayer(rectF, mPaint);
        canvas.drawColor(Color.parseColor("#FFff0000"));
        /**
         *  什么时候调用setXfermode方法很重要
         *  DARKEN：[Sa + Da - Sa*Da, Sc*(1 - Da) + Dc*(1 - Sa) + min(Sc, Dc)]
         *  此时DST是画布新建的layer层
         */
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DARKEN));
        //0x7F00FF00
        canvas.drawBitmap(srcBmp, 0, 0, mPaint);
        canvas.restore();
       //混合过后，混合区域中有颜色的结果值是0xff800000
    }
1.12 PorterDuff.Mode.LIGHTEN
/**
*Retains the largest component of the source and destination pixel.
*/ 
private void test01(Canvas canvas) {
        canvas.drawColor(Color.TRANSPARENT);
        RectF rectF = new RectF(0, 0, 350, 350);
        canvas.saveLayer(rectF, mPaint);
        canvas.drawColor(Color.parseColor("#FFff0000"));
        /**
         *  什么时候调用setXfermode方法很重要
         *  LIGHTEN：[Sa + Da - Sa*Da, Sc*(1 - Da) + Dc*(1 - Sa) + max(Sc, Dc)]
         *  此时DST是画布新建的layer层
         */
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.LIGHTEN));
        //0x7F00FF00
        canvas.drawBitmap(srcBmp, 0, 0, mPaint);
        canvas.restore();
     	//混合过后，混合区域中有颜色的结果值是0xffff7f00
    }
1.13 PorterDuff.Mode.MULTIPLY
/**
* Multiplies the source and destination pixels.
*/
private void test01(Canvas canvas) {
        canvas.drawColor(Color.TRANSPARENT);
        RectF rectF = new RectF(0, 0, 350, 350);
        canvas.saveLayer(rectF, mPaint);
        canvas.drawColor(Color.parseColor("#FFff0000"));
        /**
         *  什么时候调用setXfermode方法很重要
         *  MULTIPLY：[Sa * Da, Sc * Dc]
         *  此时DST是画布新建的layer层
         */
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.MULTIPLY));
        //0x7F00FF00
        canvas.drawBitmap(srcBmp, 0, 0, mPaint);
        canvas.restore();
    	//混合过后，混合区域中有颜色的结果值是0x7f000000
    }
1.14 PorterDuff.Mode.SCREEN
/**
* Adds the source and destination pixels, then subtracts the source pixels multiplied by the destination.
*/
private void test01(Canvas canvas) {
        canvas.drawColor(Color.TRANSPARENT);
        RectF rectF = new RectF(0, 0, 350, 350);
        canvas.saveLayer(rectF, mPaint);
        canvas.drawColor(Color.parseColor("#FFff0000"));
        /**
         *  什么时候调用setXfermode方法很重要
         *  SCREEN：[Sa + Da - Sa * Da, Sc + Dc - Sc * Dc]
         *  此时DST是画布新建的layer层
         */
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SCREEN));
        //0x7F00FF00
        canvas.drawBitmap(srcBmp, 0, 0, mPaint);
        canvas.restore();
    	//混合过后，混合区域中有颜色的结果值是0xffff7f00
    }
1.15 PorterDuff.Mode.ADD
/**
*Adds the source pixels to the destination pixels and saturates the result.
*/ 
private void test01(Canvas canvas) {
        canvas.drawColor(Color.TRANSPARENT);
        RectF rectF = new RectF(0, 0, 350, 350);
        canvas.saveLayer(rectF, mPaint);
        canvas.drawColor(Color.parseColor("#FFff0000"));
        /**
         *  什么时候调用setXfermode方法很重要
         *  ADD：[max(0,min(Sa+Da,1)),max(0,min(Sc+Dc,1)]
         *  此时DST是画布新建的layer层
         */
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.ADD));
        //0x7F00FF00
        canvas.drawBitmap(srcBmp, 0, 0, mPaint);
        canvas.restore();
     	//混合过后，混合区域中有颜色的结果值是0xffff7f00
    }
1.16 PorterDuff.Mode.OVERLAY
/**
* Multiplies or screens the source and destination depending on the destination color.
*/ 
private void test01(Canvas canvas) {
        canvas.drawColor(Color.TRANSPARENT);
        RectF rectF = new RectF(0, 0, 350, 350);
        canvas.saveLayer(rectF, mPaint);
        canvas.drawColor(Color.parseColor("#FFff0000"));
        /**
         *  什么时候调用setXfermode方法很重要
         *  OVERLAY：
         *  [
         *  Sa+Da-Sa*Da,
         *  当2*Dc<Da时，2*Sc*Dc
         *  否则，Sa*Da-2(Da-Sc)(Sa-Dc)
         *  ]
         *  此时DST是画布新建的layer层
         */
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.OVERLAY));
        //0x7F00FF00
        canvas.drawBitmap(srcBmp, 0, 0, mPaint);
        canvas.restore();
     	//混合过后，混合区域中有颜色的结果值是0xffff0000
    }

二、源代码

package com.example.imagedemo;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.RectF;


import android.os.Build;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
import androidx.annotation.RequiresApi;

public class ViewDemo12 extends View {

    private int width = 350;
    private int height = 350;
    private Bitmap dstBmp;
    private Bitmap srcBmp;
    private Paint mPaint;

    public ViewDemo12(Context context, AttributeSet attrs) {
        super(context, attrs);
        dstBmp = makeDst(width, height);
        srcBmp = makeSrc(width, height);
        mPaint = new Paint();
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    }

    Paint paint = new Paint();

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
//        origin(canvas);
        test01(canvas);
        //test02(canvas);
    }

    private void origin(Canvas canvas) {
        //判断是否经过硬件加速
        //Log.e("View","==="+canvas.isHardwareAccelerated());
        //默认画布的颜色
        canvas.drawColor(Color.WHITE);
//        paint.setColor(Color.RED);
//        canvas.drawRect(0,0,400,100,paint);
        RectF rectF = new RectF(0, 0, 350, 350);
        canvas.saveLayer(rectF, mPaint);
        canvas.drawColor(Color.DKGRAY);
        //目标
        // canvas.drawBitmap(dstBmp, 0, 0, mPaint);
        /**
         *
         * DST：[Da, Dc]
         * SRC：[Sa, Sc]
         * DST_OUT：[Da * (1 - Sa), Dc * (1 - Sa)]
         * SRC_OVER：[Sa + (1 - Sa)*Da, Sc + (1 - Sa)*Dc]
         *
         *
         */
        Log.e("View==Blend", "1 PorterDuff.Mode.SRC");
        /**
         * 什么时候调用setXfermode方法很重要
         */
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST));
//        //源
        canvas.drawBitmap(srcBmp, 0, 0, mPaint);
//        //默认是SRC_OVER
//        Log.e("View==Blend","2 PorterDuff.Mode.DST_IN");
//        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));
        canvas.restore();
    }

    @RequiresApi(api = Build.VERSION_CODES.Q)
    private void test01(Canvas canvas) {
        canvas.drawColor(Color.TRANSPARENT);
        RectF rectF = new RectF(0, 0, 350, 350);
        canvas.saveLayer(rectF, mPaint);
        canvas.drawColor(Color.parseColor("#FFff0000"));
        /**
         *  什么时候调用setXfermode方法很重要
         *  DST：[Da, Dc]
         *  SRC：[Sa, Sc]
         *  SRC_OVER：[Sa + (1 - Sa)*Da, Rc = Sc + (1 - Sa)*Dc]
         *  DST_OVER：[Sa + (1 - Sa)*Da, Rc = Dc + (1 - Da)*Sc]
         *  SRC_IN：[Sa * Da, Sc * Da]
         *  DST_IN：[Sa * Da, Sa * Dc]
         *  SRC_OUT：[Sa * (1 - Da), Sc * (1 - Da)]
         *  DST_OUT：[Da * (1 - Sa), Dc * (1 - Sa)]
         *  SRC_ATOP：[Da, Sc * Da + (1 - Sa) * Dc]
         *  DST_ATOP：[Sa, Sa * Dc + Sc * (1 - Da)]
         *  XOR：[Sa + Da - 2 * Sa * Da, Sc * (1 - Da) + (1 - Sa) * Dc]
         *  DARKEN：[Sa + Da - Sa*Da, Sc*(1 - Da) + Dc*(1 - Sa) + min(Sc, Dc)]
         *  LIGHTEN：[Sa + Da - Sa*Da, Sc*(1 - Da) + Dc*(1 - Sa) + max(Sc, Dc)]
         *  MULTIPLY：[Sa * Da, Sc * Dc]
         *  SCREEN：[Sa + Da - Sa * Da, Sc + Dc - Sc * Dc],
         *  ADD：[max(0,min(Sa+Da,1)),max(0,min(Sc+Dc,1)]
         *  OVERLAY：
         *  [
         *  Sa+Da-Sa*Da,
         *  当2*Dc<Da时，2*Sc*Dc
         *  否则，Sa*Da-2(Da-Sc)(Sa-Dc)
         *  ]
         *  此时DST是画布新建的layer层
         */
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));
        //0x7F00FF00
        canvas.drawBitmap(srcBmp, 0, 0, mPaint);
        canvas.restore();
    }



    private void test02(Canvas canvas) {
        canvas.drawColor(Color.WHITE);
        RectF rectF = new RectF(0, 0, 350, 350);
        canvas.saveLayer(rectF, mPaint);
        canvas.drawColor(Color.DKGRAY);

        //目标
        canvas.drawBitmap(dstBmp, 0, 0, mPaint);
        /**
         *
         * DST：[Da, Dc]
         */
        /**
         * 什么时候调用setXfermode方法很重要
         */
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));
        canvas.drawBitmap(srcBmp, 0, 0, mPaint);

        mPaint.setXfermode(null);
        canvas.restore();
    }

    static Bitmap makeDst(int w, int h) {
        Bitmap bm = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
        Canvas c = new Canvas(bm);
        Paint p = new Paint(Paint.ANTI_ALIAS_FLAG);

        p.setColor(0xFFFF0000);
        c.drawOval(new RectF(20, 20, 100, 100), p);
        return bm;
    }

    static Bitmap makeSrc(int w, int h) {
        Bitmap bm = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
        Canvas c = new Canvas(bm);
        Paint p = new Paint(Paint.ANTI_ALIAS_FLAG);

        p.setColor(0x7F00FF00);
        c.drawRect(0, 0, 250, 250, p);
        return bm;
    }

}
Android进阶之路 - 背景阴影、阴影背景
Android、前端、小程序、后端
07-05 4587
不知道你是不是也经常听到这些话：你这个没有阴影效果；你这个阴影太浓了；你这个阴影太粗了；你这个阴影太实了；你这个阴影颜色也不对，你这个阴影.. 在正式开发中，临近上线前有个环节叫UI验收（产品验收在其前后均可），主要查看开发效果与设计图是否统一，当然很多UI可能也会临时在做修改... 话回最初，在验收环节中经常会提出关于阴影的问题，可以说是不胜其烦，正好最近有一些时间，特意记录一下我已知的阴影实现
PorterDuff.Mode及Xfermode详解
wuyou1336的博客
02-08 1707
在android SDK Paint类中有一个很重要的方法setXfermode（源码如上），这个方法用于设置图像的过渡模式，所谓过渡是指图像的饱和度、颜色值等参数的计算结果的图像表现。在SDK中Xfermode有三个子类：AvoidXfermode, PixelXorXfermode和PorterDuffXfermode，前两个类在API 16被遗弃了，而且不是本文的主题内容，所以这里不作介
Android PorterDuff.Mode
weixin_34358092的博客
08-17 152
  1.PorterDuff.Mode.CLEAR所绘制不会提交到画布上。2.PorterDuff.Mode.SRC显示上层绘制图片3.PorterDuff.Mode.DST显示下层绘制图片4.PorterDuff.Mode.SRC_OVER正常绘制显示，上下层绘制叠盖。5.PorterDuff.Mode.DST_OVER上下层都显示。下层居上显示。6.PorterDuff.Mode.SRC...
Android自定义View系列：PorterDuff.Mode
Vincent的博客
03-06 4427
文章目录1 PorterDuff.Mode的作用和背景2 PorterDuff.Mode的颜色策略2.1 Alpha合成2.1.1 1 PorterDuff.Mode的作用和背景 PorterDuff.Mode 是用来指定两个图像共同绘制时的颜色策略的。它是一个枚举，不同的Mode可以指定不同的策略。颜色策略的意思，就是说把源图像绘制到目标图像处时应该怎样确定二者结合后的颜色。 PorterDuf...
Android图形处理--PorterDuff.Mode那些事儿
HardWorkingAnt的博客
09-20 5150
我们在绘制图形图像的时候经常会用到 PorterDuff.Mode，它对我们绘制图形有很大的帮助，如果我们对它不甚了解甚至根本不理解，那会是很麻烦的事情，我这篇博客就是来给大家介绍一下 PorterDuff.Mode。1、基本介绍在介绍 PorterDuff.Mode 之前，我们首先要了解一下 Xfermode。Xfermode 被许多人称为过渡模式，就是指图像的饱和度、颜色值等参数的计算结果的图像
【Android学习笔记一】OpenCV4Android配置
谈笑轩
06-30 1261
导言：本文是对OpenCV for Android的配置详细过程的展示，并且为在此过程中的一些坑总结整理可行的解决方案，这些解决方案大多来自网络，感谢各位大手。本文最后讲实现在Android手机上运行OpenCV的人脸识别。一、创建一个支持NDK的Android程序二、进行OpenCV库的导入和环境的配置...
Android学习笔记之高仿微信界面实现
小新的专栏
04-10 1526
还是万恶的大作业，由于之前的侧滑搞得逻辑太复杂，控件之间相互干扰太多，所以准备弃用侧滑，改用fragment来做，这样不管是在逻辑上还是之后的维护上都会有很大的提升。当然，弊端还是有的，一是没有侧滑看起来那么炫，二是。。长得太tm像微信了，因为就是仿照微信做的（别打脸）。这里感谢imooc的hyman老师，就是在他的视频教学下我学会了做这样的界面。      撤了一堆没用的，现在开始正题吧，首先
Android橡皮擦与画笔的demo_涂鸦绘画.zip
09-11
在Android开发中，创建一个橡皮擦与画笔的涂鸦绘画应用是一项常见的任务，它涉及到用户交互...通过这个项目，开发者不仅可以学习到基础的Android编程技巧，还能了解到图形渲染和动画原理，为开发更复杂的应用奠定基础。
Android性能优化 _ 帧动画OOM？优化帧动画之SurfaceView逐帧解析
m0_64319166的博客
11-18 279
ImageView ivFrameAnim = ((ImageView) findViewById(R.id.frame_anim)); ivFrameAnim.setImageDrawable(drawable); drawable.start(); 有没有什么办法让帧动画的数据逐帧加载，而不是一次性全部加载到内存？SurfaceView就提供了这种能力。 SurfaceView 屏幕的显示机制和帧动画类似，也是一帧一帧的连环画，只不过刷新频率很高，感觉像连续的。为了显示一帧，需要经历计算和渲染两个过程，
Android图像合成模式之PorterDuff.Mode
gongwq的博客
12-26 1382
本文转载自简书《各个击破搞明白PorterDuff.Mode》，链接地址如下：https://www.jianshu.com/p/d11892bbe055PorterDuff.Mode这个枚举变量主要用于Android中的图像合成PorterDuff.Mode是什么在android SDK Paint类中有一个很重要的方法setXfermode（源码如下）public Xfermode setXfe
Android学习使用PorterDuff.Mode
Alex老夫子的专栏
07-28 896
当用到canvas画图且有2层及以上的图层时，往往会用到PorterDuff.Mode，怎么使用的呢？ mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR)); 先来看下PorterDuffXfermode这个类，PorterDuff查词典是没这个名字的，看了大神的文章才知道原来这个是Tomas Proter和
Android[api]PorterDuff及Xfermode详解
u014346514的专栏
04-11 408
Android 颜色渲染(九)  PorterDuff及Xfermode详解     之前已经讲过了除ComposeShader之外Shader的全部子类, 在讲ComposeShader(组合渲染)之前,  由于构造ComposeShader需要 PorterDuffXfermode或者PorterDuff.Mode作为参数,所以在此先详细地了解下这两个类的作用,这对之后的绘图会有很大的帮
android PorterDuffXfermode、PorterDuff.Mode 使用
小码农大梦想
09-24 706
首先看一下效果图(来自ApiDemos/Graphics/XferModes) 从上面我们可以看到PorterDuff.Mode为枚举类,一共有16个枚举值: 1.PorterDuff.Mode.CLEAR     所绘制不会提交到画布上。 2.PorterDuff.Mode.SRC    显示上层绘制图片 3.PorterDuf
Android图像合成模式之PorterDuff
最新发布
2401_87167563的博客
09-18 428
【代码】Android图像合成模式之PorterDuff。
Android 使用PorterDuff.Mode.XOR自定义透明遮罩
Wait_For_Loading的博客
05-30 1336
在业务开发中很多场景都会遇到遮罩。今天使用 PorterDuffXfermode 的XOR模式来绘制一个中间透明的遮罩。 先上一张图看看效果 分析一下： 1：后面的背景是黑色 2：中间还有一个不规则的透明部分 使中间透明就需要使用到 PorterDuff.Mode.XOR 3：还有一个边框 以上如何实现的呢？下面上代码 一：首先继承View class MaskView @JvmOverloads constructor( context: Context, a...
Android 混合模式之 PorterDuffXfermode
leilifengxingmw的博客
06-22 2052
注意：在使用PorterDuffXfermode的时候，目标图像（DST）和图像（SRC）混合的操作要在一个新的图层上进行，否则当前的Canvas上的像素会影响混合操作。 @Override protected void onDraw(Canvas canvas) { //创建一个新的图层 int layerId = canvas.saveLayer(new RectF(), n...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值