Android Matrix的代码验证和应用

最新推荐文章于 2021-10-04 18:02:29 发布
最新推荐文章于 2021-10-04 18:02:29 发布
阅读量506 收藏
点赞数
分类专栏： 自定义View


Matrix介绍 : Android Matrix的用法总结（链接：ttp://blog.csdn.net/jdsjlzx/article/details/52741445）


代码验证

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


尺寸为162 x 251

每种变换的结果，请见代码之后的说明。

[java] view plain copy
print ?
  1. package com.pat.testtransformmatrix;  
  2. import android.app.Activity;  
  3. import android.content.Context;  
  4. import android.graphics.Bitmap;  
  5. import android.graphics.BitmapFactory;  
  6. import android.graphics.Canvas;  
  7. import android.graphics.Matrix;  
  8. import android.os.Bundle;  
  9. import android.util.Log;  
  10. import android.view.MotionEvent;  
  11. import android.view.View;  
  12. import android.view.Window;  
  13. import android.view.WindowManager;  
  14. import android.view.View.OnTouchListener;  
  15. import android.widget.ImageView;  
  16.   
  17. public class TestTransformMatrixActivity extends Activity implements OnTouchListener  
  18. {  
  19.     private TransformMatrixView view;  
  20.     @Override  
  21.     public void onCreate(Bundle savedInstanceState)  
  22.     {  
  23.       super.onCreate(savedInstanceState);  
  24.       requestWindowFeature(Window.FEATURE_NO_TITLE);  
  25.       getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,  
  26.       WindowManager.LayoutParams.FLAG_FULLSCREEN);  
  27.   
  28.         view = new TransformMatrixView(this);  
  29.         view.setScaleType(ImageView.ScaleType.MATRIX);  
  30.         view.setOnTouchListener(this);  
  31.   
  32.         setContentView(view);  
  33.     }  
  34.   
  35.     class TransformMatrixView extends ImageView  
  36.     {  
  37.         private Bitmap bitmap;  
  38.         private Matrix matrix;  
  39.         public TransformMatrixView(Context context){  
  40.             super(context);  
  41.             bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.sophie);  
  42.             matrix = new Matrix();  
  43.         }  
  44.   
  45.         @Override  
  46.         protected void onDraw(Canvas canvas){  
  47.             // 画出原图像  
  48.             canvas.drawBitmap(bitmap, 0, 0, null);  
  49.             // 画出变换后的图像  
  50.             canvas.drawBitmap(bitmap, matrix, null);  
  51.             super.onDraw(canvas);  
  52.         }  
  53.   
  54.         @Override  
  55.         public void setImageMatrix(Matrix matrix){  
  56.             this.matrix.set(matrix);  
  57.             super.setImageMatrix(matrix);  
  58.         }  
  59.   
  60.         public Bitmap getImageBitmap(){  
  61.             return bitmap;  
  62.         }  
  63.     }  
  64.   
  65.     public boolean onTouch(View v, MotionEvent e){  
  66.         if(e.getAction() == MotionEvent.ACTION_UP){  
  67.             Matrix matrix = new Matrix();  
  68.             // 输出图像的宽度和高度(162 x 251)  
  69.             Log.e(”TestTransformMatrixActivity”, “image size: width x height = ” +  view.getImageBitmap().getWidth() + “ x ” + view.getImageBitmap().getHeight());  
  70.             // 1. 平移  
  71.             matrix.postTranslate(view.getImageBitmap().getWidth(), view.getImageBitmap().getHeight());  
  72.             // 在x方向平移view.getImageBitmap().getWidth()，在y轴方向view.getImageBitmap().getHeight()  
  73.             view.setImageMatrix(matrix);  
  74.   
  75.             // 下面的代码是为了查看matrix中的元素  
  76.             float[] matrixValues = new float[9];  
  77.             matrix.getValues(matrixValues);  
  78.             for(int i = 0; i < 3; ++i){  
  79.                 String temp = new String();  
  80.                 for(int j = 0; j < 3; ++j){  
  81.                     temp += matrixValues[3 * i + j ] + “\t”;  
  82.                 }  
  83.                 Log.e(”TestTransformMatrixActivity”, temp);  
  84.             }  
  85.   
  86. //          // 2. 旋转(围绕图像的中心点)  
  87. //          matrix.setRotate(45f, view.getImageBitmap().getWidth() / 2f, view.getImageBitmap().getHeight() / 2f);  
  88. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠  
  89. //          matrix.postTranslate(view.getImageBitmap().getWidth() * 1.5f, 0f);  
  90. //          view.setImageMatrix(matrix);  
  91.   
  92. //          // 3. 旋转(围绕坐标原点) + 平移(效果同2)  
  93. //          matrix.setRotate(45f);  
  94. //          matrix.preTranslate(-1f * view.getImageBitmap().getWidth() / 2f, -1f * view.getImageBitmap().getHeight() / 2f);  
  95. //          matrix.postTranslate((float)view.getImageBitmap().getWidth() / 2f, (float)view.getImageBitmap().getHeight() / 2f);  
  96. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠  
  97. //          matrix.postTranslate((float)view.getImageBitmap().getWidth() * 1.5f, 0f);  
  98. //          view.setImageMatrix(matrix);      
  99.   
  100. //          // 4. 缩放  
  101. //          matrix.setScale(2f, 2f);  
  102. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠  
  103. //          matrix.postTranslate(view.getImageBitmap().getWidth(), view.getImageBitmap().getHeight());  
  104. //          view.setImageMatrix(matrix);  
  105.   
  106. //          // 5. 错切 - 水平  
  107. //          matrix.setSkew(0.5f, 0f);  
  108. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠           
  109. //          matrix.postTranslate(view.getImageBitmap().getWidth(), 0f);  
  110. //          view.setImageMatrix(matrix);  
  111.   
  112. //          // 6. 错切 - 垂直  
  113. //          matrix.setSkew(0f, 0.5f);  
  114. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠               
  115. //          matrix.postTranslate(0f, view.getImageBitmap().getHeight());  
  116. //          view.setImageMatrix(matrix);  
  117.   
  118. //          7. 错切 - 水平 + 垂直  
  119. //          matrix.setSkew(0.5f, 0.5f);  
  120. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠               
  121. //          matrix.postTranslate(0f, view.getImageBitmap().getHeight());  
  122. //          view.setImageMatrix(matrix);  
  123.   
  124. //          // 8. 对称 (水平对称)  
  125. //          float matrix_values[] = {1f, 0f, 0f, 0f, -1f, 0f, 0f, 0f, 1f};  
  126. //          matrix.setValues(matrix_values);  
  127. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠   
  128. //          matrix.postTranslate(0f, view.getImageBitmap().getHeight() * 2f);  
  129. //          view.setImageMatrix(matrix);  
  130.   
  131. //          // 9. 对称 - 垂直  
  132. //          float matrix_values[] = {-1f, 0f, 0f, 0f, 1f, 0f, 0f, 0f, 1f};  
  133. //          matrix.setValues(matrix_values);  
  134. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠   
  135. //          matrix.postTranslate(view.getImageBitmap().getWidth() * 2f, 0f);  
  136. //          view.setImageMatrix(matrix);  
  137.   
  138. //          // 10. 对称(对称轴为直线y = x)  
  139. //          float matrix_values[] = {0f, -1f, 0f, -1f, 0f, 0f, 0f, 0f, 1f};  
  140. //          matrix.setValues(matrix_values);  
  141. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠               
  142. //          matrix.postTranslate(view.getImageBitmap().getHeight() + view.getImageBitmap().getWidth(),   
  143. //                  view.getImageBitmap().getHeight() + view.getImageBitmap().getWidth());  
  144. //          view.setImageMatrix(matrix);  
  145.   
  146.             view.invalidate();  
  147.         }  
  148.         return true;  
  149.     }  
  150. }  
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);
      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);

