心得:
1：如果已经有set之类的进行变换的方法了，那么后面不能再有set之类的进行变换的方法了，不然前面的set之类的进行变换的方法就没有效果了，这时必须用前乘矩阵或者后乘矩阵才能将效果叠加，并且set之类的进行变换的方法必须放在前乘或者后乘方法的前面才行，不然set方法放在前乘或后乘的方法后面，前乘或后乘的方法会失效。
2：前乘(pre)和后乘(post)的功能就是确定了执行顺序，比如
matrix.setRotate(45,bitmap.getWidth()/2,bitmap.getHeight()/2);
matrix.preScale(1,2);//就是先进行Scale，然后再进行Rotate；
再比如
matrix.preRotate(45,bitmap.getWidth()/2,bitmap.getHeight()/2);
matrix.postScale(1,2);//就是先进行Rotate，然后再进行Scale
示例代码如下：
public class MyView extends ImageView {
private Paint paint;
private Matrix matrix;
private Bitmap bitmap;
public MyView(Context context) {
super(context);
init();
}
public MyView(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
@NonNull
private void init() {
paint=new Paint();
paint.setStyle(Paint.Style.FILL);
matrix=new Matrix();
bitmap=BitmapFactory.decodeResource(getResources(), R.mipmap.ic_launcher);
matrix.setScale(1,2);
matrix.preRotate(45,bitmap.getWidth()/2,bitmap.getHeight()/2);
}
public MyView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
canvas.drawBitmap(bitmap,matrix,paint);
Log.d("MyView", "onDraw");
}
}
参考文章如下：
http://www.gcssloop.com/customview/Matrix_Method
-----------------------------------------------------------------------------------
android群英传中对Matrix的介绍
1：android中的ColorMatrix
android中的ColorMatrix是一个4*5的数字矩阵，它用来对图片的色彩进行处理，对于每个像素点，都有一个ColorMatrix用来保存颜色的RGBA值。
上图中：
第一行的abcde值用来决定新的颜色值中的R(红色)；
第二行的fghij值用来决定新的颜色值中的G(绿色)；
第三行的klmno值用来决定新的颜色值中的B(蓝色)；
第四行的pqrst值用来决定新的颜色值中的A(透明度)；
矩阵A中的第五列(ejot)分别决定每个分量中的offset，即偏移量。
初始化矩阵为
初始化矩阵的颜色是黑色的，示例代码如下所示：
colorMatrix = new ColorMatrix();
colorMatrix.set(new float[]{1, 0, 0, 0, 0,
0, 1, 0, 0, 0,
0, 0, 1, 0, 0,
0, 0, 0, 1, 0});
paint.setColorFilter(new ColorMatrixColorFilter(colorMatrix));//画出来的图形是黑色的
改变颜色值通常有两种方法，一种是直接改变颜色的offset，另一种是直接改变对应的RGBA值，示例代码如下：
1：改变偏移量
colorMatrix = new ColorMatrix();
colorMatrix.set(new float[]{1, 0, 0, 0, 100,
0, 1, 0, 0, 100,
0, 0, 1, 0, 0,
0, 0, 0, 1, 0});
paint.setColorFilter(new ColorMatrixColorFilter(colorMatrix));//画出来的图形是褐色的
2：改变颜色系数
colorMatrix = new ColorMatrix();
colorMatrix.set(new float[]{11, 10, 10, 10, 0,
10, 11, 10, 0, 0,
10, 10, 11, 0, 0,
10, 10, 0, 1, 0});
paint.setColorFilter(new ColorMatrixColorFilter(colorMatrix));//画出来的图形是红色的
ColorMatrix中设置图像的色调，android系统提供了setRotate()来帮助我们设置颜色的色调，其中该方法的第一个参数，系统分别使用0，1，2来代表red，green，blue三种颜色的处理；而第二个参数，就是需要处理的值。示例代码如下：
colorMatrix = new ColorMatrix();
colorMatrix.setRotate(0,45);
colorMatrix.setRotate(1,45);
colorMatrix.setRotate(2,45);//给RGB三种颜色分别设置了不同的色调值
paint.setColorFilter(new ColorMatrixColorFilter(colorMatrix));
ColorMatrix中设置图像的饱和度，android系统提供了setSaturation()来设置颜色的饱和度，参数即代表设置颜色的饱和度的值，当饱和度为0时，图像就变成灰度图像了。示例代码如下：
colorMatrix = new ColorMatrix();
colorMatrix.setSaturation(0);
paint.setColorFilter(new ColorMatrixColorFilter(colorMatrix));
ColorMatrix中设置图像的亮度，当三原色以相同的比例进行混合的时候，就会显示出白色，当亮度为0时，图像就会变为黑色。示例代码如下：
colorMatrix = new ColorMatrix();
colorMatrix.setScale(100,100,100,10);
paint.setColorFilter(new ColorMatrixColorFilter(colorMatrix));
除了单独使用上面三种方式来进行颜色效果的处理之外，android系统还封装了矩阵的乘法运算，它提供了postConcat()方法来将矩阵的作用效果混合，从而叠加处理效果。
常用图像颜色矩阵处理效果：
1：灰度效果
示例代码如下：
colorMatrix = new ColorMatrix();
colorMatrix.set(new float[]{0.33f, 0.59f, 0.11f, 0, 0,
0.33f, 0.59f, 0.11f, 0, 0,
0.33f, 0.59f, 0.11f, 0, 0,
0, 0, 0, 1, 0});
paint.setColorFilter(new ColorMatrixColorFilter(colorMatrix));
2：图像反转
3：怀旧效果
4：去色效果
5：高饱和度
像素点分析
在android中，系统提供了Bitmap.getPixels()方法来帮我们提取整个Bitmap中的像素点，并保存到一个数组中，方法原型如下：
public void getPixels(@ColorInt int[] pixels, int offset, int stride,
int x, int y, int width, int height)
pixels：接收位图颜色值得数组；
offset：写入到pixels[]中的第一个像素索引值；
stride：pixels[]中的行间距；
x：从位图中读取的第一个像素的x坐标值；
y：从位图中读取的第一个像素的y坐标值；
width：从每一行中读取的像素宽度；
height：读取的行数；
示例代码如下：
int[] ints=new int[bitmap.getWidth()*bitmap.getHeight()];
bitmap.getPixels(ints,0,bitmap.getWidth(),0,0,bitmap.getWidth(),bitmap.getHeight());
for (int i = 0; i < ints.length; i++) {//输出了每个像素点对应的RGB的值
Log.d("MyView", "Color.red(ints[i]):" + Color.red(ints[i]));
Log.d("MyView", "Color.green(ints[i]):" + Color.green(ints[i]));
Log.d("MyView", "Color.blue(ints[i]):" + Color.blue(ints[i]));
}
常用图像像素点处理效果：
1：底片效果，示例代码如下：
...
private Paint paint;
private Bitmap bitmap;
private Bitmap bitmap1;
private int[] ints;
private boolean is = false;
public MyView(Context context) {
super(context);
init();
}
public MyView(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
@NonNull
private void init() {
paint = new Paint();
paint.setStyle(Paint.Style.FILL);
bitmap = BitmapFactory.decodeResource(getResources(), R.mipmap.ic_launcher);
bitmap1 = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Bitmap.Config.ARGB_8888);
ints = new int[bitmap.getWidth() * bitmap.getHeight()];
new Thread() {
@Override
public void run() {
try {
Thread.sleep(3000);//这里让线程睡上3秒，不然线程中的逻辑执行的太快了，导致onDraw方法中的is一直为true
} catch (InterruptedException e) {
e.printStackTrace();
}
bitmap.getPixels(ints, 0, bitmap.getWidth(), 0, 0, bitmap.getWidth(), bitmap.getHeight());
for (int i = 0; i < ints.length; i++) {//输出了每个像素点对应的RGB的值
ints[i] = Color.argb(Color.alpha(ints[i]), 255 - Color.red(ints[i]),
255 - Color.green(ints[i]),
255 - Color.blue(ints[i]));
}
is = true;
postInvalidate();
}
}.start();
}
public MyView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
Log.d("MyView", "ondrawhehe:" + is);
if (is) {
Log.d("MyView", "ondraw:" + is);
bitmap1.setPixels(ints, 0, bitmap1.getWidth(), 0, 0, bitmap1.getWidth(), bitmap1.getHeight());
canvas.drawBitmap(bitmap1, 200, 200, paint);
}
}
}
/* 输出结果为：05-31 16:16:10.893 3097-3097/com.example.liang.arlvyou D/MyView: ondrawhehe:false
05-31 16:16:13.823 3097-3097/com.example.liang.arlvyou D/MyView: ondrawhehe:true
05-31 16:16:13.823 3097-3097/com.example.liang.arlvyou D/MyView: ondraw:true*/
...
2：老照片效果
示例代码如下：
...
for (int i = 0; i < ints.length; i++) {//输出了每个像素点对应的RGB的值
ints[i] = Color.argb(Color.alpha(ints[i]), (int) (0.393 * Color.red(ints[i]) + 0.769 * Color.green(ints[i]) + 0.189 * Color.blue(ints[i])),
(int) (0.349 * Color.red(ints[i]) + 0.686 * Color.green(ints[i]) + 0.168 * Color.blue(ints[i]))
, (int) (0.272 * Color.red(ints[i]) + 0.534 * Color.green(ints[i]) + 0.131 * Color.blue(ints[i])));
}
...
2：android中的变形矩阵Matrix
android的图形变换矩阵式一个3*3的矩阵，初始化矩阵如下图所示：
在图形变换矩阵中，同样是通过一个一维数组来模拟矩阵，并通过setValues()方法将一个一维数组转换为图形变换矩阵，代码如下所示；
matrix = new Matrix();
matrix.setValues(new float[]{2, 1, 0,
1, 2, 0,
0, 0, 1});
...
canvas.drawBitmap(bitmap, matrix, paint);
...
当然，与色彩矩阵一样，android系统同样提供了一些API来简化矩阵的运算，如下所示：
Matrix.setRotate()--旋转变换
Matrix.setTranslate()--平移变换
Matrix.setScale()--缩放变换
Matrix.setSkew()--错位变换
pre()和post()--提供矩阵的前乘和后乘运算
Matrix类的set方法会重置矩阵中的所有值，而pre和post方法不会，这两个方法常用来实现矩阵的混合作用。不过要注意的是，矩阵运算不满足交换律，所以矩阵乘法的前乘和后乘是两种不同的运算方式。
像素块分析
drawBitmapMesh()与操纵像素点来改变色彩的原理类似，只不过是把图像分成了一个个的小块，然后通过改变每一个图像块来修改整个图像。方法原型如下所示：
public void drawBitmapMesh(@NonNull Bitmap bitmap, int meshWidth, int meshHeight,
@NonNull float[] verts, int vertOffset, @Nullable int[] colors, int colorOffset,
@Nullable Paint paint)
bitmap：将要扭曲的图像；
meshWidth：需要的横向网格数目；
meshHeight：需要的纵向网格数目；
verts：网格交叉点坐标数组，最重要的一个参数，数组中的每两位用来保存一个交织点，第一个是横坐标，第二个是纵坐标；
vertOffset：verts数组中开始跳过的(x,y)坐标对的数目；
示例代码稍后上传：
public class CeShi extends AppCompatActivity {
private Bitmap bitmap;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(new MyView(this,R.mipmap.touxiang));
}
private class MyView extends View
{
//定义两个常量,这两个常量指定该图片横向,纵向上都被划分为20格
private final int WIDTH = 20;
private final int HEIGHT = 20;
//记录该图片上包含441个顶点
private final int COUNT = (WIDTH + 1) * (HEIGHT + 1);
//定义一个数组,记录Bitmap上的21*21个点的坐标
private final float[] verts = new float[COUNT * 2];
//定义一个数组,记录Bitmap上的21*21个点经过扭曲后的坐标
//对图片扭曲的关键就是修改该数组里元素的值
private final float[] orig = new float[COUNT * 2];
public MyView(Context context, int drawableId) {
super(context);
setFocusable(true);
//根据指定资源加载图片
bitmap = BitmapFactory.decodeResource(getResources(), drawableId);
//获取图片宽度和高度
float bitmapWidth = bitmap.getWidth();
float bitmapHeight = bitmap.getHeight();
int index = 0;
for(int y = 0; y <= HEIGHT; y++)
{
float fy = bitmapHeight * y / HEIGHT;
for(int x = 0 ; x <= WIDTH; x++)
{
float fx = bitmapWidth * x / WIDTH;
//初始化orig,verts数组
//初始化,orig,verts两个数组均匀地保存了21 * 21个点的x,y坐标
orig[index * 2 + 0] = verts[index * 2 + 0] = fx;
orig[index * 2 + 1] = verts[index * 2 + 1] = fy;
index += 1;
}
}
//设置背景色
setBackgroundColor(Color.WHITE);
}
protected void onDraw(Canvas canvas)
{
//对bitmap按verts数组进行扭曲
//从第一个点(由第5个参数0控制)开始扭曲
canvas.drawBitmapMesh(bitmap, WIDTH, HEIGHT, verts, 0, null, 0, null);
}
//工具方法,用于根据触摸事件的位置计算verts数组里各元素的值
private void warp(float cx, float cy)
{
for(int i = 0; i < COUNT * 2; i += 2)
{
float dx = cx - orig[i + 0];
float dy = cy - orig[i + 1];
float dd = dx * dx + dy * dy;
//计算每个坐标点与当前点(cx,cy)之间的距离
float d = (float)Math.sqrt(dd);
//计算扭曲度，距离当前点(cx,cy)越远，扭曲度越小
float pull = 80000 / ((float)(dd * d));
//对verts数组(保存bitmap 上21 * 21个点经过扭曲后的坐标)重新赋值
if(pull >= 1)
{
verts[i + 0] = cx;
verts[i + 1] = cy;
}
else
{
//控制各顶点向触摸事件发生点偏移
verts[i + 0] = orig[i + 0] + dx * pull;
verts[i + 1] = orig[i + 1] + dx * pull;
}
}
//通知View组件重绘
invalidate();
}
public boolean onTouchEvent(MotionEvent event)
{
//调用warp方法根据触摸屏事件的坐标点来扭曲verts数组
warp(event.getX() , event.getY());
return true;
}
}
}
