Matrix的数学原理

在Android中，如果你用Matrix进行过图像处理，那么一定知道Matrix这个类。Android中的Matrix是一个3 x 3的矩阵，其内容如下：

Matrix的对图像的处理可分为四类基本变换：

Translate 平移变换

Rotate 旋转变换

Scale 缩放变换

Skew 错切变换

从字面上理解，矩阵中的MSCALE用于处理缩放变换，MSKEW用于处理错切变换，MTRANS用于处理平移变换，MPERSP用于处理透视变换。实际中当然不能完全按照字面上的说法去理解Matrix。同时，在Android的文档中，未见到用Matrix进行透视变换的相关说明，所以本文也不讨论这方面的问题。

针对每种变换，Android提供了pre、set和post三种操作方式。其中

set用于设置Matrix中的值。

pre是先乘，因为矩阵的乘法不满足交换律，因此先乘、后乘必须要严格区分。先乘相当于矩阵运算中的右乘。

post是后乘，因为矩阵的乘法不满足交换律，因此先乘、后乘必须要严格区分。后乘相当于矩阵运算中的左乘。

除平移变换(Translate)外，旋转变换(Rotate)、缩放变换(Scale)和错切变换(Skew)都可以围绕一个中心点来进行，如果不指定，在默认情况下是围绕(0, 0)来进行相应的变换的。

下面我们来看看四种变换的具体情形。由于所有的图形都是有点组成，因此我们只需要考察一个点相关变换即可。

一、平移变换

假定有一个点的坐标是，将其移动到，再假定在x轴和y轴方向移动的大小分别为：

如下图所示：

不难知道：

如果用矩阵来表示的话，就可以写成：

二、旋转变换

2.1 围绕坐标原点旋转：

假定有一个点，相对坐标原点顺时针旋转后的情形，同时假定P点离坐标原点的距离为r，如下图：

那么，

如果用矩阵，就可以表示为：

2.2 围绕某个点旋转

如果是围绕某个点顺时针旋转，那么可以用矩阵表示为：

可以化为：

很显然，

是将坐标原点移动到点后，的新坐标。

是将上一步变换后的，围绕新的坐标原点顺时针旋转。

经过上一步旋转变换后，再将坐标原点移回到原来的坐标原点。

所以，围绕某一点进行旋转变换，可以分成3个步骤，即首先将坐标原点移至该点，然后围绕新的坐标原点进行旋转变换，再然后将坐标原点移回到原先的坐标原点。

三、缩放变换

理论上而言，一个点是不存在什么缩放变换的，但考虑到所有图像都是由点组成，因此，如果图像在x轴和y轴方向分别放大k1和k2倍的话，那么图像中的所有点的x坐标和y坐标均会分别放大k1和k2倍，即

用矩阵表示就是：

缩放变换比较好理解，就不多说了。

四、错切变换

错切变换(skew)在数学上又称为Shear mapping(可译为“剪切变换”)或者Transvection(缩并)，它是一种比较特殊的线性变换。错切变换的效果就是让所有点的x坐标(或者y坐标)保持不变，而对应的y坐标(或者x坐标)则按比例发生平移，且平移的大小和该点到x轴(或y轴)的垂直距离成正比。错切变换，属于等面积变换，即一个形状在错切变换的前后，其面积是相等的。

比如下图，各点的y坐标保持不变，但其x坐标则按比例发生了平移。这种情况将水平错切。

下图各点的x坐标保持不变，但其y坐标则按比例发生了平移。这种情况叫垂直错切。

假定一个点经过错切变换后得到，对于水平错切而言，应该有如下关系：

用矩阵表示就是：

扩展到3 x 3的矩阵就是下面这样的形式：

同理，对于垂直错切，可以有：

在数学上严格的错切变换就是上面这样的。在Android中除了有上面说到的情况外，还可以同时进行水平、垂直错切，那么形式上就是：

五、对称变换

除了上面讲到的4中基本变换外，事实上，我们还可以利用Matrix，进行对称变换。所谓对称变换，就是经过变化后的图像和原图像是关于某个对称轴是对称的。比如，某点经过对称变换后得到，

如果对称轴是x轴，难么，

用矩阵表示就是：

如果对称轴是y轴，那么，

用矩阵表示就是：

如果对称轴是y = x，如图：

那么，

很容易可以解得：

用矩阵表示就是：

同样的道理，如果对称轴是y = -x，那么用矩阵表示就是：

特殊地，如果对称轴是y = kx，如下图：