//          // 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);    

//          // 4. 缩放
//          matrix.setScale(2f, 2f);
//          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠
//          matrix.postTranslate(view.getImageBitmap().getWidth(), view.getImageBitmap().getHeight());
//          view.setImageMatrix(matrix);

//          // 5. 错切 - 水平
//          matrix.setSkew(0.5f, 0f);
//          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠         
//          matrix.postTranslate(view.getImageBitmap().getWidth(), 0f);
//          view.setImageMatrix(matrix);

//          // 6. 错切 - 垂直
//          matrix.setSkew(0f, 0.5f);
//          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠             
//          matrix.postTranslate(0f, view.getImageBitmap().getHeight());
//          view.setImageMatrix(matrix);

//          7. 错切 - 水平 + 垂直
//          matrix.setSkew(0.5f, 0.5f);
//          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠             
//          matrix.postTranslate(0f, view.getImageBitmap().getHeight());
//          view.setImageMatrix(matrix);

//          // 8. 对称 (水平对称)
//          float matrix_values[] = {1f, 0f, 0f, 0f, -1f, 0f, 0f, 0f, 1f};
//          matrix.setValues(matrix_values);
//          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠 
//          matrix.postTranslate(0f, view.getImageBitmap().getHeight() * 2f);
//          view.setImageMatrix(matrix);

//          // 9. 对称 - 垂直
//          float matrix_values[] = {-1f, 0f, 0f, 0f, 1f, 0f, 0f, 0f, 1f};
//          matrix.setValues(matrix_values);
//          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠 
//          matrix.postTranslate(view.getImageBitmap().getWidth() * 2f, 0f);
//          view.setImageMatrix(matrix);

//          // 10. 对称(对称轴为直线y = x)
//          float matrix_values[] = {0f, -1f, 0f, -1f, 0f, 0f, 0f, 0f, 1f};
//          matrix.setValues(matrix_values);
//          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠             
//          matrix.postTranslate(view.getImageBitmap().getHeight() + view.getImageBitmap().getWidth(), 
//                  view.getImageBitmap().getHeight() + view.getImageBitmap().getWidth());
//          view.setImageMatrix(matrix);

            view.invalidate();
        }
        return true;
    }
}


