织梦CMS - 轻松建站从此开始！
高级搜索|网站地图|TAG标签RSS订阅[设为首页] [加入收藏]

罗索

搜索

热门标签:

当前位置: 主页>嵌入式开发>Android>

Android matrix 控制图片的旋转、缩放、移动

落鹤生 发布于 2012-03-27 10:54 点击:次 
本文主要讲解利用android中Matrix控制图形的旋转缩放移动,使用矩阵控制图片移动、缩放、旋转
TAG:

本文主要讲解利用android中Matrix控制图形的旋转缩放移动，具体参见一下代码：

  1. /**  
  2.  * 使用矩阵控制图片移动、缩放、旋转  
  3.  * @author 张进  
  4.  */   
  5. public class CommonImgEffectView extends View {
  6.     private Context context ;
  7.     private Bitmap mainBmp , controlBmp ;
  8.     private int mainBmpWidth, mainBmpHeight, controlBmpWidth, controlBmpHeight ;
  9.     private Matrix matrix ;
  10.     private float [] srcPs , dstPs ;
  11.     private RectF srcRect , dstRect ;
  12.     private Paint paint ,paintRect , paintFrame;
  13.     private float deltaX = 0, deltaY = 0; //位移值
  14.     private float scaleValue = 1; //缩放值
  15.     private Point lastPoint ;
  16.     private Point prePivot , lastPivot;
  17.     private float preDegree , lastDegree ;
  18.     private short currentSelectedPointindex;        //当前操作点击点
  19.     private Point symmetricPoint  = new Point();    //当前操作点对称点

  21.     /**  
  22.      * 图片操作类型  
  23.      */   
  24.     public static final int OPER_DEFAULT = -1;      //默认   
  25.     public static final int OPER_TRANSLATE = 0;     //移动   
  26.     public static final int OPER_SCALE = 1;         //缩放   
  27.     public static final int OPER_ROTATE = 2;        //旋转   
  28.     public static final int OPER_SELECTED = 3;      //选择   
  29.     public int lastOper = OPER_DEFAULT;   
  30.        
  31.     /* 图片控制点  
  32.      * 0---1---2  
  33.      * |       |  
  34.      * 7   8   3  
  35.      * |       |  
  36.      * 6---5---4   
  37.      */   
  38.     public static final int CTR_NONE = -1;   
  39.     public static final int CTR_LEFT_TOP = 0;   
  40.     public static final int CTR_MID_TOP = 1;   
  41.     public static final int CTR_RIGHT_TOP = 2;   
  42.     public static final int CTR_RIGHT_MID = 3;   
  43.     public static final int CTR_RIGHT_BOTTOM = 4;   
  44.     public static final int CTR_MID_BOTTOM = 5;   
  45.     public static final int CTR_LEFT_BOTTOM = 6;   
  46.     public static final int CTR_LEFT_MID = 7;   
  47.     public static final int CTR_MID_MID = 8;   
  48.     public int current_ctr = CTR_NONE;   
  49.        
  50.     public CommonImgEffectView(Context context){   
  51.         super(context);   
  52.         this.context = context ;   
  53.     }   
  54.        
  55.     public CommonImgEffectView(Context context, AttributeSet attrs) {   
  56.         super(context, attrs);   
  57.         this.context = context ;   
  58.         initData();   
  59.     }   
  60.        
  61.     /**  
  62.      * 初始化数据  
  63.      * @author 张进  
  64.      */   
  65.     private void initData(){   
  66.         mainBmp = BitmapFactory.decodeResource(this.context.getResources()
  67. , R.drawable.flower);   
  68.         controlBmp = BitmapFactory.decodeResource(this.context.getResources()
  69. , R.drawable.control);   
  70.         mainBmpWidth = mainBmp.getWidth();   
  71.         mainBmpHeight = mainBmp.getHeight();   
  72.         controlBmpWidth = controlBmp.getWidth();   
  73.         controlBmpHeight = controlBmp.getHeight();   
  74.            
  75.         srcPs = new float[]{   
  76.                                 0,0,    
  77.                                 mainBmpWidth/2,0,    
  78.                                 mainBmpWidth,0,    
  79.                                 mainBmpWidth,mainBmpHeight/2,   
  80.                                 mainBmpWidth,mainBmpHeight,    
  81.                                 mainBmpWidth/2,mainBmpHeight,    
  82.                                 0,mainBmpHeight,    
  83.                                 0,mainBmpHeight/2,    
  84.                                 mainBmpWidth/2,mainBmpHeight/2   
  85.                             };   
  86.         dstPs = srcPs.clone();   
  87.         srcRect = new RectF(0, 0, mainBmpWidth, mainBmpHeight);   
  88.         dstRect = new RectF();   
  89.            
  90.         matrix = new Matrix();   
  91.            
  92.         prePivot = new Point(mainBmpWidth/2, mainBmpHeight/2);   
  93.         lastPivot = new Point(mainBmpWidth/2, mainBmpHeight/2);   
  94.            
  95.         lastPoint = new Point(0,0);   
  96.            
  97.         paint = new Paint();   
  98.            
  99.         paintRect = new Paint();   
  100.         paintRect.setColor(Color.RED);   
  101.         paintRect.setAlpha(100);   
  102.         paintRect.setAntiAlias(true);   
  103.            
  104.         paintFrame = new Paint();   
  105.         paintFrame.setColor(Color.GREEN);   
  106.         paintFrame.setAntiAlias(true);   
  107.            
  108.         setMatrix(OPER_DEFAULT);   
  109.     }   
  110.        
  111.     /**  
  112.      * 矩阵变换，达到图形平移的目的  
  113.      * @author 张进  
  114.      */   
  115.     private void setMatrix(int operationType){   
  116.         switch (operationType) {   
  117.         case OPER_TRANSLATE:   
  118.             matrix.postTranslate(deltaX , deltaY);   
  119.             break;   
  120.         case OPER_SCALE:   
  121.             matrix.postScale(scaleValue, scaleValue, symmetricPoint.x
  122. , symmetricPoint.y);   
  123.             break;   
  124.         case OPER_ROTATE:   
  125.             matrix.postRotate(preDegree - lastDegree, dstPs[CTR_MID_MID * 2]
  126. , dstPs[CTR_MID_MID * 2 + 1]);   
  127.             break;   
  128.         }   
  129.            
  130.         matrix.mapPoints(dstPs, srcPs);   
  131.         matrix.mapRect(dstRect, srcRect);   
  132.     }   
  133.        
  134.     private boolean isOnPic(int x , int y){   
  135.         if(dstRect.contains(x, y)){   
  136.             return true;   
  137.         }else    
  138.             return false;   
  139.     }   
  140.        
  141.     private int getOperationType(MotionEvent event){   
  142.    
  143.         int evX = (int)event.getX();   
  144.         int evY = (int)event.getY();   
  145.         int curOper = lastOper;   
  146.         switch(event.getAction()) {   
  147.             case MotionEvent.ACTION_DOWN:   
  148.                 current_ctr = isOnCP(evX, evY);   
  149.                 Log.i("img", "current_ctr is "+current_ctr);   
  150.                 if(current_ctr != CTR_NONE || isOnPic(evX, evY)){   
  151.                     curOper = OPER_SELECTED;   
  152.                 }   
  153.                 break;   
  154.             case MotionEvent.ACTION_MOVE:   
  155.                     if(current_ctr > CTR_NONE && current_ctr < CTR_MID_MID ){   
  156.                         curOper = OPER_SCALE;   
  157.                     }else if(current_ctr == CTR_MID_MID ){   
  158.                         curOper = OPER_ROTATE;   
  159.                     }else if(lastOper == OPER_SELECTED){   
  160.                         curOper = OPER_TRANSLATE;   
  161.                     }   
  162.                 break;   
  163.             case MotionEvent.ACTION_UP:   
  164.                 curOper = OPER_SELECTED;   
  165.                 break;   
  166.             default:   
  167.                 break;   
  168.         }   
  169.         Log.d("img", "curOper is "+curOper);   
  170.         return curOper;   
  171.            
  172.     }   
  173.        
  174.      /**  
  175.      * 判断点所在的控制点  
  176.      * @param evX  
  177.      * @param evY  
  178.      * @return  
  179.      */    
  180.     private int isOnCP(int evx, int evy) {   
  181.         Rect rect = new Rect(evx-controlBmpWidth/2,evy-controlBmpHeight/2
  182. ,evx+controlBmpWidth/2,evy+controlBmpHeight/2);   
  183.         int res = 0 ;   
  184.         for (int i = 0; i < dstPs.length; i+=2) {   
  185.             if(rect.contains((int)dstPs[i], (int)dstPs[i+1])){   
  186.                 return res ;   
  187.             }   
  188.             ++res ;    
  189.         }   
  190.         return CTR_NONE;   
  191.     }   
  192.        
  193.        
  194.        
  195.     @Override   
  196.     public boolean dispatchTouchEvent(MotionEvent event) {   
  197.         int evX = (int)event.getX();   
  198.         int evY = (int)event.getY();   
  199.            
  200.         int operType = OPER_DEFAULT;   
  201.         operType = getOperationType(event);   
  202.            
  203.         switch (operType) {   
  204.         case OPER_TRANSLATE:   
  205.             translate(evX, evY);   
  206.             break;   
  207.         case OPER_SCALE:   
  208.             scale(event);   
  209.             break;   
  210.         case OPER_ROTATE:   
  211.             rotate(event);   
  212.             break;   
  213.         }   
  214.        
  215.         lastPoint.x = evX;   
  216.         lastPoint.y = evY;     
  217.            
  218.         lastOper = operType;   
  219.         invalidate();//重绘   
  220.         return true;   
  221.     }   
  222.    
  223.     /**  
  224.      * 移动  
  225.      * @param evx  
  226.      * @param evy  
  227.      * @author zhang_jin1  
  228.      */   
  229.     private void translate(int evx , int evy){   
  230.            
  231.         prePivot.x += evx - lastPoint.x;   
  232.         prePivot.y += evy -lastPoint.y;   
  233.            
  234.         deltaX = prePivot.x - lastPivot.x;   
  235.         deltaY = prePivot.y - lastPivot.y;   
  236.            
  237.         lastPivot.x = prePivot.x;   
  238.         lastPivot.y = prePivot.y;   
  239.            
  240.         setMatrix(OPER_TRANSLATE); //设置矩阵   
  241.            
  242.     }   
  243.        
  244.     /**  
  245.      * 缩放  
  246.      * 0---1---2  
  247.      * |       |  
  248.      * 7   8   3  
  249.      * |       |  
  250.      * 6---5---4  
  251.      * @param evX  
  252.      * @param evY  
  253.      */   
  254.     private void scale(MotionEvent event) {   
  255.            
  256.         int pointIndex = current_ctr*2 ;   
  257.            
  258.         float px = dstPs[pointIndex];   
  259.         float py = dstPs[pointIndex+1];   
  260.            
  261.         float evx = event.getX();   
  262.         float evy = event.getY();   
  263.            
  264.         float oppositeX = 0 ;   
  265.         float oppositeY = 0 ;   
  266.         if(current_ctr<4 && current_ctr >= 0){   
  267.              oppositeX = dstPs[pointIndex+8];   
  268.              oppositeY = dstPs[pointIndex+9];   
  269.         }else if(current_ctr >= 4){   
  270.              oppositeX = dstPs[pointIndex-8];   
  271.              oppositeY = dstPs[pointIndex-7];   
  272.         }   
  273.         float temp1 = getDistanceOfTwoPoints(px,py,oppositeX,oppositeY);   
  274.         float temp2 = getDistanceOfTwoPoints(evx,evy,oppositeX,oppositeY);   
  275.            
  276.         this.scaleValue = temp2 / temp1 ;   
  277.         symmetricPoint.x = (int) oppositeX;   
  278.         symmetricPoint.y = (int)oppositeY;   
  279.            
  280.         Log.i("img", "scaleValue is "+scaleValue);   
  281.         setMatrix(OPER_SCALE);   
  282.     }   
  283.        
  284.     /**  
  285.      * 旋转图片  
  286.      * 0---1---2  
  287.      * |       |  
  288.      * 7   8   3  
  289.      * |       |  
  290.      * 6---5---4   
  291.      * @param evX  
  292.      * @param evY  
  293.      */   
  294.     private void rotate(MotionEvent event) {   
  295.           
  296.         if(event.getPointerCount() == 2){   
  297.             preDegree = computeDegree(new Point((int)event.getX(0)
  298. , (int)event.getY(0)), new Point((int)event.getX(1), (int)event.getY(1)));   
  299.         }else{   
  300.             preDegree = computeDegree(new Point((int)event.getX()
  301. , (int)event.getY()), new Point((int)dstPs[16], (int)dstPs[17]));   
  302.         }   
  303.         setMatrix(OPER_ROTATE);   
  304.         lastDegree = preDegree;   
  305.     }   
  306.        
  307.        
  308.     /**  
  309.      * 计算两点与垂直方向夹角  
  310.      * @param p1  
  311.      * @param p2  
  312.      * @return  
  313.      */   
  314.     public float computeDegree(Point p1, Point p2){   
  315.         float tran_x = p1.x - p2.x;   
  316.         float tran_y = p1.y - p2.y;   
  317.         float degree = 0.0f;   
  318.         float angle = (float)(Math.asin(tran_x/Math.sqrt(tran_x*tran_x
  319.  + tran_y* tran_y))*180/Math.PI);   
  320.         if(!Float.isNaN(angle)){   
  321.             if(tran_x >= 0 && tran_y <= 0){//第一象限   
  322.                 degree = angle;   
  323.             }else if(tran_x <= 0 && tran_y <= 0){//第二象限   
  324.                 degree = angle;   
  325.             }else if(tran_x <= 0 && tran_y >= 0){//第三象限   
  326.                 degree = -180 - angle;   
  327.             }else if(tran_x >= 0 && tran_y >= 0){//第四象限   
  328.                 degree = 180 - angle;   
  329.             }   
  330.         }   
  331.         return degree;   
  332.     }   
  333.        
  334.     /**  
  335.      * 计算两个点之间的距离  
  336.      * @param p1  
  337.      * @param p2  
  338.      * @return  
  339.      */   
  340.     private float getDistanceOfTwoPoints(Point p1, Point p2){   
  341.         return (float)(Math.sqrt((p1.x - p2.x) * (p1.x - p2.x)
  342.  + (p1.y - p2.y) * (p1.y - p2.y)));   
  343.     }   
  344.        
  345.     private float getDistanceOfTwoPoints(float x1,float y1,float x2,float y2){   
  346.         return (float)(Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)));   
  347.     }   
  348.        
  349.        
  350.     @Override   
  351.     public void onDraw(Canvas canvas){   
  352.         drawBackground(canvas);//绘制背景,以便测试矩形的映射   
  353.         canvas.drawBitmap(mainBmp, matrix, paint);//绘制主图片   
  354.         drawFrame(canvas);//绘制边框,以便测试点的映射   
  355.         drawControlPoints(canvas);//绘制控制点图片   
  356.     }   
  357.        
  358.     private void drawBackground(Canvas canvas){   
  359.         canvas.drawRect(dstRect, paintRect);   
  360.     }   
  361.        
  362.     private void drawFrame(Canvas canvas){   
  363.         canvas.drawLine(dstPs[0], dstPs[1], dstPs[4], dstPs[5], paintFrame);   
  364.         canvas.drawLine(dstPs[4], dstPs[5], dstPs[8], dstPs[9], paintFrame);   
  365.         canvas.drawLine(dstPs[8], dstPs[9], dstPs[12], dstPs[13], paintFrame);   
  366.         canvas.drawLine(dstPs[0], dstPs[1], dstPs[12], dstPs[13], paintFrame);   
  367.         canvas.drawPoint(dstPs[16], dstPs[17], paintFrame);   
  368.     }   
  369.        
  370.     private void drawControlPoints(Canvas canvas){   
  371.            
  372.         for (int i = 0; i < dstPs.length; i+=2) {   
  373.             canvas.drawBitmap(controlBmp, dstPs[i]-controlBmpWidth/2
  374. , dstPs[i+1]-controlBmpHeight/2, paint);   
  375.         }   
  376.            
  377.     }   
  378.        
  379. }   

Demo效果：

(zj_1395201)
本站文章除注明转载外，均为本站原创或编译欢迎任何形式的转载，但请务必注明出处，尊重他人劳动，同学习共成长。转载请注明：文章转载自：罗索实验室 [http://www.rosoo.net/a/201203/15877.html]
本文出处：CSDN博客　作者：zj_1395201 原文
顶一下
(18)
100%
踩一下
(0)
0%
------分隔线----------------------------
相关文章
发表评论
请自觉遵守互联网相关的政策法规，严禁发布色情、暴力、反动的言论。
评价:
表情:
用户名: 验证码:点击我更换图片
最新评论 进入详细评论页>>
栏目列表
将本文分享到微信
织梦二维码生成器
推荐内容
热点内容