那么，

很容易可解得：

用矩阵表示就是：

当k = 0时，即y = 0，也就是对称轴为x轴的情况；当k趋于无穷大时，即x = 0，也就是对称轴为y轴的情况；当k =1时，即y = x，也就是对称轴为y = x的情况；当k = -1时，即y = -x，也就是对称轴为y = -x的情况。不难验证，这和我们前面说到的4中具体情况是相吻合的。

如果对称轴是y = kx + b这样的情况，只需要在上面的基础上增加两次平移变换即可，即先将坐标原点移动到(0, b)，然后做上面的关于y = kx的对称变换，再然后将坐标原点移回到原来的坐标原点即可。用矩阵表示大致是这样的：

需要特别注意：在实际编程中，我们知道屏幕的y坐标的正向和数学中y坐标的正向刚好是相反的，所以在数学上y = x和屏幕上的y = -x才是真正的同一个东西，反之亦然。也就是说，如果要使图片在屏幕上看起来像按照数学意义上y = x对称，那么需使用这种转换：

要使图片在屏幕上看起来像按照数学意义上y = -x对称，那么需使用这种转换：

关于对称轴为y = kx 或y = kx + b的情况，同样需要考虑这方面的问题。

第二部分代码验证

在第一部分中讲到的各种图像变换的验证代码如下，一共列出了10种情况。如果要验证其中的某一种情况，只需将相应的代码反注释即可。试验中用到的图片：

其尺寸为162 x 251。

<span style="font-size:13px;"></span><pre name="code" class="java">package com.pat.testtransformmatrix;  

import android.app.Activity;

import android.content.Context;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.graphics.Canvas;

import android.graphics.Matrix;

import android.os.Bundle;

import android.util.Log;

import android.view.MotionEvent;

import android.view.View;

import android.view.Window;

import android.view.WindowManager;

import android.view.View.OnTouchListener;

import android.widget.ImageView;  

public class TestTransformMatrixActivity extends Activity

implements

OnTouchListener