下面给出上述代码中，各种变换的具体结果及其对应的相关变换矩阵

  • 平移 
     
    输出的结果： 
     
    请对照第一部分中的“一、平移变换”所讲的情形，考察上述矩阵的正确性。
  • 旋转(围绕图像的中心点) 
     
    输出的结果： 
     
    它实际上是 
    matrix.setRotate(45f,view.getImageBitmap().getWidth() / 2f, view.getImageBitmap().getHeight() / 2f); 
    matrix.postTranslate(view.getImageBitmap().getWidth()* 1.5f, 0f); 
    这两条语句综合作用的结果。根据第一部分中“二、旋转变换”里面关于围绕某点旋转的公式， 
    matrix.setRotate(45f,view.getImageBitmap().getWidth() / 2f, view.getImageBitmap().getHeight() / 2f); 
    所产生的转换矩阵就是： 
     
    而matrix.postTranslate(view.getImageBitmap().getWidth()* 1.5f, 0f);的意思就是在上述矩阵的左边再乘以下面的矩阵： 
     
    关于post是左乘这一点，我们在前面的理论部分曾经提及过，后面我们还会专门讨论这个问题。

所以它实际上就是： 
 
出去计算上的精度误差，我们可以看到我们计算出来的结果，和程序直接输出的结果是一致的。

  • 旋转(围绕坐标原点旋转，在加上两次平移，效果同2) 
     
    根据第一部分中“二、旋转变换”里面关于围绕某点旋转的解释，不难知道： 
    matrix.setRotate(45f,view.getImageBitmap().getWidth() / 2f, view.getImageBitmap().getHeight() / 2f); 
    等价于 
    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.setRotate(45f)对应的矩阵是： 
 
matrix.preTranslate(-1f* view.getImageBitmap().getWidth() / 2f, -1f * view.getImageBitmap().getHeight()/ 2f)对应的矩阵是： 
 
由于是preTranslate，是先乘，也就是右乘，即它应该出现在matrix.setRotate(45f)所对应矩阵的右侧。

matrix.postTranslate((float)view.getImageBitmap().getWidth()/ 2f, (float)view.getImageBitmap().getHeight() / 2f)对应的矩阵是： 
 
这次由于是postTranslate，是后乘，也就是左乘，即它应该出现在matrix.setRotate(45f)所对应矩阵的左侧。

所以综合起来， 
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); 
对应的矩阵就是： 
 
这和下面这个矩阵(围绕图像中心顺时针旋转45度)其实是一样的： 
 
因此，此处变换后的图像和2中变换后的图像时一样的。

  • 缩放变换 
     
    程序所输出的两个矩阵分别是： 
     
    其中第二个矩阵，其实是下面两个矩阵相乘的结果： 
     
    大家可以对照第一部分中的“三、缩放变换”和“一、平移变换”说法，自行验证结果。
  • 错切变换(水平错切) 
     
    代码所输出的两个矩阵分别是： 
     
    其中，第二个矩阵其实是下面两个矩阵相乘的结果： 
     
    大家可以对照第一部分中的“四、错切变换”和“一、平移变换”的相关说法，自行验证结果。
  • 错切变换(垂直错切) 
     
    代码所输出的两个矩阵分别是： 
     
    其中，第二个矩阵其实是下面两个矩阵相乘的结果： 
     
    大家可以对照第一部分中的“四、错切变换”和“一、平移变换”的相关说法，自行验证结果。
  • 错切变换(水平+垂直错切) 
     
    代码所输出的两个矩阵分别是： 
     
    其中，后者是下面两个矩阵相乘的结果： 
     
    大家可以对照第一部分中的“四、错切变换”和“一、平移变换”的相关说法，自行验证结果。
  • 对称变换(水平对称) 
     
    代码所输出的两个各矩阵分别是： 
     
    其中，后者是下面两个矩阵相乘的结果： 
     
    大家可以对照第一部分中的“五、对称变换”和“一、平移变换”的相关说法，自行验证结果。
  • 对称变换(垂直对称) 
     
    代码所输出的两个矩阵分别是： 
     
    其中，后者是下面两个矩阵相乘的结果： 
     
    大家可以对照第一部分中的“五、对称变换”和“一、平移变换”的相关说法，自行验证结果。
  • 对称变换(对称轴为直线) 
     
    代码所输出的两个矩阵分别是： 
     
    其中，后者是下面两个矩阵相乘的结果： 
     
    大家可以对照第一部分中的“五、对称变换”和“一、平移变换”的相关说法，自行验证结果。
  • 关于先乘和后乘的问题 
    由于矩阵的乘法运算不满足交换律，我们在前面曾经多次提及先乘、后乘的问题，即先乘就是矩阵运算中右乘，后乘就是矩阵运算中的左乘。其实先乘、后乘的概念是针对变换操作的时间先后而言的，左乘、右乘是针对矩阵运算的左右位置而言的。以第一部分“二、旋转变换”中围绕某点旋转的情况为例： 
     
    越靠近原图像中像素的矩阵，越先乘，越远离原图像中像素的矩阵，越后乘。事实上，图像处理时，矩阵的运算是从右边往左边方向进行运算的。这就形成了越在右边的矩阵(右乘)，越先运算(先乘)，反之亦然。

