android——8点控制裁剪框

落日映苍穹つ 2022-07-12 03:28 169阅读 0赞

原创文章——转载请注明

之前的图片裁剪功能是4点控制的，来源为他人的博客。目前有点时间，将其扩展为8控制点裁剪。

先看一下效果：

![Center][]

关键在于控制点的绘制，触屏时控制点的判断（一定半径的圆形范围），扩大缩小的判断，缩小的最小量判断（四角的点用对角线，中间点用长宽），移动边界越界的判断，放大缩小时控制点的重绘。

代码很简单，注释也充足，就不多解释了，上代码

public class ChoiceMatrixView extends View {
    
    	private static final String TAG = "ChoiceMatrixView";
    	
    	private int scale = (int) this.getResources().getDisplayMetrics().density;  //屏幕像素密度
        private float borderHeight;   //总高
        private float borderWith; //总宽
        private float imageHeight; //图片高度
        private float imageWidth; //图片宽度
        private float imageTranslateX; //由于图片是居中的，需要考虑x和y方向的偏移量
        private float imageTranslateY; //由于图片是居中的，需要考虑x和y方向的偏移量
        private float borderLength = 200 * scale; //边框长度
        private int RECT_BORDER_WITH = 3 * scale; //长方形框框粗
        private int RECT_CORNER_WITH = 6 * scale; //四个角的粗
        private int RECT_CORNER_HEIGHT = 20 * scale; //四个角的长度
    
        //四个点坐标
        public static float[][] four_corner_coordinate_positions;
    
        private static int NOW_MOVE_STATE = 1; //移动状态，默认为1，Y轴=1，X轴=2
    
        private static boolean MOVE_OR_ZOOM_STATE = true; //移动或缩放状态， true 为移动
    
        public ChoiceMatrixView(Context context, AttributeSet attrs) {
            super(context, attrs);
            this.setFocusable(true);
            this.setFocusableInTouchMode(true);
            init();
        }
    
        /**
         * 初始化布局
         * @param changed
         * @param left
         * @param top
         * @param right
         * @param bottom
         */
        @Override
        protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
            super.onLayout(changed, left, top, right, bottom);
            