{

    private TransformMatrixView view;

    @Override

    public void onCreate(Bundle savedInstanceState)

    {

        super.onCreate(savedInstanceState);

        requestWindowFeature(Window.FEATURE_NO_TITLE);

        this.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);  

        view = new TransformMatrixView(this);

        view.setScaleType(ImageView.ScaleType.MATRIX);

        view.setOnTouchListener(this);  

        setContentView(view);

    }  

    class TransformMatrixView extends ImageView

    {

        private Bitmap bitmap;

        private Matrix matrix;

        public TransformMatrixView(Context context)

        {

            super(context);

            bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.sophie);

            matrix = new Matrix();

        }  

        @Override

        protected void onDraw(Canvas canvas)

        {

            // 画出原图像

            canvas.drawBitmap(bitmap, 0, 0, null);

            // 画出变换后的图像

            canvas.drawBitmap(bitmap, matrix, null);

            super.onDraw(canvas);

        }  

        @Override

        public void setImageMatrix(Matrix matrix)

        {

            this.matrix.set(matrix);

            super.setImageMatrix(matrix);

        }  

        public Bitmap getImageBitmap()

        {

            return bitmap;

        }

    }  

    public boolean onTouch(View v, MotionEvent e)

    {

        if(e.getAction() == MotionEvent.ACTION_UP)

        {

            Matrix matrix = new Matrix();

            // 输出图像的宽度和高度(162 x 251)

            Log.e("TestTransformMatrixActivity", "image size: width x height = " +  view.getImageBitmap().getWidth() + " x " + view.getImageBitmap().getHeight());

            // 1. 平移

            matrix.postTranslate(view.getImageBitmap().getWidth(), view.getImageBitmap().getHeight());

            // 在x方向平移view.getImageBitmap().getWidth()，在y轴方向view.getImageBitmap().getHeight()

            view.setImageMatrix(matrix);  

            // 下面的代码是为了查看matrix中的元素

            float[] matrixValues = new float[9];

            matrix.getValues(matrixValues);

            for(int i = 0; i < 3; ++i)

            {

                String temp = new String();

                for(int j = 0; j < 3; ++j)

                {

                    temp += matrixValues[3 * i + j ] + "\t";

                }

                Log.e("TestTransformMatrixActivity", temp);

            }  

//          // 2. 旋转(围绕图像的中心点)

//          matrix.setRotate(45f, view.getImageBitmap().getWidth() / 2f, view.getImageBitmap().getHeight() / 2f);

//

//          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

//          matrix.postTranslate(view.getImageBitmap().getWidth() * 1.5f, 0f);

//          view.setImageMatrix(matrix);

//

//          // 下面的代码是为了查看matrix中的元素

//          float[] matrixValues = new float[9];

//          matrix.getValues(matrixValues);

//          for(int i = 0; i < 3; ++i)

//          {

//              String temp = new String();

//              for(int j = 0; j < 3; ++j)

//              {

//                  temp += matrixValues[3 * i + j ] + "\t";

//              }

//              Log.e("TestTransformMatrixActivity", temp);

//          }  

//          // 3. 旋转(围绕坐标原点) + 平移(效果同2)

//          matrix.setRotate(45f);

//          matrix.preTranslate(-1f * view.getImageBitmap().getWidth() / 2f, -1f * view.getImageBitmap().getHeight() / 2f);

//          matrix.postTranslate((float)view.getImageBitmap().getWidth() / 2f, (float)view.getImageBitmap().getHeight() / 2f);

//

//          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

//          matrix.postTranslate((float)view.getImageBitmap().getWidth() * 1.5f, 0f);

//          view.setImageMatrix(matrix);

//

//          // 下面的代码是为了查看matrix中的元素

//          float[] matrixValues = new float[9];

//          matrix.getValues(matrixValues);

//          for(int i = 0; i < 3; ++i)

//          {

//              String temp = new String();

//              for(int j = 0; j < 3; ++j)

//              {

//                  temp += matrixValues[3 * i + j ] + "\t";

//              }

//              Log.e("TestTransformMatrixActivity", temp);

//          }             

//          // 4. 缩放

//          matrix.setScale(2f, 2f);

//          // 下面的代码是为了查看matrix中的元素

//          float[] matrixValues = new float[9];

//          matrix.getValues(matrixValues);

//          for(int i = 0; i < 3; ++i)

//          {

//              String temp = new String();

//              for(int j = 0; j < 3; ++j)

//              {

//                  temp += matrixValues[3 * i + j ] + "\t";

//              }

//              Log.e("TestTransformMatrixActivity", temp);

//          }

//

//          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

//          matrix.postTranslate(view.getImageBitmap().getWidth(), view.getImageBitmap().getHeight());

//          view.setImageMatrix(matrix);

//

//          // 下面的代码是为了查看matrix中的元素

//          matrixValues = new float[9];

//          matrix.getValues(matrixValues);

//          for(int i = 0; i < 3; ++i)

//          {

//              String temp = new String();

//              for(int j = 0; j < 3; ++j)

//              {

//                  temp += matrixValues[3 * i + j ] + "\t";

//              }

//              Log.e("TestTransformMatrixActivity", temp);

//          }  

//          // 5. 错切 - 水平

//          matrix.setSkew(0.5f, 0f);

//          // 下面的代码是为了查看matrix中的元素

//          float[] matrixValues = new float[9];

//          matrix.getValues(matrixValues);

//          for(int i = 0; i < 3; ++i)

//          {

//              String temp = new String();

//              for(int j = 0; j < 3; ++j)

//              {

//                  temp += matrixValues[3 * i + j ] + "\t";

//              }

//              Log.e("TestTransformMatrixActivity", temp);

//          }

//

//          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

//          matrix.postTranslate(view.getImageBitmap().getWidth(), 0f);

//          view.setImageMatrix(matrix);

//

//          // 下面的代码是为了查看matrix中的元素

//          matrixValues = new float[9];

//          matrix.getValues(matrixValues);

//          for(int i = 0; i < 3; ++i)

//          {

//              String temp = new String();

//              for(int j = 0; j < 3; ++j)

//              {

//                  temp += matrixValues[3 * i + j ] + "\t";

//              }

//              Log.e("TestTransformMatrixActivity", temp);

//          }  

//          // 6. 错切 - 垂直

//          matrix.setSkew(0f, 0.5f);

//          // 下面的代码是为了查看matrix中的元素

//          float[] matrixValues = new float[9];

//          matrix.getValues(matrixValues);

//          for(int i = 0; i < 3; ++i)

//          {

//              String temp = new String();

//              for(int j = 0; j < 3; ++j)

//              {

//                  temp += matrixValues[3 * i + j ] + "\t";

//              }

//              Log.e("TestTransformMatrixActivity", temp);

//          }

//

//          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

//          matrix.postTranslate(0f, view.getImageBitmap().getHeight());

//          view.setImageMatrix(matrix);

//

//          // 下面的代码是为了查看matrix中的元素

//          matrixValues = new float[9];

//          matrix.getValues(matrixValues);

//          for(int i = 0; i < 3; ++i)

//          {

//              String temp = new String();

//              for(int j = 0; j < 3; ++j)

//              {

//                  temp += matrixValues[3 * i + j ] + "\t";

//              }

//              Log.e("TestTransformMatrixActivity", temp);

//          }             

//          7. 错切 - 水平 + 垂直

//          matrix.setSkew(0.5f, 0.5f);

//          // 下面的代码是为了查看matrix中的元素

//          float[] matrixValues = new float[9];

//          matrix.getValues(matrixValues);

//          for(int i = 0; i < 3; ++i)

//          {

//              String temp = new String();

//              for(int j = 0; j < 3; ++j)

//              {

//                  temp += matrixValues[3 * i + j ] + "\t";

//              }

//              Log.e("TestTransformMatrixActivity", temp);

//          }

//

//          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

//          matrix.postTranslate(0f, view.getImageBitmap().getHeight());

//          view.setImageMatrix(matrix);

//

//          // 下面的代码是为了查看matrix中的元素

//          matrixValues = new float[9];

//          matrix.getValues(matrixValues);

//          for(int i = 0; i < 3; ++i)

//          {

//              String temp = new String();

//              for(int j = 0; j < 3; ++j)

//              {

//                  temp += matrixValues[3 * i + j ] + "\t";

//              }

//              Log.e("TestTransformMatrixActivity", temp);

//          }  

//          // 8. 对称 (水平对称)

//          float matrix_values[] = {1f, 0f, 0f, 0f, -1f, 0f, 0f, 0f, 1f};

//          matrix.setValues(matrix_values);

//          // 下面的代码是为了查看matrix中的元素

//          float[] matrixValues = new float[9];

//          matrix.getValues(matrixValues);

//          for(int i = 0; i < 3; ++i)

//          {

//              String temp = new String();

//              for(int j = 0; j < 3; ++j)

//              {

//                  temp += matrixValues[3 * i + j ] + "\t";

//              }

//              Log.e("TestTransformMatrixActivity", temp);

//          }

//

//          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

//          matrix.postTranslate(0f, view.getImageBitmap().getHeight() * 2f);

//          view.setImageMatrix(matrix);

//

//          // 下面的代码是为了查看matrix中的元素

//          matrixValues = new float[9];

//          matrix.getValues(matrixValues);

//          for(int i = 0; i < 3; ++i)

//          {

//              String temp = new String();

//              for(int j = 0; j < 3; ++j)

//              {

//                  temp += matrixValues[3 * i + j ] + "\t";

//              }

//              Log.e("TestTransformMatrixActivity", temp);

//          }             

//          // 9. 对称 - 垂直

//          float matrix_values[] = {-1f, 0f, 0f, 0f, 1f, 0f, 0f, 0f, 1f};

//          matrix.setValues(matrix_values);

//          // 下面的代码是为了查看matrix中的元素

//          float[] matrixValues = new float[9];

//          matrix.getValues(matrixValues);

//          for(int i = 0; i < 3; ++i)

//          {

//              String temp = new String();

//              for(int j = 0; j < 3; ++j)

//              {

//                  temp += matrixValues[3 * i + j ] + "\t";

//              }

//              Log.e("TestTransformMatrixActivity", temp);

//          }

//

//          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

//          matrix.postTranslate(view.getImageBitmap().getWidth() * 2f, 0f);

//          view.setImageMatrix(matrix);

//

//          // 下面的代码是为了查看matrix中的元素

//          matrixValues = new float[9];

//          matrix.getValues(matrixValues);

//          for(int i = 0; i < 3; ++i)

//          {

//              String temp = new String();

//              for(int j = 0; j < 3; ++j)

//              {

//                  temp += matrixValues[3 * i + j ] + "\t";

//              }

//              Log.e("TestTransformMatrixActivity", temp);

//          }  

//          // 10. 对称(对称轴为直线y = x)

//          float matrix_values[] = {0f, -1f, 0f, -1f, 0f, 0f, 0f, 0f, 1f};

//          matrix.setValues(matrix_values);

//          // 下面的代码是为了查看matrix中的元素

//          float[] matrixValues = new float[9];

//          matrix.getValues(matrixValues);

//          for(int i = 0; i < 3; ++i)

//          {

//              String temp = new String();

//              for(int j = 0; j < 3; ++j)

//              {

//                  temp += matrixValues[3 * i + j ] + "\t";

//              }

//              Log.e("TestTransformMatrixActivity", temp);

//          }

//

//          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

//          matrix.postTranslate(view.getImageBitmap().getHeight() + view.getImageBitmap().getWidth(),

//                  view.getImageBitmap().getHeight() + view.getImageBitmap().getWidth());

//          view.setImageMatrix(matrix);

//

//          // 下面的代码是为了查看matrix中的元素

//          matrixValues = new float[9];

//          matrix.getValues(matrixValues);

//          for(int i = 0; i < 3; ++i)

//          {

//              String temp = new String();

//              for(int j = 0; j < 3; ++j)

//              {

//                  temp += matrixValues[3 * i + j ] + "\t";

//              }

//              Log.e("TestTransformMatrixActivity", temp);

//          }  

            view.invalidate();

        }

        return true;

    }

}</pre><br>