当然，在实际中，如果首先指定了一个matrix，比如我们先setRotate()，即指定了上面变换矩阵中，中间的那个矩阵，那么后续的矩阵到底是pre还是post运算，都是相对这个中间矩阵而言的。

所有这些，其实都是很自然的事情。

实际应用

下面我们结合之前的介绍和 Android 手势结合起来，利用各种不同的手势对图像进行平移、缩放和旋转。

1. 在AndroidManifest.xml中增加权限： <uses-permissionandroid:name= “android.permission.VIBRATE” />


2.自定义PatImageView

[java] view plain copy
print ?
  1. package com.pat.imageview;  
  2.   
  3. import android.app.Service;  
  4. import android.content.Context;  
  5. import android.graphics.Matrix;  
  6. import android.graphics.PointF;  
  7. import android.os.Vibrator;  
  8. import android.util.FloatMath;  
  9. import android.view.GestureDetector;  
  10. import android.view.MotionEvent;  
  11. import android.view.View;  
  12. import android.widget.ImageView;  
  13.   
  14. public class PatImageView extends ImageView  
  15. {  
  16.     private Matrix matrix;  
  17.     private Matrix savedMatrix;  
  18.       
  19.     private boolean long_touch = false;  
  20.     private static int NONE = 0;  
  21.     private static int DRAG = 1;    // 拖动  
  22.     private static int ZOOM = 2;    // 缩放  
  23.     private static int ROTA = 3;    // 旋转  
  24.     private int mode = NONE;  
  25.       
  26.     private PointF startPoint;  
  27.     private PointF middlePoint;  
  28.       
  29.     private float oldDistance;  
  30.     private float oldAngle;  
  31.   
  32.     private Vibrator vibrator;  
  33.       
  34.     private GestureDetector gdetector;  
  35.       
  36.     public PatImageView(final Context context)  
  37.     {  
  38.         super(context);  
  39.   
  40.         matrix = new Matrix();  
  41.         savedMatrix = new Matrix();  
  42.           
  43.         matrix.setTranslate(0f, 0f);  
  44.         setScaleType(ScaleType.MATRIX);  
  45.         setImageMatrix(matrix);  
  46.           
  47.         startPoint = new PointF();  
  48.         middlePoint = new PointF();  
  49.           
  50.         oldDistance = 1f;  
  51.           
  52.         gdetector = new GestureDetector(context, new GestureDetector.OnGestureListener()  
  53.         {  
  54.             @Override  
  55.             public boolean onSingleTapUp(MotionEvent e)  
  56.             {  
  57.                 return true;  
  58.             }  
  59.               
  60.             @Override  
  61.             public void onShowPress(MotionEvent e)  
  62.             {  
  63.             }  
  64.               
  65.             @Override  
  66.             public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY)  
  67.             {  
  68.                 return true;  
  69.             }  
  70.               
  71.             @Override  
  72.             public void onLongPress(MotionEvent e)  
  73.             {  
  74.                 long_touch = true;  
  75.                 vibrator = (Vibrator) context.getSystemService(Service.VIBRATOR_SERVICE);  
  76.                 // 振动50ms，提示后续的操作将是旋转图片，而非缩放图片  
  77.                 vibrator.vibrate(50);  
  78.             }  
  79.               
  80.             @Override  
  81.             public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY)  
  82.             {  
  83.                 return true;  
  84.             }  
  85.               
  86.             @Override  
  87.             public boolean onDown(MotionEvent e)  
  88.             {  
  89.                 return true;  
  90.             }  
  91.         });  
  92.           
  93.         setOnTouchListener(new OnTouchListener()  
  94.         {  
  95.             public boolean onTouch(View view, MotionEvent event)  
  96.             {  
  97.                 switch(event.getAction() & MotionEvent.ACTION_MASK)  
  98.                 {  
  99.                 case MotionEvent.ACTION_DOWN:           // 第一个手指touch  
  100.                     savedMatrix.set(matrix);  
  101.                     startPoint.set(event.getX(), event.getY());  
  102.                     mode = DRAG;  
  103.                     long_touch = false;  
  104.                     break;  
  105.                 case MotionEvent.ACTION_POINTER_DOWN:   // 第二个手指touch  
  106.                     oldDistance = getDistance(event);   // 计算第二个手指touch时，两指之间的距离  
  107.                     oldAngle = getDegree(event);        // 计算第二个手指touch时，两指所形成的直线和x轴的角度  
  108.                     if(oldDistance > 10f)  
  109.                     {  
  110.                         savedMatrix.set(matrix);  
  111.                         middlePoint = midPoint(event);  
  112.                         if(!long_touch)  
  113.                         {  
  114.                             mode = ZOOM;  
  115.                         }  
  116.                         else  
  117.                         {  
  118.                             mode = ROTA;  
  119.                         }  
  120.                     }  
  121.                     break;  
  122.                 case MotionEvent.ACTION_UP:  
  123.                     mode = NONE;  
  124.                     break;  
  125.                 case MotionEvent.ACTION_POINTER_UP:  
  126.                     mode = NONE;  
  127.                     break;  
  128.                 case MotionEvent.ACTION_MOVE:  
  129.                     if(vibrator != null)    vibrator.cancel();  
  130.                     if(mode == DRAG)  
  131.                     {  
  132.                         matrix.set(savedMatrix);  
  133.                         matrix.postTranslate(event.getX() - startPoint.x, event.getY() - startPoint.y);  
  134.                     }  
  135.                       
  136.                     if(mode == ZOOM)  
  137.                     {  
  138.                         float newDistance = getDistance(event);  
  139.                           
  140.                         if(newDistance > 10f)  
  141.                         {  
  142.                             matrix.set(savedMatrix);  
  143.                             float scale = newDistance / oldDistance;  
  144.                             matrix.postScale(scale, scale, middlePoint.x, middlePoint.y);  
  145.                         }  
  146.                     }  
  147.                       
  148.                     if(mode == ROTA)  
  149.                     {  
  150.                         float newAngle = getDegree(event);  
  151.                         matrix.set(savedMatrix);  
  152.                         float degrees = newAngle - oldAngle;  
  153.                         matrix.postRotate(degrees, middlePoint.x, middlePoint.y);  
  154.                     }  
  155.                     break;  
  156.                 }  
  157.                 setImageMatrix(matrix);  
  158.                 invalidate();  
  159.                 gdetector.onTouchEvent(event);  
  160.                 return true;  
  161.             }  
  162.         });  
  163.     }  
  164.   
  165.     // 计算两个手指之间的距离  
  166.         private float getDistance(MotionEvent event)  
  167.         {  
  168.             float x = event.getX(0) - event.getX(1);  
  169.             float y = event.getY(0) - event.getY(1);  
  170.             return FloatMath.sqrt(x * x + y * y);  
  171.         }  
  172.       
  173.         // 计算两个手指所形成的直线和x轴的角度  
  174.         private float getDegree(MotionEvent event)  
  175.         {  
  176.             return (float)(Math.atan((event.getY(1) - event.getY(0)) / (event.getX(1) - event.getX(0))) * 180f);  
  177.         }  
  178.   
  179.         // 计算两个手指之间，中间点的坐标  
  180.         private PointF midPoint( MotionEvent event)  
  181.         {  
  182.             PointF point = new PointF();  
  183.             float x = event.getX(0) + event.getX(1);  
  184.             float y = event.getY(0) + event.getY(1);  
  185.             point.set(x / 2, y / 2);  
  186.           
  187.             return point;  
  188.         }  
  189. }  