            //总高和总宽需要综合考虑view的宽和高和图片的宽和高
            //但是由于异步机制，无法在onLayout之前获得偏移量，因此图片溢出改为消息提醒
            /*
            if(imageHeight==0){
            	borderHeight = this.getHeight();
            }else{
            	if(imageHeight<this.getHeight())
            		borderHeight=imageHeight;
            	else
            		borderHeight = this.getHeight()+getTranslationY();
            }
            if(imageWidth==0){
            	borderWith = this.getWidth();
            }else{
            	if(imageWidth<this.getWidth())
            		borderWith=imageWidth;
            	else
            		borderWith = this.getWidth()+getTranslationX();
            }
            */
            borderHeight = this.getHeight();
            borderWith = this.getWidth();
            //初始化四个点的坐标
            four_corner_coordinate_positions = new float[][]{
                    {(borderWith - borderLength) / 2, (borderHeight - borderLength) / 2}, //左上
                    {(borderWith + borderLength) / 2, (borderHeight - borderLength) / 2}, //右上
                    {(borderWith - borderLength) / 2, (borderHeight + borderLength) / 2}, //左下
                    {(borderWith + borderLength) / 2, (borderHeight + borderLength) / 2}, //右上
                    {(borderWith - borderLength) / 2 + borderLength / 2, (borderHeight - borderLength) / 2}, //上中
                    {(borderWith + borderLength) / 2, (borderHeight - borderLength) / 2 + borderLength / 2}, //右中
                    {(borderWith - borderLength) / 2, (borderHeight - borderLength) / 2 + borderLength / 2}, //左中
                    {(borderWith - borderLength) / 2 + borderLength / 2, (borderHeight + borderLength) / 2}  //下中
            };
        }
    
        private int temp1 = (RECT_CORNER_WITH - RECT_BORDER_WITH) / 2;  //长方形的粗半距
        private int temp2 = (RECT_CORNER_WITH + RECT_BORDER_WITH) / 2;  //四个角的粗半距
    
        /**
         * RECT_CORNER_WITH = 6
         * RECT_BORDER_WITH  =3
         *
         * @param canvas
         */
        @Override
        protected void onDraw(Canvas canvas) {
            Paint paintRect = new Paint();  //初始化画笔
            //画边框的画笔
            paintRect.setColor(getResources().getColor(R.color.darker_gray));    //颜色
            paintRect.setStrokeWidth(RECT_BORDER_WITH);    //宽度
            paintRect.setAntiAlias(true);   //抗锯齿
            paintRect.setStyle(Paint.Style.STROKE); //设置空心
            canvas.drawRect(four_corner_coordinate_positions[0][0],
                    four_corner_coordinate_positions[0][1],
                    four_corner_coordinate_positions[3][0],
                    four_corner_coordinate_positions[3][1], paintRect);
            //画四个角的画笔
            paintRect.setColor(Color.WHITE);
            paintRect.setStrokeWidth(RECT_CORNER_WITH);
            paintRect.setAntiAlias(true);
            //左上角的两根
            canvas.drawLine(four_corner_coordinate_positions[0][0] - temp2,
                    four_corner_coordinate_positions[0][1] - temp1,
                    four_corner_coordinate_positions[0][0] - temp1 + RECT_CORNER_HEIGHT,
                    four_corner_coordinate_positions[0][1] - temp1,
                    paintRect);
            canvas.drawLine(four_corner_coordinate_positions[0][0] - temp1,
                    four_corner_coordinate_positions[0][1] - temp2,
                    four_corner_coordinate_positions[0][0] - temp1,
                    four_corner_coordinate_positions[0][1] - temp1 + RECT_CORNER_HEIGHT,
                    paintRect);
            //左下角的两根
            canvas.drawLine(four_corner_coordinate_positions[2][0] - temp2,
                    four_corner_coordinate_positions[2][1] + temp1,
                    four_corner_coordinate_positions[2][0] - temp1 + RECT_CORNER_HEIGHT,
                    four_corner_coordinate_positions[2][1] + temp1,
                    paintRect);
            canvas.drawLine(four_corner_coordinate_positions[2][0] - temp1,
                    four_corner_coordinate_positions[2][1] + temp1,
                    four_corner_coordinate_positions[2][0] - temp1,
                    four_corner_coordinate_positions[2][1] + temp1 - RECT_CORNER_HEIGHT,
                    paintRect);
            //右上角的两根
            canvas.drawLine(four_corner_coordinate_positions[1][0] + temp1,
                    four_corner_coordinate_positions[1][1] - temp1,
                    four_corner_coordinate_positions[1][0] + temp1 - RECT_CORNER_HEIGHT,
                    four_corner_coordinate_positions[1][1] - temp1,
                    paintRect);
            canvas.drawLine(four_corner_coordinate_positions[1][0] + temp1,
                    four_corner_coordinate_positions[1][1] - temp2,
                    four_corner_coordinate_positions[1][0] + temp1,
                    four_corner_coordinate_positions[1][1] - temp1 + RECT_CORNER_HEIGHT
                    , paintRect);
            //右下角的两根
            canvas.drawLine(four_corner_coordinate_positions[3][0] + temp2,
                    four_corner_coordinate_positions[3][1] + temp1,
                    four_corner_coordinate_positions[3][0] + temp1 - RECT_CORNER_HEIGHT,
                    four_corner_coordinate_positions[3][1] + temp1,
                    paintRect);
            canvas.drawLine(four_corner_coordinate_positions[3][0] + temp1,
                    four_corner_coordinate_positions[3][1] + temp1,
                    four_corner_coordinate_positions[3][0] + temp1,
                    four_corner_coordinate_positions[3][1] + temp1 - RECT_CORNER_HEIGHT,
                    paintRect);
            
            //上中
            canvas.drawLine(four_corner_coordinate_positions[4][0]- temp2 - RECT_CORNER_HEIGHT,
                    four_corner_coordinate_positions[0][1] - temp1,
                    four_corner_coordinate_positions[4][0] + (temp1 + RECT_CORNER_HEIGHT),
                    four_corner_coordinate_positions[0][1] - temp1,
                    paintRect);
            
            //右中
            canvas.drawLine(four_corner_coordinate_positions[3][0],
                    four_corner_coordinate_positions[6][1] - temp2 - RECT_CORNER_HEIGHT,
                    four_corner_coordinate_positions[3][0],
                    four_corner_coordinate_positions[6][1] + temp1 + RECT_CORNER_HEIGHT,
                    paintRect);
            
            //左中
            canvas.drawLine(four_corner_coordinate_positions[0][0],
                    four_corner_coordinate_positions[6][1] - temp2 - RECT_CORNER_HEIGHT,
                    four_corner_coordinate_positions[0][0],
                    four_corner_coordinate_positions[6][1] + temp1 + RECT_CORNER_HEIGHT,
                    paintRect);
            
            //下中
            canvas.drawLine(four_corner_coordinate_positions[4][0] - temp2 - RECT_CORNER_HEIGHT,
                    four_corner_coordinate_positions[3][1] + temp1,
                    four_corner_coordinate_positions[4][0] + temp1 + RECT_CORNER_HEIGHT,
                    four_corner_coordinate_positions[3][1] + temp1,
                    paintRect);
            
            //画扫描线
            if (IF_SCANNING_SHOW) {
                paintRect.setColor(Color.WHITE);
                paintRect.setStrokeWidth(1);
                paintRect.setAntiAlias(true);
                paintRect.setStyle(Paint.Style.STROKE);
                //共四根线
                //竖1
                canvas.drawLine(four_corner_coordinate_positions[0][0] + borderLength / 3,
                        four_corner_coordinate_positions[0][1] + temp1,
                        four_corner_coordinate_positions[2][0] + borderLength / 3,
                        four_corner_coordinate_positions[2][1] - temp1,
                        paintRect);
                //竖2
                canvas.drawLine(four_corner_coordinate_positions[1][0] - borderLength / 3,
                        four_corner_coordinate_positions[1][1] + temp1,
                        four_corner_coordinate_positions[3][0] - borderLength / 3,
                        four_corner_coordinate_positions[3][1] - temp1,
                        paintRect);
                //横1
                canvas.drawLine(four_corner_coordinate_positions[0][0] + temp1,
                        four_corner_coordinate_positions[0][1] + borderLength / 3,
                        four_corner_coordinate_positions[1][0] - temp1,
                        four_corner_coordinate_positions[1][1] + borderLength / 3,
                        paintRect);
                //横2
                canvas.drawLine(four_corner_coordinate_positions[2][0] + temp1,
                        four_corner_coordinate_positions[2][1] - borderLength / 3,
                        four_corner_coordinate_positions[3][0] - temp1,
                        four_corner_coordinate_positions[3][1] - borderLength / 3,
                        paintRect);
            }
        }
    
        private boolean IF_SCANNING_SHOW = false;
        private int lastX = 0;  //上次按下的X位置
        private int lastY = 0;  //上次按下的Y位置
        private int offsetX = 0;    //X轴偏移量
        private int offsetY = 0;    //Y轴偏移量
        static int point = -1;// 用户按下的点
        private int POINT_STATE = -1; //判断用户是缩小还是放大 0放大 1缩小
    
        @Override
        public boolean onTouchEvent(MotionEvent event) {
            int x = (int) event.getX();
            int y = (int) event.getY();
    
            switch (event.getAction()) {
                case MotionEvent.ACTION_DOWN:
                    IF_SCANNING_SHOW = true;//显示扫描线
                    if (isInTheCornerCircle(event.getX(), event.getY()) != -1) {
                        //开始缩放操作
                        MOVE_OR_ZOOM_STATE = false; //设置false为缩放状态
                        point = isInTheCornerCircle(event.getX(), event.getY());
                    }
                    lastX = x;
                    lastY = y;
                    invalidate();
                    break;
                case MotionEvent.ACTION_MOVE:
                    offsetX = x - lastX;
                    offsetY = y - lastY;
                    //判断当前是扩大还是缩小操作
                    judgementXandY();
                    //限定移动范围
                    //移动状态：只有在移动状态下才能移动
                    if (MOVE_OR_ZOOM_STATE) {
                        getoffsetXandoffsetY();
                        //四个点的坐标信息也要随之改变
                        for (int i = 0; i < four_corner_coordinate_positions.length; i++) {
                            four_corner_coordinate_positions[i][0] += offsetX;
                            four_corner_coordinate_positions[i][1] += offsetY;
    
                            //更新回调接口
                            /*
                            onImageDetailsSizeChanggedl.onBorderSizeChangged(
                                    (int) four_corner_coordinate_positions[0][0],
                                    (int) four_corner_coordinate_positions[0][1],
                                    (int) borderLength
                            );
                            */
    
                            invalidate();
                        }
                        // this.scrollBy(-offsetX, -offsetY);   //这里弃用，后面改用了四点坐标移动代替背景移动
                    }
                    //在缩放状态下
                    else {
                        //按住某一个点，该点的坐标改变，其他2个点坐标跟着改变，对点坐标不变
                    	//新加入4个点的坐标后，对点和边上中点坐标不变，剩余点坐标改变
                        max = Math.abs(offsetX) >= Math.abs(offsetY) ? Math.abs(offsetX) : Math.abs(offsetY);
                        //只有在扩大操作才进行边界范围判断
                        if (POINT_STATE == 0) {
                            getoffsetXandoffsetY(); //边界范围判断
                        }
                        //缩小操作时进行边界不能太小判断
                        else if (POINT_STATE == 1) {
                            //如果边长+max太小，直接返回
                        	//由于加入中间控制点，因此需要乘以2
                            if (borderLength - max <= (RECT_CORNER_HEIGHT*2-temp2)*2) {
                                max = 0;
                            }
                            //加入中间控制点后，不能只以对角线判断，还需要判断长边和短边
                            float a = four_corner_coordinate_positions[0][0];
                            float b = four_corner_coordinate_positions[0][1];
                            float c = four_corner_coordinate_positions[1][0];
                            float d = four_corner_coordinate_positions[2][1];
                            float t1 = c - a;
                            float t2 = d - b;
                            if(t1-max<RECT_CORNER_HEIGHT*4){
                            	max = 0;
                            }
                            if(t2-max<RECT_CORNER_HEIGHT*4){
                            	max = 0;
                            }
                        }
    
                        //改变坐标
                        //changgeFourCoodinatePosition(point, offsetX, offsetY);
                        changgeEightCoodinatePosition(point, offsetX, offsetY);
                        //更新边长
                        notifyNowborderLength();
                        //更新回调接口
                        /*
                        onImageDetailsSizeChanggedl.onBorderSizeChangged(
                                (int) four_corner_coordinate_positions[0][0],
                                (int) four_corner_coordinate_positions[0][1],
                                (int) borderLength
                        );
                        */
                        invalidate();
                    }
                    lastX = x;
                    lastY = y;
                    break;
                case MotionEvent.ACTION_UP:
                    IF_SCANNING_SHOW = false; //不显示扫描线
                    MOVE_OR_ZOOM_STATE = true; //回归为默认的移动状态
                    invalidate();
                    break;
            }
            return true;
        }
        
        private void init() {
    
        }
    
        /**
         * 更新矩形框对角线的方法
         */
        private void notifyNowborderLength() {
            float a = four_corner_coordinate_positions[0][0];
            float b = four_corner_coordinate_positions[0][1];
            float c = four_corner_coordinate_positions[1][0];
            float d = four_corner_coordinate_positions[1][1];
            float temp1 = (float) Math.pow(a - c, 2);
            float temp2 = (float) Math.pow(b - d, 2);
            borderLength = (float) Math.sqrt(temp1 + temp2);
        }
    
        /**
         * POINT_STATE 为0放大， 1缩小
         */
        private void judgementXandY() {
            switch (point) {
                case 0:
                    if ((offsetX <= 0 && offsetY <= 0) || (offsetX <= 0 && offsetY >= 0)) {
                        POINT_STATE = 0;//扩大
                    } else {
                        POINT_STATE = 1;//缩小
                    }
                    break;
                case 1:
                    if ((offsetX >= 0 && offsetY <= 0) || (offsetX >= 0 && offsetY >= 0)) {
                        POINT_STATE = 0;
                    } else {
                        POINT_STATE = 1;
                    }
                    break;
                case 2:
                    if ((offsetX <= 0 && offsetY >= 0) || (offsetX <= 0 && offsetY <= 0)) {
                        POINT_STATE = 0;
                    } else {
                        POINT_STATE = 1;
                    }
                    break;
                case 3:
                    if ((offsetX >= 0 && offsetY >= 0) || (offsetX >= 0 && offsetY <= 0)) {
                        POINT_STATE = 0;
                    } else {
                        POINT_STATE = 1;
                    }
                    break;
                    
                //新加的中间控制点
                //上中
                case 4:
                	if(offsetY <= 0){
                		POINT_STATE=0;
                	} else {
                		POINT_STATE = 1;
                	}
                	break;
                //右中
                case 5:
                	if(offsetX >= 0){
                		POINT_STATE = 0;
                	} else {
                		POINT_STATE = 1;
                	}
                	break;
                //左中
                case 6:
                	if(offsetX <= 0){
                		POINT_STATE = 0;
                	} else {
                		POINT_STATE = 1;
                	}
                	break;
                //下中
                case 7:
                	if(offsetY >= 0){
                		POINT_STATE = 0;
                	} else {
                		POINT_STATE = 1;
                	}
                	break;	
            }
        }
    
        /**
         * 防止X和Y溢出边界的算法
         */
        private void getoffsetXandoffsetY() {
        	Log.d(TAG,"offsetX:"+offsetX+",offsetY:"+offsetY+",max:"+max);
            //如果是移动状态
            if (MOVE_OR_ZOOM_STATE) {
                if ((four_corner_coordinate_positions[0][0] + offsetX <= 0) ||
                        (four_corner_coordinate_positions[1][0] + offsetX >= borderWith)
                        ) {
                    offsetX = 0;
                }
    
                if ((four_corner_coordinate_positions[0][1] + offsetY <= 0) ||
                        (four_corner_coordinate_positions[2][1] + offsetY >= borderHeight)
                        ) {
                    offsetY = 0;
                }
            }
            //如果是缩放状态
            else {
            	float selectWidth=four_corner_coordinate_positions[1][0]-four_corner_coordinate_positions[0][0];
        		float selectHeight=four_corner_coordinate_positions[2][1]-four_corner_coordinate_positions[0][1];
                switch (point) {
                    case 0:
                        if ((four_corner_coordinate_positions[0][0] - max <= 0) ||
                            (four_corner_coordinate_positions[0][1] - max <= 0) 
                        ) {
                            max = 0;
                        }
                        break;
                    case 1:
                        if ((four_corner_coordinate_positions[1][0] + max >= borderWith) ||
                            (four_corner_coordinate_positions[1][1] - max <= 0) 
                                ) {
                            max = 0;
                        }
                        break;
                    case 2:
                        if ((four_corner_coordinate_positions[2][0] - max <= 0) ||
                                (four_corner_coordinate_positions[2][1] + max >= borderHeight)
                                ) {
                            max = 0;
                        }
                        break;
                    case 3:
                        if ((four_corner_coordinate_positions[3][0] + max >= borderWith) ||
                                (four_corner_coordinate_positions[3][1] + max >= borderHeight)
                                ) {
                            max = 0;
                        }
                        break;
                    //新增中间控制点的溢出算法
                    case 4:
                    	if((four_corner_coordinate_positions[4][1] - max <= 0)){
                    		max = 0;
                    	}
                    	break;
                    case 5:
                    	if((four_corner_coordinate_positions[5][0] + max >= borderWith)){
                    		max = 0;
                    	}
                    	break;
                    case 6:
                    	if((four_corner_coordinate_positions[6][0] - max <= 0)){
                    		max = 0;
                    	}
                    	break;
                    case 7:
                    	if((four_corner_coordinate_positions[7][1] + max >= borderHeight)){
                    		max = 0;
                    	}
                    	break;
                }
            }
        }
    
    
        static int max;
        
        /**
         * 扩大缩放方法
         * 根据用户传来的点改变其他点的坐标
         * 按住某一个点，该点的坐标改变，其他2个点坐标跟着改变，对边的点坐标不变
         * 点阵示意：
         * 0  4  1
         * 6     5
         * 2  7  3
         *
         * @param point   用户按的点
         * @param offsetX X轴偏移量
         * @param offsetY Y轴偏移量
         */
        private void changgeEightCoodinatePosition(int point, int offsetX, int offsetY) {
    
            switch (point) {
                case 0:
                    if ((offsetX > 0 && offsetY < 0) || (offsetX > 0 && offsetY > 0)) {
                        //变化0点的位置   suoxiao
                        four_corner_coordinate_positions[0][0] += max;
                        four_corner_coordinate_positions[0][1] += max;
                        //变化1点的Y轴
                        four_corner_coordinate_positions[1][1] += max;
                        //变化2点的X轴
                        four_corner_coordinate_positions[2][0] += max;
                        //变化4点的X轴，Y轴
                        four_corner_coordinate_positions[4][0] += max/2;
                        four_corner_coordinate_positions[4][1] += max;
                        //变化5点的Y轴
                        four_corner_coordinate_positions[5][1] += max/2;
                        //变化6点的X轴，Y轴
                        four_corner_coordinate_positions[6][0] += max;
                        four_corner_coordinate_positions[6][1] += max/2;
                        //变化7点的X轴
                        four_corner_coordinate_positions[7][0] += max/2;
                    } else{
                        //变化0点的位置   kuoda
                        four_corner_coordinate_positions[0][0] -= max;
                        four_corner_coordinate_positions[0][1] -= max;
                        //变化1点的Y轴
                        four_corner_coordinate_positions[1][1] -= max;
                        //变化2点的X轴
                        four_corner_coordinate_positions[2][0] -= max;
                        //变化4点的X轴，Y轴
                        four_corner_coordinate_positions[4][0] -= max/2;
                        four_corner_coordinate_positions[4][1] -= max;
                        //变化5点的Y轴
                        four_corner_coordinate_positions[5][1] -= max/2;
                        //变化6点的X轴，Y轴
                        four_corner_coordinate_positions[6][0] -= max;
                        four_corner_coordinate_positions[6][1] -= max/2;
                        //变化7点的X轴
                        four_corner_coordinate_positions[7][0] -= max/2;
                    } 
                    break;
                case 1:
                    if ((offsetX > 0 && offsetY < 0) || (offsetX > 0 && offsetY > 0)) {
                        //变化1点的位置
                        four_corner_coordinate_positions[1][0] += max;
                        four_corner_coordinate_positions[1][1] -= max;
                        //变化0点的Y轴
                        four_corner_coordinate_positions[0][1] -= max;
                        //变化3点的X轴
                        four_corner_coordinate_positions[3][0] += max;
                        //变化4点的X轴，Y轴
                        four_corner_coordinate_positions[4][0] += max/2;
                        four_corner_coordinate_positions[4][1] -= max;
                        //变化5点的X轴，Y轴
                        four_corner_coordinate_positions[5][0] += max;
                        four_corner_coordinate_positions[5][1] -= max/2;
                        //变化6点的Y轴
                        four_corner_coordinate_positions[6][1] -= max/2;
                        //变化7点的X轴，Y轴
                        four_corner_coordinate_positions[7][0] += max/2;
                        four_corner_coordinate_positions[7][1] += max;
                    } else if ((offsetX < 0 && offsetY > 0) || (offsetX < 0 && offsetY < 0)) {
                        //变化1点的位置
                        four_corner_coordinate_positions[1][0] -= max;
                        four_corner_coordinate_positions[1][1] += max;
                        //变化0点的Y轴
                        four_corner_coordinate_positions[0][1] += max;
                        //变化3点的X轴
                        four_corner_coordinate_positions[3][0] -= max;
                        //变化4点的X轴，Y轴
                        four_corner_coordinate_positions[4][0] -= max/2;
                        four_corner_coordinate_positions[4][1] += max;
                        //变化5点的X轴，Y轴
                        four_corner_coordinate_positions[5][0] -= max;
                        four_corner_coordinate_positions[5][1] += max/2;
                        //变化6点的Y轴
                        four_corner_coordinate_positions[6][1] += max/2;
                        //变化7点的X轴，Y轴
                        four_corner_coordinate_positions[7][0] -= max/2;
                        four_corner_coordinate_positions[7][1] -= max;
                    }
                    break;
                case 2:
                    if ((offsetX > 0 && offsetY < 0) || (offsetX > 0 && offsetY > 0)) {
                        //变化2点的位置   suoxiao
                        four_corner_coordinate_positions[2][0] += max;
                        four_corner_coordinate_positions[2][1] -= max;
                        //变化0点的X轴
                        four_corner_coordinate_positions[0][0] += max;
                        //变化3点的Y轴
                        four_corner_coordinate_positions[3][1] -= max;
                        //变化4点的X轴
                        four_corner_coordinate_positions[4][0] += max/2;
                        //变化5点的Y轴
                        four_corner_coordinate_positions[5][1] -= max/2;
                        //变化6点的Y轴
                        four_corner_coordinate_positions[6][1] -= max/2;
                        //变化7点的X轴,Y轴
                        four_corner_coordinate_positions[7][0] += max/2;
                        four_corner_coordinate_positions[7][1] -= max;
                    } else{
                        //变化2点的位置   kuoda
                        four_corner_coordinate_positions[2][0] -= max;
                        four_corner_coordinate_positions[2][1] += max;
                        //变化0点的X轴
                        four_corner_coordinate_positions[0][0] -= max;
                        //变化3点的Y轴
                        four_corner_coordinate_positions[3][1] += max;
                        //变化4点的X轴
                        four_corner_coordinate_positions[4][0] -= max/2;
                        //变化5点的Y轴
                        four_corner_coordinate_positions[5][1] += max/2;
                        //变化6点的Y轴
                        four_corner_coordinate_positions[6][1] += max/2;
                        //变化7点的X轴,Y轴
                        four_corner_coordinate_positions[7][0] -= max/2;
                        four_corner_coordinate_positions[7][1] += max;
                    } 
                    break;
                case 3:
                    if ((offsetX > 0 && offsetY < 0) || ((offsetX > 0 && offsetY > 0))) {
                        //变化3点的位置   kuoda
                        four_corner_coordinate_positions[3][0] += max;
                        four_corner_coordinate_positions[3][1] += max;
                        //变化1点的X轴
                        four_corner_coordinate_positions[1][0] += max;
                        //变化2点的Y轴
                        four_corner_coordinate_positions[2][1] += max;
                        //变化4点的X轴
                        four_corner_coordinate_positions[4][0] += max/2;
                        //变化5点的X轴,Y轴
                        four_corner_coordinate_positions[5][0] += max;
                        four_corner_coordinate_positions[5][1] += max/2;
                        //变化6点的Y轴
                        four_corner_coordinate_positions[6][1] += max/2;
                        //变化7点的X轴,Y轴
                        four_corner_coordinate_positions[7][0] += max/2;
                        four_corner_coordinate_positions[7][1] += max;
                    } else{
                        //变化3点的位置   suoxiao
                        four_corner_coordinate_positions[3][0] -= max;
                        four_corner_coordinate_positions[3][1] -= max;
                        //变化1点的X轴
                        four_corner_coordinate_positions[1][0] -= max;
                        //变化2点的Y轴
                        four_corner_coordinate_positions[2][1] -= max;
                        //变化4点的X轴
                        four_corner_coordinate_positions[4][0] -= max/2;
                        //变化5点的X轴,Y轴
                        four_corner_coordinate_positions[5][0] -= max;
                        four_corner_coordinate_positions[5][1] -= max/2;
                        //变化6点的Y轴
                        four_corner_coordinate_positions[6][1] -= max/2;
                        //变化7点的X轴,Y轴
                        four_corner_coordinate_positions[7][0] -= max/2;
                        four_corner_coordinate_positions[7][1] -= max;
                    }
                    break;
                case 4:
                	if(offsetY < 0){
                		//变化0点的位置
                        four_corner_coordinate_positions[0][1] -= max;
                        //变化1点的位置
                        four_corner_coordinate_positions[1][1] -= max;
                        //变化4点的位置
                        four_corner_coordinate_positions[4][1] -= max;
                        //变化5点的位置
                        four_corner_coordinate_positions[5][1] -= max/2;
                        //变化6点的位置
                        four_corner_coordinate_positions[6][1] -= max/2;
                	} else{
                		//变化0点的位置
                        four_corner_coordinate_positions[0][1] += max;
                        //变化1点的位置
                        four_corner_coordinate_positions[1][1] += max;
                        //变化4点的位置
                        four_corner_coordinate_positions[4][1] += max;
                        //变化5点的位置
                        four_corner_coordinate_positions[5][1] += max/2;
                        //变化6点的位置
                        four_corner_coordinate_positions[6][1] += max/2;
                	}
                	break;
                case 5:
                	if(offsetX < 0){
                		//变化1点的位置
                        four_corner_coordinate_positions[1][0] -= max;
                        //变化3点的位置
                        four_corner_coordinate_positions[3][0] -= max;
                        //变化4点的位置
                        four_corner_coordinate_positions[4][0] -= max/2;
                        //变化5点的位置
                        four_corner_coordinate_positions[5][0] -= max;
                        //变化7点的位置
                        four_corner_coordinate_positions[7][1] -= max/2;
                	} else{
                		//变化1点的位置
                        four_corner_coordinate_positions[1][0] += max;
                        //变化3点的位置
                        four_corner_coordinate_positions[3][0] += max;
                        //变化4点的位置
                        four_corner_coordinate_positions[4][0] += max/2;
                        //变化5点的位置
                        four_corner_coordinate_positions[5][0] += max;
                        //变化7点的位置
                        four_corner_coordinate_positions[7][1] += max/2;
                	}
                	break;
                case 6:
                	if(offsetX < 0){
                		//变化1点的位置
                        four_corner_coordinate_positions[0][0] -= max;
                        //变化2点的位置
                        four_corner_coordinate_positions[2][0] -= max;
                        //变化4点的位置
                        four_corner_coordinate_positions[4][0] -= max/2;
                        //变化6点的位置
                        four_corner_coordinate_positions[6][0] -= max;
                        //变化7点的位置
                        four_corner_coordinate_positions[7][0] -= max/2;
                	} else{
                		//变化1点的位置
                        four_corner_coordinate_positions[0][0] += max;
                        //变化2点的位置
                        four_corner_coordinate_positions[2][0] += max;
                        //变化4点的位置
                        four_corner_coordinate_positions[4][0] += max/2;
                        //变化6点的位置
                        four_corner_coordinate_positions[6][0] += max;
                        //变化7点的位置
                        four_corner_coordinate_positions[7][0] += max/2;
                	}
                	break;
                case 7:
                	if(offsetY < 0){
                		//变化2点的位置
                        four_corner_coordinate_positions[2][1] -= max;
                        //变化3点的位置
                        four_corner_coordinate_positions[3][1] -= max;
                        //变化5点的位置
                        four_corner_coordinate_positions[5][1] -= max/2;
                        //变化6点的位置
                        four_corner_coordinate_positions[6][1] -= max/2;
                        //变化7点的位置
                        four_corner_coordinate_positions[7][1] -= max;
                	} else{
                		//变化2点的位置
                        four_corner_coordinate_positions[2][1] += max;
                        //变化3点的位置
                        four_corner_coordinate_positions[3][1] += max;
                        //变化5点的位置
                        four_corner_coordinate_positions[5][1] += max/2;
                        //变化6点的位置
                        four_corner_coordinate_positions[6][1] += max/2;
                        //变化7点的位置
                        four_corner_coordinate_positions[7][1] += max;
                	}
                	break;
            }
    
        }
    
        /**
         * 扩大缩放方法
         * 根据用户传来的点改变其他点的坐标
         * 按住某一个点，该点的坐标改变，其他2个点坐标跟着改变，对点坐标不变
         * 点阵示意：
         * 0   1
         * 2   3
         *
         * @param point   用户按的点
         * @param offsetX X轴偏移量
         * @param offsetY Y轴偏移量
         */
        private void changgeFourCoodinatePosition(int point, int offsetX, int offsetY) {
    
            switch (point) {
                case 0:
                    if (offsetX > 0 && offsetY < 0) {
                        //变化0点的位置   suoxiao
                        four_corner_coordinate_positions[0][0] += max;
                        four_corner_coordinate_positions[0][1] += max;
                        //变化1点的Y轴
                        four_corner_coordinate_positions[1][1] += max;
                        //变化2点的X轴
                        four_corner_coordinate_positions[2][0] += max;
                    } else if (offsetX < 0 && offsetY > 0) {
                        //变化0点的位置   kuoda
                        four_corner_coordinate_positions[0][0] -= max;
                        four_corner_coordinate_positions[0][1] -= max;
                        //变化1点的Y轴
                        four_corner_coordinate_positions[1][1] -= max;
                        //变化2点的X轴
                        four_corner_coordinate_positions[2][0] -= max;
                    } else if (offsetX < 0 && offsetY < 0) {
                        //变化0点的位置   kuoda
                        four_corner_coordinate_positions[0][0] -= max;
                        four_corner_coordinate_positions[0][1] -= max;
                        //变化1点的Y轴
                        four_corner_coordinate_positions[1][1] -= max;
                        //变化2点的X轴
                        four_corner_coordinate_positions[2][0] -= max;
                    } else if (offsetX > 0 && offsetY > 0) {
                        //变化0点的位置   suoxiao
                        four_corner_coordinate_positions[0][0] += max;
                        four_corner_coordinate_positions[0][1] += max;
                        //变化1点的Y轴
                        four_corner_coordinate_positions[1][1] += max;
                        //变化2点的X轴
                        four_corner_coordinate_positions[2][0] += max;
                    }
                    break;
                case 1:
                    if (offsetX > 0 && offsetY < 0) {
                        //变化1点的位置
                        four_corner_coordinate_positions[1][0] += max;
                        four_corner_coordinate_positions[1][1] -= max;
                        //变化0点的Y轴
                        four_corner_coordinate_positions[0][1] -= max;
                        //变化3点的X轴
                        four_corner_coordinate_positions[3][0] += max;
                    } else if (offsetX < 0 && offsetY > 0) {
                        //变化1点的位置
                        four_corner_coordinate_positions[1][0] -= max;
                        four_corner_coordinate_positions[1][1] += max;
                        //变化0点的Y轴
                        four_corner_coordinate_positions[0][1] += max;
                        //变化3点的X轴
                        four_corner_coordinate_positions[3][0] -= max;
                    } else if (offsetX < 0 && offsetY < 0) {
                        //变化1点的位置
                        four_corner_coordinate_positions[1][0] -= max;
                        four_corner_coordinate_positions[1][1] += max;
                        //变化0点的Y轴
                        four_corner_coordinate_positions[0][1] += max;
                        //变化3点的X轴
                        four_corner_coordinate_positions[3][0] -= max;
                    } else if (offsetX > 0 && offsetY > 0) {
                        //变化1点的位置
                        four_corner_coordinate_positions[1][0] += max;
                        four_corner_coordinate_positions[1][1] -= max;
                        //变化0点的Y轴
                        four_corner_coordinate_positions[0][1] -= max;
                        //变化3点的X轴
                        four_corner_coordinate_positions[3][0] += max;
                    }
                    break;
                case 2:
                    if (offsetX > 0 && offsetY < 0) {
                        //变化2点的位置   suoxiao
                        four_corner_coordinate_positions[2][0] += max;
                        four_corner_coordinate_positions[2][1] -= max;
                        //变化0点的X轴
                        four_corner_coordinate_positions[0][0] += max;
                        //变化3点的Y轴
                        four_corner_coordinate_positions[3][1] -= max;
                    } else if (offsetX < 0 && offsetY > 0) {
                        //变化2点的位置   kuoda
                        four_corner_coordinate_positions[2][0] -= max;
                        four_corner_coordinate_positions[2][1] += max;
                        //变化0点的X轴
                        four_corner_coordinate_positions[0][0] -= max;
                        //变化3点的Y轴
                        four_corner_coordinate_positions[3][1] += max;
                    } else if (offsetX < 0 && offsetY < 0) {
                        //变化2点的位置   kuoda
                        four_corner_coordinate_positions[2][0] -= max;
                        four_corner_coordinate_positions[2][1] += max;
                        //变化0点的X轴
                        four_corner_coordinate_positions[0][0] -= max;
                        //变化3点的Y轴
                        four_corner_coordinate_positions[3][1] += max;
                    } else if (offsetX > 0 && offsetY > 0) {
                        //变化2点的位置   suoxiao
                        four_corner_coordinate_positions[2][0] += max;
                        four_corner_coordinate_positions[2][1] -= max;
                        //变化0点的X轴
                        four_corner_coordinate_positions[0][0] += max;
                        //变化3点的Y轴
                        four_corner_coordinate_positions[3][1] -= max;
                    }
                    break;
                case 3:
                    if (offsetX > 0 && offsetY < 0) {
                        //变化3点的位置   kuoda
                        four_corner_coordinate_positions[3][0] += max;
                        four_corner_coordinate_positions[3][1] += max;
                        //变化1点的X轴
                        four_corner_coordinate_positions[1][0] += max;
                        //变化2点的Y轴
                        four_corner_coordinate_positions[2][1] += max;
                    } else if (offsetX < 0 && offsetY > 0) {
                        //变化3点的位置   suoxiao
                        four_corner_coordinate_positions[3][0] -= max;
                        four_corner_coordinate_positions[3][1] -= max;
                        //变化1点的X轴
                        four_corner_coordinate_positions[1][0] -= max;
                        //变化2点的Y轴
                        four_corner_coordinate_positions[2][1] -= max;
                    } else if (offsetX < 0 && offsetY < 0) {
                        //变化3点的位置   suoxiao
                        four_corner_coordinate_positions[3][0] -= max;
                        four_corner_coordinate_positions[3][1] -= max;
                        //变化1点的X轴
                        four_corner_coordinate_positions[1][0] -= max;
                        //变化2点的Y轴
                        four_corner_coordinate_positions[2][1] -= max;
                    } else if (offsetX > 0 && offsetY > 0) {
                        //变化3点的位置   kuoda
                        four_corner_coordinate_positions[3][0] += max;
                        four_corner_coordinate_positions[3][1] += max;
                        //变化1点的X轴
                        four_corner_coordinate_positions[1][0] += max;
                        //变化2点的Y轴
                        four_corner_coordinate_positions[2][1] += max;
                    }
                    break;
            }
    
        }
    
        /**
         * 判断按下的点在圆圈内
         *
         * @param x 按下的X坐标
         * @param y 按下的Y坐标
         * @return 返回按到的是哪个点, 没有则返回-1
         * 点阵示意：
         * 0   1
         * 2   3
         */
        private int isInTheCornerCircle(float x, float y) {
            for (int i = 0; i < four_corner_coordinate_positions.length; i++) {
                float a = four_corner_coordinate_positions[i][0];
                float b = four_corner_coordinate_positions[i][1];
                float temp1 = (float) Math.pow((x - a), 2);
                float temp2 = (float) Math.pow((y - b), 2);
                if (((float) RECT_CORNER_HEIGHT) >= Math.sqrt(temp1 + temp2)) {
                    return i;
                }
            }
            return -1;
        }
    
        public interface onImageDetailsSizeChangged {
            void onBorderSizeChangged(int x, int y, int length);
        }
    
        public onImageDetailsSizeChangged onImageDetailsSizeChanggedl;
    
        public void setonImageDetailsSizeChangged(onImageDetailsSizeChangged onImageDetailsSizeChangged) {
            this.onImageDetailsSizeChanggedl = onImageDetailsSizeChangged;
        }
    
    	public float getImageHeight() {
    		return imageHeight;
    	}
    
    	public void setImageHeight(float imageHeight) {
    		this.imageHeight = imageHeight;
    	}
    
    	public float getImageWidth() {
    		return imageWidth;
    	}
    
    	public void setImageWidth(float imageWidth) {
    		this.imageWidth = imageWidth;
    	}
    
    	public float getImageTranslateX() {
    		return imageTranslateX;
    	}
    
    	public void setImageTranslateX(float imageTranslateX) {
    		this.imageTranslateX = imageTranslateX;
    	}
    
    	public float getImageTranslateY() {
    		return imageTranslateY;
    	}
    
    	public void setImageTranslateY(float imageTranslateY) {
    		this.imageTranslateY = imageTranslateY;
    	}
    	
    }

[Center]: /images/20220711/2d9d941c43974b5381dca47ec06c1e87.png