<br>

<p><span style="font-size:13px"> </span></p>

<p><span style="font-size:13px">下面给出上述代码中，各种变换的具体结果及其对应的相关变换矩阵</span></p>

<p><span style="font-size:13px">1.     平移</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_1321712352qQRu.gif" alt=""></span></p>

<p><span style="font-size:13px">输出的结果：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_13217123565Wwz.gif" alt=""></span></p>

<p><span style="font-size:13px">请对照第一部分中的“一、平移变换”所讲的情形，考察上述矩阵的正确性。</span></p>

<p><span style="font-size:13px"> </span></p>

<p><span style="font-size:13px">2.     旋转(围绕图像的中心点)</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_132171250556xp.gif" alt=""></span></p>

<p><span style="font-size:13px">输出的结果：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_1321712512Yj1i.gif" alt=""></span></p>

<p><span style="font-size:13px">它实际上是</span></p>

<p><span style="font-size:13px">matrix.setRotate(45f,view.getImageBitmap().getWidth() / 2f, view.getImageBitmap().getHeight() / 2f);</span></p>

<p><span style="font-size:13px">matrix.postTranslate(view.getImageBitmap().getWidth()* 1.5f, 0f);</span></p>

<p><span style="font-size:13px">这两条语句综合作用的结果。根据第一部分中“二、旋转变换”里面关于围绕某点旋转的公式，</span></p>