package com.pat.imageview;

import android.app.Service;
import android.content.Context;
import android.graphics.Matrix;
import android.graphics.PointF;
import android.os.Vibrator;
import android.util.FloatMath;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.View;
import android.widget.ImageView;

public class PatImageView extends ImageView
{
    private Matrix matrix;
    private Matrix savedMatrix;

    private boolean long_touch = false;
    private static int NONE = 0;
    private static int DRAG = 1;    // 拖动
    private static int ZOOM = 2;    // 缩放
    private static int ROTA = 3;    // 旋转
    private int mode = NONE;

    private PointF startPoint;
    private PointF middlePoint;

    private float oldDistance;
    private float oldAngle;

    private Vibrator vibrator;

    private GestureDetector gdetector;

    public PatImageView(final Context context)
    {
        super(context);

        matrix = new Matrix();
        savedMatrix = new Matrix();

        matrix.setTranslate(0f, 0f);
        setScaleType(ScaleType.MATRIX);
        setImageMatrix(matrix);

        startPoint = new PointF();
        middlePoint = new PointF();

        oldDistance = 1f;

        gdetector = new GestureDetector(context, new GestureDetector.OnGestureListener()
        {
            @Override
            public boolean onSingleTapUp(MotionEvent e)
            {
                return true;
            }

            @Override
            public void onShowPress(MotionEvent e)
            {
            }

            @Override
            public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY)
            {
                return true;
            }

            @Override
            public void onLongPress(MotionEvent e)
            {
                long_touch = true;
                vibrator = (Vibrator) context.getSystemService(Service.VIBRATOR_SERVICE);
                // 振动50ms，提示后续的操作将是旋转图片，而非缩放图片
                vibrator.vibrate(50);
            }

            @Override
            public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY)
            {
                return true;
            }

            @Override
            public boolean onDown(MotionEvent e)
            {
                return true;
            }
        });

        setOnTouchListener(new OnTouchListener()
        {
            public boolean onTouch(View view, MotionEvent event)
            {
                switch(event.getAction() & MotionEvent.ACTION_MASK)
                {
                case MotionEvent.ACTION_DOWN:           // 第一个手指touch
                    savedMatrix.set(matrix);
                    startPoint.set(event.getX(), event.getY());
                    mode = DRAG;
                    long_touch = false;
                    break;
                case MotionEvent.ACTION_POINTER_DOWN:   // 第二个手指touch
                    oldDistance = getDistance(event);   // 计算第二个手指touch时，两指之间的距离
                    oldAngle = getDegree(event);        // 计算第二个手指touch时，两指所形成的直线和x轴的角度
                    if(oldDistance > 10f)
                    {
                        savedMatrix.set(matrix);
                        middlePoint = midPoint(event);
                        if(!long_touch)
                        {
                            mode = ZOOM;
                        }
                        else
                        {
                            mode = ROTA;
                        }
                    }
                    break;
                case MotionEvent.ACTION_UP:
                    mode = NONE;
                    break;
                case MotionEvent.ACTION_POINTER_UP:
                    mode = NONE;
                    break;
                case MotionEvent.ACTION_MOVE:
                    if(vibrator != null)    vibrator.cancel();
                    if(mode == DRAG)
                    {
                        matrix.set(savedMatrix);
                        matrix.postTranslate(event.getX() - startPoint.x, event.getY() - startPoint.y);
                    }

                    if(mode == ZOOM)
                    {
                        float newDistance = getDistance(event);

                        if(newDistance > 10f)
                        {
                            matrix.set(savedMatrix);
                            float scale = newDistance / oldDistance;
                            matrix.postScale(scale, scale, middlePoint.x, middlePoint.y);
                        }
                    }

                    if(mode == ROTA)
                    {
                        float newAngle = getDegree(event);
                        matrix.set(savedMatrix);
                        float degrees = newAngle - oldAngle;
                        matrix.postRotate(degrees, middlePoint.x, middlePoint.y);
                    }
                    break;
                }
                setImageMatrix(matrix);
                invalidate();
                gdetector.onTouchEvent(event);
                return true;
            }
        });
    }

    // 计算两个手指之间的距离
        private float getDistance(MotionEvent event)
        {
            float x = event.getX(0) - event.getX(1);
            float y = event.getY(0) - event.getY(1);
            return FloatMath.sqrt(x * x + y * y);
        }

        // 计算两个手指所形成的直线和x轴的角度
        private float getDegree(MotionEvent event)
        {
            return (float)(Math.atan((event.getY(1) - event.getY(0)) / (event.getX(1) - event.getX(0))) * 180f);
        }

        // 计算两个手指之间，中间点的坐标
        private PointF midPoint( MotionEvent event)
        {
            PointF point = new PointF();
            float x = event.getX(0) + event.getX(1);
            float y = event.getY(0) + event.getY(1);
            point.set(x / 2, y / 2);

            return point;
        }
}