<p><span style="font-size:13px">matrix.setRotate(45f,view.getImageBitmap().getWidth() / 2f, view.getImageBitmap().getHeight() / 2f);</span></p>

<p><span style="font-size:13px">所产生的转换矩阵就是：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_1321712644I54M.gif" alt=""></span></p>

<p><span style="font-size:13px">而matrix.postTranslate(view.getImageBitmap().getWidth()* 1.5f, 0f);的意思就是在上述矩阵的左边再乘以下面的矩阵：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_13217126508k4V.gif" alt=""></span></p>

<p><span style="font-size:13px">关于post是左乘这一点，我们在前面的理论部分曾经提及过，后面我们还会专门讨论这个问题。</span></p>

<p><span style="font-size:13px"> </span></p>

<p><span style="font-size:13px">所以它实际上就是：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_13217126608wdT.gif" alt=""></span></p>

<p><span style="font-size:13px">出去计算上的精度误差，我们可以看到我们计算出来的结果，和程序直接输出的结果是一致的。</span></p>

<p><span style="font-size:13px"> </span></p>

<p><span style="font-size:13px">3.     旋转(围绕坐标原点旋转，在加上两次平移，效果同2)</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_132171250556xp.gif" alt=""></span></p>

<p><span style="font-size:13px">根据第一部分中“二、旋转变换”里面关于围绕某点旋转的解释，不难知道：</span></p>

<p><span style="font-size:13px">matrix.setRotate(45f,view.getImageBitmap().getWidth() / 2f, view.getImageBitmap().getHeight() / 2f);</span></p>

<p><span style="font-size:13px">等价于</span></p>

<p><span style="font-size:13px">matrix.setRotate(45f);</span></p>

<p><span style="font-size:13px">matrix.preTranslate(-1f* view.getImageBitmap().getWidth() / 2f, -1f *view.getImageBitmap().getHeight() / 2f);</span></p>

<p><span style="font-size:13px">matrix.postTranslate((<strong>float</strong>)view.getImageBitmap().getWidth()/ 2f, (<strong>float</strong>)view.getImageBitmap().getHeight() / 2f);</span></p>

<p><span style="font-size:13px"> </span></p>

<p><span style="font-size:13px">其中matrix.setRotate(45f)对应的矩阵是：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_1321712949GjN7.gif" alt=""></span></p>

<p><span style="font-size:13px">matrix.preTranslate(-1f* view.getImageBitmap().getWidth() / 2f, -1f * view.getImageBitmap().getHeight()/ 2f)对应的矩阵是：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_1321712956BNj8.gif" alt=""></span></p>

<p><span style="font-size:13px">由于是preTranslate，是先乘，也就是右乘，即它应该出现在matrix.setRotate(45f)所对应矩阵的右侧。</span></p>

<p><span style="font-size:13px"> </span></p>

<p><span style="font-size:13px">matrix.postTranslate((<strong>float</strong>)view.getImageBitmap().getWidth()/ 2f, (<strong>float</strong>)view.getImageBitmap().getHeight() / 2f)对应的矩阵是：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_1321712963iNO1.gif" alt=""></span></p>

<p><span style="font-size:13px">这次由于是postTranslate，是后乘，也就是左乘，即它应该出现在matrix.setRotate(45f)所对应矩阵的左侧。</span></p>

<p><span style="font-size:13px"> </span></p>

<p><span style="font-size:13px">所以综合起来，</span></p>

<p><span style="font-size:13px">matrix.setRotate(45f);</span></p>

<p><span style="font-size:13px">matrix.preTranslate(-1f* view.getImageBitmap().getWidth() / 2f, -1f *view.getImageBitmap().getHeight() / 2f);</span></p>

<p><span style="font-size:13px">matrix.postTranslate((<strong>float</strong>)view.getImageBitmap().getWidth()/ 2f, (<strong>float</strong>)view.getImageBitmap().getHeight() / 2f);</span></p>

<p><span style="font-size:13px">对应的矩阵就是：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_1321713055HOOt.gif" alt=""></span></p>

<p><span style="font-size:13px">这和下面这个矩阵(围绕图像中心顺时针旋转45度)其实是一样的：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_1321713100VIOz.gif" alt=""></span></p>

<p><span style="font-size:13px">因此，此处变换后的图像和2中变换后的图像时一样的。</span></p>

<p><span style="font-size:13px"> </span></p>

<p><span style="font-size:13px">4.     缩放变换</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_1321713185yKS7.gif" alt=""></span></p>

<p><span style="font-size:13px">程序所输出的两个矩阵分别是：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_13217131941R24.gif" alt=""></span></p>

<p><span style="font-size:13px">其中第二个矩阵，其实是下面两个矩阵相乘的结果：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_1321713201VRxs.gif" alt=""> </span></p>

<p><span style="font-size:13px">大家可以对照第一部分中的“三、缩放变换”和“一、平移变换”说法，自行验证结果。</span></p>

<p><span style="font-size:13px"> </span></p>

<p><span style="font-size:13px">5.     错切变换(水平错切)</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_132171330766G0.gif" alt=""></span></p>

<p><span style="font-size:13px">代码所输出的两个矩阵分别是：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_1321713314Dk69.gif" alt=""></span></p>

<p><span style="font-size:13px">其中，第二个矩阵其实是下面两个矩阵相乘的结果：</span></p>

<p><span style="font-size:13px"> <img src="http://hi.csdn.net/attachment/201111/19/0_1321713322PeML.gif" alt=""></span></p>

<p><span style="font-size:13px">大家可以对照第一部分中的“四、错切变换”和“一、平移变换”的相关说法，自行验证结果。</span></p>

<p><span style="font-size:13px"> </span></p>

<p><span style="font-size:13px">6.     错切变换(垂直错切)</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_1321713502Akg2.gif" alt=""></span></p>

<p><span style="font-size:13px">代码所输出的两个矩阵分别是：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_1321713509Hz7p.gif" alt=""></span></p>

<p><span style="font-size:13px">其中，第二个矩阵其实是下面两个矩阵相乘的结果：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_1321713516TUvx.gif" alt=""></span></p>

<p><span style="font-size:13px">大家可以对照第一部分中的“四、错切变换”和“一、平移变换”的相关说法，自行验证结果。</span></p>

<p><span style="font-size:13px"> </span></p>

<p><span style="font-size:13px">7.     错切变换(水平+垂直错切)</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_1321713655Qsij.gif" alt=""></span></p>