PatImageViewActivity.java代码如下：

[java] view plain copy
print ?
  1. package com.pat.imageview;  
  2.   
  3. import android.app.Activity;  
  4. import android.graphics.Bitmap;  
  5. import android.graphics.BitmapFactory;  
  6. import android.os.Bundle;  
  7. import android.view.Window;  
  8. import android.view.WindowManager;  
  9.   
  10. public class PatImageViewActivity extends Activity  
  11. {  
  12.     @Override  
  13.     public void onCreate(Bundle savedInstanceState)  
  14.     {  
  15.         super.onCreate(savedInstanceState);  
  16.           
  17.         requestWindowFeature(Window.FEATURE_NO_TITLE);  
  18.         this.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,   
  19.                 WindowManager.LayoutParams.FLAG_FULLSCREEN);  
  20.           
  21.         PatImageView piv = new PatImageView(this);  
  22.         Bitmap bmp = BitmapFactory.decodeResource(getResources(), R.drawable.sophie);  
  23.   
  24.         piv.setImageBitmap(bmp);  
  25.           
  26.         setContentView(piv);  
  27.     }  
  28. }  
package com.pat.imageview;

import android.app.Activity;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Bundle;
import android.view.Window;
import android.view.WindowManager;

public class PatImageViewActivity extends Activity
{
    @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);

        PatImageView piv = new PatImageView(this);
        Bitmap bmp = BitmapFactory.decodeResource(getResources(), R.drawable.sophie);

        piv.setImageBitmap(bmp);

        setContentView(piv);
    }
}


由于有些手势在模拟器上无法模拟，所以就不上运行结果的图片了。本人在真机上运行后(照片就不拍了，有点累啦)，可以轻松做到：

1.     很方便地拖动图片(比如，单指按住屏幕进行拖动)

2.     很方便地缩放图片(比如，双指按住屏幕进行分开或者并拢操作，可分别实现放大或者缩小图片的功能)

3.     长按出现振动后，可以很方便地旋转图片(一个手指固定，另外一个手指围绕那个固定的手指运动)。


转自：http://blog.csdn.net/pathuang68/article/details/6991988