<p><span style="font-size:13px">代码所输出的两个矩阵分别是：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_13217136824kKR.gif" alt=""></span></p>

<p><span style="font-size:13px">其中，后者是下面两个矩阵相乘的结果：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_13217136931vl4.gif" alt=""></span></p>

<p><span style="font-size:13px">大家可以对照第一部分中的“四、错切变换”和“一、平移变换”的相关说法，自行验证结果。</span></p>

<p><span style="font-size:13px"> </span></p>

<p><span style="font-size:13px">8.     对称变换(水平对称)</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_13217141232rJI.gif" alt=""></span></p>

<p><span style="font-size:13px">代码所输出的两个各矩阵分别是：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_1321714133P0ha.gif" alt=""></span></p>

<p><span style="font-size:13px">其中，后者是下面两个矩阵相乘的结果：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_13217141417Bi3.gif" alt=""> </span></p>

<p><span style="font-size:13px">大家可以对照第一部分中的“五、对称变换”和“一、平移变换”的相关说法，自行验证结果。</span></p>

<p><span style="font-size:13px"> </span></p>

<p><span style="font-size:13px">9.     对称变换(垂直对称)</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_1321714261NN3V.gif" alt=""></span></p>

<p><span style="font-size:13px">代码所输出的两个矩阵分别是：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_1321714269Kqs4.gif" alt=""></span></p>

<p><span style="font-size:13px">其中，后者是下面两个矩阵相乘的结果：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_1321714276ai2f.gif" alt=""> </span></p>

<p><span style="font-size:13px">大家可以对照第一部分中的“五、对称变换”和“一、平移变换”的相关说法，自行验证结果。</span></p>

<p><span style="font-size:13px"> </span></p>

<p><span style="font-size:13px">10.   对称变换(对称轴为直线<em>y = x</em>)</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_13217144950030.gif" alt=""></span></p>

<p><span style="font-size:13px">代码所输出的两个矩阵分别是：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_13217145038hN8.gif" alt=""></span></p>

<p><span style="font-size:13px">其中，后者是下面两个矩阵相乘的结果：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_1321714509sBN4.gif" alt=""> </span></p>

<p><span style="font-size:13px">大家可以对照第一部分中的“五、对称变换”和“一、平移变换”的相关说法，自行验证结果。</span></p>

<p><span style="font-size:13px"> </span></p>

<p><span style="font-size:13px">11.   关于先乘和后乘的问题</span></p>

<p><span style="font-size:13px">由于矩阵的乘法运算不满足交换律，我们在前面曾经多次提及先乘、后乘的问题，即先乘就是矩阵运算中右乘，后乘就是矩阵运算中的左乘。其实先乘、后乘的概念是针对变换操作的时间先后而言的，左乘、右乘是针对矩阵运算的左右位置而言的。以第一部分“二、旋转变换”中围绕某点旋转的情况为例：</span></p>

<p><span style="font-size:13px"><img src="http://hi.csdn.net/attachment/201111/19/0_1321714645396z.gif" alt=""> </span></p>

<p><span style="font-size:13px">越靠近原图像中像素的矩阵，越先乘，越远离原图像中像素的矩阵，越后乘。事实上，图像处理时，矩阵的运算是从右边往左边方向进行运算的。这就形成了越在右边的矩阵(右乘)，越先运算(先乘)，反之亦然。</span></p>

<p><span style="font-size:13px"> </span></p>

<p><span style="font-size:13px">当然，在实际中，如果首先指定了一个matrix，比如我们先setRotate(<img src="http://hi.csdn.net/attachment/201111/19/0_1321714654C9Xc.gif" alt="">)，即指定了上面变换矩阵中，中间的那个矩阵，那么后续的矩阵到底是pre还是post运算，都是相对这个中间矩阵而言的。</span></p>

<p><span style="font-size:13px"> </span></p>

<span style="font-size:13px">所有这些，其实都是很自然的事情。</span>

<pre></pre>

<pre></pre>

<pre></pre>

<pre></pre>

Android 之 Matrix（转）的更多相关文章

Android笔记——Matrix
转自:http://www.cnblogs.com/qiengo/archive/2012/06/30/2570874.html#translate Matrix的数学原理在Android中,如果你 ...
android.graphics.Matrix
Matrix类包含了一个3x3的矩阵用来改变坐标,它没有一个构造器来初始化它里边的内容,所以创建实例后需要调用reset()方法生成一个标准matrix,或者调用set..一类的函数,比如setTra ...
Android学习记录（9）—Android之Matrix的用法
Matrix ,中文里叫矩阵,高等数学里有介绍,在图像处理方面,主要是用于平面的缩放.平移.旋转等操作. 首先介绍一下矩阵运算.加法和减法就不用说了,对应位相加就好.图像处理,主要用到的是乘法 .下面 ...
[Android] 使用Matrix矩阵类对图像进行缩放、旋转、对照度、亮度处理
前一篇文章讲述了Android拍照.截图.保存并显示在ImageView控件中,该篇文章继续讲述Android图像处理技术,主要操作包含:通过打开相冊里的图片,使用Matrix对图像进行缩放. ...
Matrix: android 中的Matrix (android.graphics.Matrix) (转)
本篇博客主要讲解一下如何处理对一个Bitmap对象进行处理,包括:缩放.旋转.位移.倾斜等.在最后将以一个简单的Demo来演示图片特效的变换. 1. Matrix概述对于一个图片变换的处理,需要Ma ...
Android中Matrix的pre post set方法理解(转载来源：Linux社区作者：zjmdp)
虽说以前学习过线性代数和图形学原理,但是在实际中碰到matrix还是疑惑了好一阵子,今天通过向同事请教终于找到一点门路,特总结如下: Matrix主要用于对平面进行缩放,平移,旋转以及倾斜操作,为简化 ...
Android中图像变换Matrix的原理、代码验证和应用(二)
第二部分代码验证在第一部分中讲到的各种图像变换的验证代码如下,一共列出了10种情况.如果要验证其中的某一种情况,只需将相应的代码反注释即可.试验中用到的图片: 其尺寸为162 x 251. 每种变 ...
Android中图像变换Matrix的原理、代码验证和应用(三)
第三部分应用在这一部分,我们会将前面两部分所了解到的内容和Android手势结合起来,利用各种不同的手势对图像进行平移.缩放和旋转,前面两项都是在实践中经常需要用到的功能,后一项据说苹果也是最近才 ...
Android Matrix
转自 :http://www.cnblogs.com/qiengo/archive/2012/06/30/2570874.html#code Matrix的数学原理平移变换旋转变换缩放变换错切 ...

随机推荐

Harvard数据库课程CS 265: Research Topics in Database Systems
CS 265: Research Topics in Database Systems Announcements Quiz 3 will be posted. Good luck! Quiz 2 h ...
Google Code Jam 2014 资格赛：Problem D. Deceitful War
This problem is the hardest problem to understand in this round. If you are new to Code Jam, you sho ...
【Mac系统】istatmenus6.20下载以及激活
下载地址:https://pan.baidu.com/s/1-2-yw2NnOlGJ46D536t5uQ iStat Menus 的激活密码: Email: 982092332@qq.com SN: ...
IEnumerable, IEnumerator接口
IEnumerable接口 // Exposes the enumerator, which supports a simple iteration over a non-generic collec ...
unity 常用的几种相机跟随
固定相机跟随这种相机有一个参考对象,它会保持与该参考对象固定的位置,跟随改参考对象发生移动 using UnityEngine; using System.Collections; public c ...
JS中setInterval、setTimeout不能传递带参数的函数的解决办法
在JS中无论是setTimeout还是setInterval,在使用函数名作为调用句柄时都不能带参数,而在许多场合必须要带参数,这就需要想方法解决. 一.采用字符串形式:——(缺陷)参数不能被周期性改 ...
Apache启动失败（Windows 无法在本地计算机启动Apache2.2）
该问题产生的原因有很多,这里就说说我遇到的问题: 这个问题是突然遇到的,启动的时候连日志都没有产生,最后是通过window的日志中发现问题所在的,如图所示: 发现是目录错了.其他问题也可以通过该日志找 ...
3354 [IOI2005]河流
题目描述几乎整个Byteland王国都被森林和河流所覆盖.小点的河汇聚到一起,形成了稍大点的河.就这样,所有的河水都汇聚并流进了一条大河,最后这条大河流进了大海.这条大河的入海口处有一个村庄——名叫 ...
HDFS上传机制
[Android]彻底去除Google AdMob广告
应用中包含广告是能够理解的,但经常造成用户误点,或者广告切换时造成下载流量,就有点让人不舒服了. 以下就以Google AdMob广告为例,看怎样彻底去除他. 先分析一下Google AdMob的工作 ...

Android 之 Matrix（转）

Android Matrix

Android 之 Matrix（转）的更多相关文章

随机推荐

热门专题