http://blog.csdn.net/jdsjlzx/article/details/52749178

贵公子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Google Android sdk 开发范例大全 部分章节代码
04-06
5.24 取得电信网络与手机相关信息——TelephonyManager与android.provider.Settings.System的应用 第6章 手机自动服务纪实 –p254 6.1 您有一条短信popup提醒——常驻BroadcastReceiver的应用 6.2 手机电池计量还剩...
矩阵matrix通路验证小知识_3
Grady
05-25 400
一、地址对齐和非对齐访问 一个地址最多能存储8bit数据； 当数据总线位宽为128bit时，则一个数据需要16的地址，对应十六进制为f； len=0，size=4，满带访问时，对齐地址为0、4、8、c。 当数据总线位宽为256bit时，则一个数据需要32的地址，对应十六进制为20； len=0，size=5，满带访问时，对齐地址为20、40、60、80…。 非对齐访问只要地址末尾不是上述的即可。 二、axi vip 目前axi vip不支持窄带非对齐访问。 原因为发固定数据时，vip会对数据进行移位对齐操作
矩阵matrix通路验证小知识_2
Grady
04-25 742
1、matrix cdas机制 SPI模式：对于不同的ID，即阻塞。上一ID的响应未返回时，即上一ID的事务未完成，则下一ID阻塞，事务不允许发出。 SAS模式：在SPI的基础上，增加对同一ID的限制。对于同一ID，若mst0到slv0写数据未完成，即写通道的wlast未置起，则阻塞mst1到slv0的aw。 2、matrix outstanding os分矩阵本身和矩阵组件，此处为矩阵本身。 矩...
安卓自定义View——Matrix
浅谈Android
04-24 1285
1、Matrix简介 Matrix是一个矩阵，主要功能映射视图中的坐标，这里的映射有两重意思，一是将坐标以矩阵的形式表示，类似于数学中的向量，二是映射手机屏幕坐标和安卓坐标的对应关系，在物理屏幕中坐标原点为左上角（0，0）处，而在Android了开发中使用的坐标是去除状态栏和导航栏的高度，即（0，0）位置在状态栏之下，假设状态栏30px，导航栏60px，则Android中的（0，0）对应物理坐标...
Android Matrix 不再疑惑
10-04 566
前言 在进行坐标变换的时候，都绕不开Matrix类，那到底Matrix原理是什么以及怎么使用，接下来将会详细讲解。 通过这篇文章，你将了解到： 1、Matrix类的基本方法 2、pre/post该怎么理解 3、Matrix底层原理 4、Matrix实际运用 矩阵知识 如上图，是一个二行二列的矩阵。 矩阵可以相加（相减），条件是两个矩阵的行数和列数需要一致（同型矩阵）。 矩阵可以相乘，条件是第一个矩阵列数和第二个矩阵的行数一致 举个简单的乘法的例子： 将乘数交换位置 可以看出，交换了位置之后，乘
矩阵matrix通路验证小知识_5
Grady
01-12 576
1、fn_mod_bb寄存器(切包) RW，位宽1,复位0。仅在向下转换数据位宽到AXI4时有效。长猝发功能修改寄存器。用于控制长猝发的拆分：0,在ASIB的输出端不能产生长猝发；1,在ASIB的输出端产生长猝发。 示例： axi4访问axi4,且128bit转32bit。激励为awaddr=00,size=4,len=5<16，strb=ffff，cache=2。 当long_burst_int=0时，出矩阵时awaddr=00+40,size=2,len=f+7,strb=f，cache=2。 当
JAVA上百实例源码以及开源项目源代码
09-17
　Java绘制图片火焰效果，源代码相关注释：前景和背景Image对象、Applet和绘制火焰的效果的Image对象、Applet和绘制火焰的效果的Graphics对象、火焰效果的线程、Applet的高度,图片到图片装载器、绘制火焰效果的X坐标...
JAVA上百实例源码以及开源项目
01-03
　Java绘制图片火焰效果，源代码相关注释：前景和背景Image对象、Applet和绘制火焰的效果的Image对象、Applet和绘制火焰的效果的Graphics对象、火焰效果的线程、Applet的高度,图片到图片装载器、绘制火焰效果的X坐标...
java开源包8
06-28
JGraphEd 是一个 Java 的图形编辑应用和绘图框架。 Java 穿越NAT方案 JSTUN.tar JSTUN 是另外一个用来解决穿越 NAT 进行通讯的 Java 解决方案，是 STUN 协议的 Java实现。 在浏览器上运行Java程序 Doppio DoppioVM...
android倒影效果,Android中使用Matrix控制图形变换和制作倒影效果的方法
weixin_30635747的博客
05-27 498
最近在使用Matrix进行绘图的操作。对Matrix的一些方法有了一些更深的体会，记下来，以便日后复习。Matrix常用的方法：一、变换方法：Matrix提供了translate(平移)、rotate(旋转)、scale(缩放)、skew(倾斜)四种操作，这四种操作的内部实现过程都是通过matrix.setValues(…)来设置矩阵的值来达到变换图片的效果。Matrix的每种操作都有set、pr...
Matrix矩阵
jimmy的专栏
01-05 837
Matrix，中文里叫矩阵，高等数学里有介绍，在图像处理方面，主要是用于平面的缩放、平移、旋转等操作。 在Android里面，Matrix由9个float值构成，是一个3*3的矩阵。最好记住。如下图： 解释一下，上面的sinX和cosX，表示旋转角度的cos值和sin值，注意，旋转角度是按顺时针方向计算的。 translateX和translateY表示x和y的平移量。s
android matrix 详解与进阶(一)
文涛的专栏
05-18 7767
1 概述这里我们会详细讲解matrix的各个方法，以及它的用法。matrix叫做矩阵，在前面讲解 ColorFilter 的文章中，我们讲解了ColorMatrix，他是一个4*5的矩阵。而这里，我们讲解的Matrix不是用于处理颜色的，而是处理图形的。他是一个3*3的矩阵。2 原理先看看matrix的矩阵是什么样子的：这里可以查看Matrix的代码得到。那么这个矩阵分别代表了什么呢，这里通
Matrix（矩阵操作）
Android人生
09-11 1513
准备一张名为picture的图片。     在main.xml中：       xmlns:android="http://schemas.android.com/apk/res/android"     android:layout_width="fill_parent"     android:layout_height="fill_parent"     android:
我的Android进阶之旅------>android Matrix图片随意的放大缩小,拖动（转）
weixin_30900589的博客
03-17 238
step1:新建一个项目DragAndZoom，并准备一张照片放在res/drawable-hdpi目录下，如下图所示： step2: 设置应用的UI界面，在main.xml中设置： [html]view plaincopy <?xmlversion="1.0"encoding="utf-8"?> <Linea...
Android学习笔记进阶九之Matrix对称变换
落日小屋
02-16 4340
网上很多的倒影特效实际上就是一个对称变换，在改变透明度即可。 Matrix对称变换包括很多种，有关于Y轴对称，关于X轴对称，关于y= -x对称等等。 1 关于Y轴对称 // 获取资源文件的引用res Resources res = getResources(); // 获取图形资源文件 Bitmap bmp = BitmapFactory.decodeResource(res
matrix.set,pre,post用法
u010313877的专栏
10-30 1097
最近在使用Matrix进行绘图的操作。对Matrix的一些方法有了一些更深的体会，记下来，以便日后复习。 Matrix常用的方法： （一）变换方法：      Matrix提供了translate(平移)、rotate(旋转)、scale(缩放)、skew(倾斜)四种操作，这四种操作的内部实现过程都是通过matrix.setValues(…)来设置矩阵的值来达到变换图片的效果。
Android---Matrix类的使用
dia7964的博客
01-22 176
在Android中，对图片的处理需要使用到Matrix类，Matrix是一个3 x 3的矩阵，他对图片的处理分为四个基本类型： 1、Translate————平移变换 2、Scale————缩放变换 3、Rotate————旋转变换 4、Skew————错切变换 在Android的API里对于每一种变换都提供了三种操作方式：set（用于设置Matrix中的值）、post（后乘，...
java matrix_Java Matrix.orthoM方法代码示例
weixin_42358409的博客
02-16 234
import android.opengl.Matrix; //导入方法依赖的package包/类/*** Handles changes to the size of the underlying surface. Adjusts viewport as needed.* Must be called before we start drawing.* (Called from RenderH...
Android中图像变换Matrix的原理应用
maozhuxigood
02-12 762
第一部分 Matrix的数学原理 在Android中，如果你用Matrix进行过图像处理，那么一定知道Matrix这个类。Android中的Matrix是一个3 x 3的矩阵，其内容如下： Matrix的对图像的处理可分为四类基本变换： Translate 平移变换 Rotate 旋转变换 Scale 缩放变换 Skew 错切变换 从字...
android studio matrix旋转
最新发布
04-08
Android Studio是一款用于开发Android应用程序的集成开发环境（IDE），而Matrix旋转是指在Android应用程序中对图形进行旋转变换的操作。 在Android Studio中，可以使用Matrix类来进行图形的旋转变换。Matrix是一个2D变换矩阵，可以通过设置不同的变换参数来实现旋转、缩放、平移等操作。 要实现Matrix旋转，可以按照以下步骤进行操作： 1. 创建一个Matrix对象：`Matrix matrix = new Matrix();` 2. 使用Matrix的`postRotate()`方法来设置旋转角度和旋转中心点：`matrix.postRotate(angle, centerX, centerY);` - `angle`表示旋转的角度，单位为度。 - `centerX`和`centerY`表示旋转中心点的坐标。 3. 将Matrix应用到需要进行旋转的图形上，可以使用Canvas的`concat()`方法：`canvas.concat(matrix);` - `canvas`表示要进行绘制的画布对象。 通过以上步骤，就可以在Android应用程序中实现Matrix旋转效果了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值