精华内容
下载资源
问答
  • 本文提供了使用JAVA判断凸多边形的示例代码供大家参考学习,需要的朋友可以看一下
  • 已知四边形(凸四边形)的四个点A、B、C、D(按逆时针顺序)的坐标,求点P是否在ABCD所围成的四边形内,可以通过向量叉乘的方法实现。        原文来自:...

           已知四边形(凸四边形)的四个点A、B、C、D(按逆时针顺序)的坐标,求点P是否在ABCD所围成的四边形内,可以通过向量叉乘的方法实现。

           原文来自:http://www.dewen.io/q/5805/Android

    先提供一种简单情景(假定四边形是一个凸四边形)的解决方法:

           原理:凸多边形内部的点都在凸多边形的边所在的向量的同一侧(前提是计算边所在的向量时采用的是同一个方向,同为顺时针或者同为逆时针),利用叉积求解。
           假设四边形四个顶点依次为A(x1,y1),B(x2,y2),C(x3,y3),D(x4,y4),待判断的点为P(x,y),如果点P在四边形内部,则向量AB * AP(注意:1.这是求叉积;2.AB、AP均为向量,也就等于(x2-x1) * (y-y1)-(y2-y1) * (x-x1))的值与BC*BP、CD * CP、DA * DP的值同号(若有等于零的情况,则表示P在边上,可以根据自己的喜好把它当做是内部或者外部),即四个值同为正或者同为负,则点P在ABCD内部,否则在外部。
           如果是凹四边形还要做一些其他处理,就是找到导致四边形为凹的那个顶点,也是借助于叉积(可以参考我的博客:http://tristan-xi.org/?p=113 (可惜博客已失效),只需记录中间哪个点所求的向量叉积与其它几点异号即可),然后把四边形分成两个三角形(三角形肯定是凸的了),再按照上面的方法计算叉积,即可解决。
           总结:叉积是判断多边形凹凸性以及点是否在凸多边形内部的利器。

           向量AB:(B.x - A.x , B.y - A.y);

           向量AP:(P.x - A.x , P.y - A.y);

           向量叉乘: ABxAP = (B.x - A.x) * (P.y - A.y) - (B.y - A.y) * (P.x - A.x);

    
     
    1. private boolean isPointInRect(int x, int y) {
    2. final Point A = mLBPoint;
    3. final Point B = mLTPoint;
    4. final Point C = mRTPoint;
    5. final Point D = mRBPoint;
    6. final int a = (B.x - A.x)*(y - A.y) - (B.y - A.y)*(x - A.x);
    7. final int b = (C.x - B.x)*(y - B.y) - (C.y - B.y)*(x - B.x);
    8. final int c = (D.x - C.x)*(y - C.y) - (D.y - C.y)*(x - C.x);
    9. final int d = (A.x - D.x)*(y - D.y) - (A.y - D.y)*(x - D.x);
    10. if((a > 0 && b > 0 && c > 0 && d > 0) || (a < 0 && b < 0 && c < 0 && d < 0)) {
    11. return true;
    12. }
    13. // AB X AP = (b.x - a.x, b.y - a.y) x (p.x - a.x, p.y - a.y) = (b.x - a.x) * (p.y - a.y) - (b.y - a.y) * (p.x - a.x);
    14. // BC X BP = (c.x - b.x, c.y - b.y) x (p.x - b.x, p.y - b.y) = (c.x - b.x) * (p.y - b.y) - (c.y - b.y) * (p.x - b.x);
    15. return false;
    16. }

    转载自:https://blog.csdn.net/laukaka/article/details/45168439

    展开全文
  • 计算当前四边形是否为凸四边形

    千次阅读 2017-04-07 16:09:34
    下面算法为计算四边形是否为凸四边形,算法摘自gimp。

           发现自己的evernote保存了很多黑科技小算法,都忘记是什么时候摘录的。因为以前上学时做过图形学相关工作,下面算法为计算四边形是否为凸四边形,算法摘自gimp(https://www.gimp.org/)。关于gimp大家可以自行去查阅,也可以翻翻gimp的源码。编程水平提高,不是一味的多写代码就可以,还要时不时的看看高质量的开源代码,分析他们的代码组织方式,命名方式,逻辑调用方式,相信自己的水平也会跟着提高。下面是相关c代码:

    bool gimp_transform_polygon_is_convex(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
    {
    	double z1, z2, z3, z4;
    
    	z1 = ((x2 - x1) * (y4 - y1) - (x4 - x1) * (y2 - y1));
    	z2 = ((x4 - x1) * (y3 - y1) - (x3 - x1) * (y4 - y1));
    	z3 = ((x4 - x2) * (y3 - y2) - (x3 - x2) * (y4 - y2));
    	z4 = ((x3 - x2) * (y1 - y2) - (x1 - x2) * (y3 - y2));
    
    	return (z1 * z2 > 0) && (z3 * z4 > 0);
    }
    
    int main()
    {
    	double x1 = 10.0, y1 = 10.0;
    	double x2 = 50.0, y2 = 10.0;
    	double x3 = 10.0, y3 = 50.0;
    	double x4 = 35.0, y4 = 30.0;
    	bool result = gimp_transform_polygon_is_convex(x1, y1, x2, y2, x3, y3, x4, y4);
    
    	printf("result: %d\n", result);
    	system("pause");
    	return 0;
    }
            上面示例中,当x4小于等于30时,比如取值29,result输出为0,即非凸四边形。当x4大于30时,比如上面的取值35,result输出为1,即凸四边形。




    展开全文
  • 判断点在凸四边形

    2011-02-12 10:14:00
    #import #import "cocos2d.h" @interface MTQuadrilateral : CCNode { //左下角 CGPoint point_lb; //左上角 CGPoint point_lt; //右上角 CGPoint point_rt; ...@

     

     

     

    展开全文
  • 1.实现可移动的凸四边形view package com.viking.qynet; import android.content.Context; import android.graphics.Canvas; import android.graphics.Paint; import android.support.annotation.Nullable; import...

    1.实现可移动的凸四边形view

    package com.viking.qynet;
    
    import android.content.Context;
    import android.graphics.Canvas;
    import android.graphics.Paint;
    import android.support.annotation.Nullable;
    import android.util.AttributeSet;
    import android.util.Log;
    import android.view.MotionEvent;
    import android.view.View;
    
    import com.viking.bean.TLine;
    import com.viking.bean.TPoint;
    import com.viking.bean.TVideoDetectParamSetup;
    import com.viking.myapplication.Utils;
    
    /**
     * Created by 25934 on 2017/11/3.
     */
    
    public class MyView extends View {
        private String TAG = "--------";
        private Paint mPaint = null;
        private Paint mCirclePaint = null;
        float max_width, max_height;
        float A_x, A_y, B_x, B_y, C_x, C_y, D_x, D_y;
        float E1_x, E1_y, E2_x, E2_y = 0;
        float K1, K2;
        float K_Max = Float.MAX_VALUE;
        float radius = 10;
        float radius_add = radius + 10;
        float next = 20;
        private TLine mB_cLine;
    
        public MyView(Context context) {
            this(context, null);
        }
    
        public MyView(Context context, @Nullable AttributeSet attrs) {
            super(context, attrs);
            mPaint = new Paint();
            mPaint.setStyle(Paint.Style.STROKE);
            mPaint.setStrokeWidth(3);
            mPaint.setAntiAlias(true);
            mCirclePaint = new Paint();
            mCirclePaint.setStyle(Paint.Style.FILL);
            mCirclePaint.setStrokeWidth(radius);
            mCirclePaint.setAntiAlias(true);
            mCirclePaint.setARGB(255, 69, 125, 125);
            Log.e(TAG, "MyView: ");
    
        }
        float xRatio = 0;
        float yRatio = 0;
        public void setInItData(TVideoDetectParamSetup setup){
            xRatio = max_width/1920;
            Log.e(TAG, "setInItData: max_width"+max_width);
            yRatio =max_height/1080;
            A_x = setup.getAtPlateRegion4()[0].x*xRatio;
            A_y = setup.getAtPlateRegion4()[0].y*yRatio;
            B_x = setup.getAtPlateRegion4()[1].x*xRatio;
            B_y = setup.getAtPlateRegion4()[1].y*yRatio;
            C_x = setup.getAtPlateRegion4()[2].x*xRatio;
            C_y = setup.getAtPlateRegion4()[2].y*yRatio;
            D_x = setup.getAtPlateRegion4()[3].x*xRatio;
            D_y = setup.getAtPlateRegion4()[3].y*yRatio;
            E1_x = setup.getaStopLine().tStartPoint.x*xRatio;
            E1_y = setup.getaStopLine().tStartPoint.y*yRatio;
            E2_x = setup.getaStopLine().tEndPoint.x*xRatio;
            E2_y = setup.getaStopLine().tEndPoint.y*yRatio;
            Log.e(TAG, "setInItData:  A("+A_x+","+A_y+")  B("+B_x+","+B_y+")  C("+C_x+","+C_y+")  D("+D_x+","+D_y+")  E1("+E1_x+","+E1_y+")  E2("+E2_x+","+E2_y+")");
            if (A_x == C_x) { //a c两点为竖线
                K1 = (A_y - E1_y) / (E1_y - C_y);
            } else if (A_y == C_y) { //a c点为横线
                K1 = (A_x - E1_x) / (E1_x - C_x);
            } else {
                K1 = (A_x - E1_x) / (E1_x - C_x);
            }
            if (B_x == D_x) { //a c两点为竖线
                K2 = (B_y - E2_y) / (E2_y - D_y);
            } else if (B_y == D_y) { //a c点为横线
                K2 = (B_x - E2_x) / (E2_x - D_x);
            } else {
                K2 = (B_x - E2_x) / (E2_x - D_x);
            }
            invalidate();
        }
        @Override
        protected void onSizeChanged(int w, int h, int oldw, int oldh) {
            A_x = w / 4;
            A_y = h / 4;
            B_x = w * 3 / 4;
            B_y = h * 1 / 4;
            C_x = w / 4;
            C_y = h * 3 / 4;
            D_x = w * 3 / 4;
            D_y = h * 3 / 4;
            E1_x = w / 4;
            E1_y = h / 2;
            E2_x = w * 3 / 4;
            E2_y = h / 2;
            if (A_x == C_x) { //a c两点为竖线
                K1 = (A_y - E1_y) / (E1_y - C_y);
            } else if (A_y == C_y) { //a c点为横线
                K1 = (A_x - E1_x) / (E1_x - C_x);
            } else {
                K1 = (A_x - E1_x) / (E1_x - C_x);
            }
            if (B_x == D_x) { //a c两点为竖线
                K2 = (B_y - E2_y) / (E2_y - D_y);
            } else if (B_y == D_y) { //a c点为横线
                K2 = (B_x - E2_x) / (E2_x - D_x);
            } else {
                K2 = (B_x - E2_x) / (E2_x - D_x);
            }
            Log.e(TAG, "onSizeChanged: k1:" + K1 + " k2:" + K2);
            max_width = this.getMeasuredWidth();
            max_height = this.getMeasuredHeight();
            Log.e(TAG, "onSizeChanged: ");
        }
    
        @Override
        protected void onDraw(Canvas canvas) {
            Log.e(TAG, "onDraw: ");
            //计算k
            initCircle(canvas);
            initLine(canvas);
    
        }
    
        private void initLine(Canvas canvas) {
            canvas.drawLine(A_x, A_y, B_x, B_y, mPaint);
            canvas.drawLine(A_x, A_y, C_x, C_y, mPaint);
            canvas.drawLine(B_x, B_y, D_x, D_y, mPaint);
            canvas.drawLine(C_x, C_y, D_x, D_y, mPaint);
            canvas.drawLine(E1_x, E1_y, E2_x, E2_y, mPaint);
        }
    
        private void initCircle(Canvas canvas) {
            //画四个小圆
            canvas.drawCircle(A_x, A_y, radius, mCirclePaint);
            canvas.drawCircle(B_x, B_y, radius, mCirclePaint);
            canvas.drawCircle(C_x, C_y, radius, mCirclePaint);
            canvas.drawCircle(D_x, D_y, radius, mCirclePaint);
            canvas.drawCircle(E1_x, E1_y, radius, mCirclePaint);
            canvas.drawCircle(E2_x, E2_y, radius, mCirclePaint);
        }
    
        public void startTick() {
            Log.e(TAG, "startTick: ");
            invalidate();
        }
    
        private boolean DA = false;
        private boolean DB = false;
        private boolean DC = false;
        private boolean DD = false;
        private boolean E1 = false;
        private boolean E2 = false;
        private int MOVE = 0;
        private int aciton_up = 0;
    
        @Override
        public boolean onTouchEvent(MotionEvent event) {
            float x = event.getX();
            float y = event.getY();
            switch (event.getAction()) {
                case MotionEvent.ACTION_DOWN: {
                    aciton_up = 0;
                    Log.e(TAG, "onTouchEvent: ACTION_DOWN");
                    if (x < max_width && y < max_height) { //判断点击是否在view.
                        if (x <= A_x + radius_add && x >= A_x - radius_add && y <= A_y + radius_add && y >= A_y - radius_add) {  //A                        DA = true;
                            DB = false;
                            DC = false;
                            DD = false;
                        } else if (x <= B_x + radius_add && x >= B_x - radius_add && y <= B_y + radius_add && y >= B_y - radius_add) { //B                        DA = false;
                            DB = true;
                            DC = false;
                            DD = false;
                        } else if (x <= C_x + radius_add && x >= C_x - radius_add && y <= C_y + radius_add && y >= C_y - radius_add) { //C                        DA = false;
                            DB = false;
                            DC = true;
                            DD = false;
                        } else if (x <= D_x + radius_add && x >= D_x - radius_add && y <= D_y + radius_add && y >= D_y - radius_add) { //D                        DA = false;
                            DB = false;
                            DC = false;
                            DD = true;
                        } else if (x <= E1_x + radius_add && x >= E1_x - radius_add && y <= E1_y + radius_add && y >= E1_y - radius_add) { //点击空白处
                            DA = false;
                            DB = false;
                            DC = false;
                            DD = false;
                            E1 = true;
                            E2 = false;
                        } else if (x <= E2_x + radius_add && x >= E2_x - radius_add && y <= E2_y + radius_add && y >= E2_y - radius_add) {
                            DA = false;
                            DB = false;
                            DC = false;
                            DD = false;
                            E1 = false;
                            E2 = true;
                        } else {
                            DA = false;
                            DB = false;
                            DC = false;
                            DD = false;
                            E1 = false;
                            E2 = false;
                            return false;
                        }
                    } else {  //点击view之外
                        DA = false;
                        DB = false;
                        DC = false;
                        DD = false;
                        E1 = false;
                        E2 = false;
                        return false;
                    }
                }
                case MotionEvent.ACTION_MOVE: {
                    aciton_up = 0;
                    Log.e(TAG, "onTouchEvent: ACTION_MOVE");
                    if (x < max_width && y < max_height) {  //点击移动在view之中
                        if (DA && Math.abs(y - C_y) <= max_height / 2 && Math.abs(y - D_y) <= max_height / 2) {
                            TTPoint aPoint = new TTPoint(x, y);
                            TTPoint bPoint = new TTPoint(B_x, B_y);
                            TTPoint cPoint = new TTPoint(C_x, C_y);
                            TTPoint dPoint = new TTPoint(D_x, D_y);
                            TTLine mB_cLine = new TTLine(bPoint, cPoint);
                            TTLine a_dLine = new TTLine(aPoint, dPoint);
                            if (MOVE == 0) {
                                if (Utils.isPointUpLine(aPoint, mB_cLine)) {
                                    Log.e(TAG, "onTouchEvent: Move=1");
                                    MOVE = 1;
                                } else {
                                    Log.e(TAG, "onTouchEvent: Move=2");
                                    MOVE = 2;
                                }
                            }
    
                            if (Utils.isPointUpLine(aPoint, mB_cLine) && MOVE == 1) { // A点在bc上面
                                if (Utils.pointToLine(aPoint, mB_cLine) >= 15 && Utils.pointToLine(bPoint, a_dLine) >= 15 && Utils.pointToLine(cPoint, a_dLine) >= 15) {
                                    if (Utils.isPointUpLine(bPoint, a_dLine) && Utils.isPointDownLine(cPoint, a_dLine)) { //b点在ad上面,c点在ad下面
                                        if (E1_x - C_x == 0 && A_x - C_x == 0) {  //之前为垂直
                                            float ey = C_y + (E1_y - C_y) / (A_y - C_y) * (y - C_y);
                                            //求出两条直线的焦点
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E1_x, ey),
                                                    new TTPoint(E2_x, E2_y)), new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 11111111111111");
                                        } else if (E1_y - C_y == 0 && A_y - C_y == 0) {
                                            float ex = C_x + (E1_x - C_x) / (A_x - C_x) * (x - C_x);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E1_y), new TTPoint(E2_x, E2_y)),
                                                    new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 2222222222222");
                                        } else {
                                            float ex = C_x + (E1_x - C_x) / (A_x - C_x) * (x - C_x);
                                            float ey = C_y + (E1_y - C_y) / (A_y - C_y) * (y - C_y);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E2_x, E2_y)),
                                                    new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 3333333333333");
                                        }
                                        A_x = x;
                                        A_y = y;
                                        Log.e(TAG, "onTouchEvent: e1x:" + E1_x + "e1y:" + E1_y);
                                    } else if (Utils.isPointDownLine(bPoint, a_dLine) && Utils.isPointUpLine(cPoint, a_dLine)) {
                                        if (E1_x - C_x == 0 && A_x - C_x == 0) {  //之前为垂直
                                            float ey = C_y + (E1_y - C_y) / (A_y - C_y) * (y - C_y);
                                            //求出两条直线的焦点
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E1_x, ey),
                                                    new TTPoint(E2_x, E2_y)), new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 11111111111111");
                                        } else if (E1_y - C_y == 0 && A_y - C_y == 0) {
                                            float ex = C_x + (E1_x - C_x) / (A_x - C_x) * (x - C_x);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E1_y), new TTPoint(E2_x, E2_y)),
                                                    new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 2222222222222");
                                        } else {
                                            float ex = C_x + (E1_x - C_x) / (A_x - C_x) * (x - C_x);
                                            float ey = C_y + (E1_y - C_y) / (A_y - C_y) * (y - C_y);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E2_x, E2_y)),
                                                    new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 3333333333333");
                                        }
                                        A_x = x;
                                        A_y = y;
                                        Log.e(TAG, "onTouchEvent: ");
                                    } else {
                                        Log.e(TAG, "onTouchEvent: ");
                                    }
                                } else {
                                    if (x < A_x && y < A_y) {
                                        if (Utils.isPointUpLine(bPoint, a_dLine) && Utils.isPointDownLine(cPoint, a_dLine)) { //
                                            if (E1_x - C_x == 0 && A_x - C_x == 0) {  //之前为垂直
                                                float ey = C_y + (E1_y - C_y) / (A_y - C_y) * (y - C_y);
                                                //求出两条直线的焦点
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E1_x, ey),
                                                        new TTPoint(E2_x, E2_y)), new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 11111111111111");
                                            } else if (E1_y - C_y == 0 && A_y - C_y == 0) {
                                                float ex = C_x + (E1_x - C_x) / (A_x - C_x) * (x - C_x);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E1_y), new TTPoint(E2_x, E2_y)),
                                                        new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 2222222222222");
                                            } else {
                                                float ex = C_x + (E1_x - C_x) / (A_x - C_x) * (x - C_x);
                                                float ey = C_y + (E1_y - C_y) / (A_y - C_y) * (y - C_y);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E2_x, E2_y)),
                                                        new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 3333333333333");
                                            }
                                            A_x = x;
                                            A_y = y;
                                            Log.e(TAG, "onTouchEvent: ");
                                        } else if (Utils.isPointDownLine(bPoint, a_dLine) && Utils.isPointUpLine(cPoint, a_dLine)) {
                                            if (E1_x - C_x == 0 && A_x - C_x == 0) {  //之前为垂直
                                                float ey = C_y + (E1_y - C_y) / (A_y - C_y) * (y - C_y);
                                                //求出两条直线的焦点
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E1_x, ey),
                                                        new TTPoint(E2_x, E2_y)), new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 11111111111111");
                                            } else if (E1_y - C_y == 0 && A_y - C_y == 0) {
                                                float ex = C_x + (E1_x - C_x) / (A_x - C_x) * (x - C_x);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E1_y), new TTPoint(E2_x, E2_y)),
                                                        new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 2222222222222");
                                            } else {
                                                float ex = C_x + (E1_x - C_x) / (A_x - C_x) * (x - C_x);
                                                float ey = C_y + (E1_y - C_y) / (A_y - C_y) * (y - C_y);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E2_x, E2_y)),
                                                        new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 3333333333333");
                                            }
                                            A_x = x;
                                            A_y = y;
                                            Log.e(TAG, "onTouchEvent: ");
                                        } else {
                                            Log.e(TAG, "onTouchEvent: ");
                                        }
                                    } else {
                                        Log.e(TAG, "onTouchEvent: ");
                                    }
    
                                }
    
                            } else if (!Utils.isPointUpLine(aPoint, mB_cLine) && MOVE == 2) { //A点在bc下面
                                if (Utils.pointToLine(aPoint, mB_cLine) >= 15 && Utils.pointToLine(bPoint, a_dLine) >= 15 && Utils.pointToLine(cPoint, a_dLine) >= 15) {
                                    if (Utils.isPointDownLine(bPoint, a_dLine) && Utils.isPointUpLine(cPoint, a_dLine)) {
                                        if (E1_x - C_x == 0 && A_x - C_x == 0) {  //之前为垂直
                                            float ey = C_y + (E1_y - C_y) / (A_y - C_y) * (y - C_y);
                                            //求出两条直线的焦点
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E1_x, ey),
                                                    new TTPoint(E2_x, E2_y)), new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 11111111111111");
                                        } else if (E1_y - C_y == 0 && A_y - C_y == 0) {
                                            float ex = C_x + (E1_x - C_x) / (A_x - C_x) * (x - C_x);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E1_y), new TTPoint(E2_x, E2_y)),
                                                    new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 2222222222222");
                                        } else {
                                            float ex = C_x + (E1_x - C_x) / (A_x - C_x) * (x - C_x);
                                            float ey = C_y + (E1_y - C_y) / (A_y - C_y) * (y - C_y);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E2_x, E2_y)),
                                                    new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 3333333333333");
                                        }
                                        A_x = x;
                                        A_y = y;
                                        Log.e(TAG, "onTouchEvent: ");
                                    } else if (Utils.isPointUpLine(bPoint, a_dLine) && Utils.isPointDownLine(cPoint, a_dLine)) {
                                        if (E1_x - C_x == 0 && A_x - C_x == 0) {  //之前为垂直
                                            float ey = C_y + (E1_y - C_y) / (A_y - C_y) * (y - C_y);
                                            //求出两条直线的焦点
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E1_x, ey),
                                                    new TTPoint(E2_x, E2_y)), new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 11111111111111");
                                        } else if (E1_y - C_y == 0 && A_y - C_y == 0) {
                                            float ex = C_x + (E1_x - C_x) / (A_x - C_x) * (x - C_x);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E1_y), new TTPoint(E2_x, E2_y)),
                                                    new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 2222222222222");
                                        } else {
                                            float ex = C_x + (E1_x - C_x) / (A_x - C_x) * (x - C_x);
                                            float ey = C_y + (E1_y - C_y) / (A_y - C_y) * (y - C_y);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E2_x, E2_y)),
                                                    new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 3333333333333");
                                        }
                                        A_x = x;
                                        A_y = y;
                                        Log.e(TAG, "onTouchEvent: ");
                                    } else {
                                        Log.e(TAG, "onTouchEvent: ");
                                    }
                                } else {
                                    if (x > A_x && y > A_y) {
                                        if (Utils.isPointDownLine(bPoint, a_dLine) && Utils.isPointUpLine(cPoint, a_dLine)) {
                                            if (E1_x - C_x == 0 && A_x - C_x == 0) {  //之前为垂直
                                                float ey = C_y + (E1_y - C_y) / (A_y - C_y) * (y - C_y);
                                                //求出两条直线的焦点
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E1_x, ey),
                                                        new TTPoint(E2_x, E2_y)), new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 11111111111111");
                                            } else if (E1_y - C_y == 0 && A_y - C_y == 0) {
                                                float ex = C_x + (E1_x - C_x) / (A_x - C_x) * (x - C_x);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E1_y), new TTPoint(E2_x, E2_y)),
                                                        new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 2222222222222");
                                            } else {
                                                float ex = C_x + (E1_x - C_x) / (A_x - C_x) * (x - C_x);
                                                float ey = C_y + (E1_y - C_y) / (A_y - C_y) * (y - C_y);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E2_x, E2_y)),
                                                        new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 3333333333333");
                                            }
                                            A_x = x;
                                            A_y = y;
                                            Log.e(TAG, "onTouchEvent: ");
                                        } else if (Utils.isPointUpLine(bPoint, a_dLine) && Utils.isPointDownLine(cPoint, a_dLine)) {
                                            if (E1_x - C_x == 0 && A_x - C_x == 0) {  //之前为垂直
                                                float ey = C_y + (E1_y - C_y) / (A_y - C_y) * (y - C_y);
                                                //求出两条直线的焦点
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E1_x, ey),
                                                        new TTPoint(E2_x, E2_y)), new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 11111111111111");
                                            } else if (E1_y - C_y == 0 && A_y - C_y == 0) {
                                                float ex = C_x + (E1_x - C_x) / (A_x - C_x) * (x - C_x);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E1_y), new TTPoint(E2_x, E2_y)),
                                                        new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 2222222222222");
                                            } else {
                                                float ex = C_x + (E1_x - C_x) / (A_x - C_x) * (x - C_x);
                                                float ey = C_y + (E1_y - C_y) / (A_y - C_y) * (y - C_y);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E2_x, E2_y)),
                                                        new TTLine(new TTPoint(A_x, A_y), new TTPoint(C_x, C_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 3333333333333");
                                            }
                                            A_x = x;
                                            A_y = y;
                                            Log.e(TAG, "onTouchEvent: ");
                                        } else {
                                            Log.e(TAG, "onTouchEvent: ");
                                        }
                                    }
                                }
                            }
    
                        } else if (DB && Math.abs(y - C_y) <= max_height / 2 && Math.abs(y - D_y) <= max_height / 2) {
                            TTPoint aPoint = new TTPoint(A_x, A_y);
                            TTPoint bPoint = new TTPoint(x, y);
                            TTPoint cPoint = new TTPoint(C_x, C_y);
                            TTPoint dPoint = new TTPoint(D_x, D_y);
                            TTLine a_dLine = new TTLine(aPoint, dPoint);
                            TTLine b_cLine = new TTLine(bPoint, cPoint);
    
                            if (MOVE == 0) {
                                if (Utils.isPointUpLine(bPoint, a_dLine)) {
                                    MOVE = 1;
                                } else {
                                    MOVE = 2;
                                }
                            }
                            if (Utils.isPointUpLine(bPoint, a_dLine) && MOVE == 1) {
                                if (Utils.pointToLine(bPoint, a_dLine) >= 15 && Utils.pointToLine(aPoint, b_cLine) >= 15 && Utils.pointToLine(dPoint, b_cLine) >= 15) {
                                    if (Utils.isPointUpLine(aPoint, b_cLine) && Utils.isPointDownLine(dPoint, b_cLine)) {
                                        if (E2_x - D_x == 0 && B_x - D_x == 0) {  //之前为垂直
                                            float ey = D_y + (E2_y - D_y) / (B_y - D_y) * (y - D_y);
                                            //求出两条直线的焦点
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E2_x, ey),
                                                    new TTPoint(E1_x, E1_y)), new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 11111111111111");
                                        } else if (E2_y - D_y == 0 && B_y - D_y == 0) {
                                            float ex = D_x + (E2_x - D_x) / (B_x - D_x) * (x - D_x);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E2_y), new TTPoint(E1_x, E1_y)),
                                                    new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 2222222222222");
                                        } else {
                                            float ex = D_x + (E2_x - D_x) / (B_x - D_x) * (x - D_x);
                                            float ey = D_y + (E2_y - D_y) / (B_y - D_y) * (y - D_y);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E1_x, E1_y)),
                                                    new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 3333333333333");
                                        }
                                        B_x = x;
                                        B_y = y;
                                        Log.e(TAG, "onTouchEvent: ");
                                    } else if (Utils.isPointDownLine(aPoint, b_cLine) && Utils.isPointUpLine(dPoint, b_cLine)) {
                                        if (E2_x - D_x == 0 && B_x - D_x == 0) {  //之前为垂直
                                            float ey = D_y + (E2_y - D_y) / (B_y - D_y) * (y - D_y);
                                            //求出两条直线的焦点
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E2_x, ey),
                                                    new TTPoint(E1_x, E1_y)), new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 11111111111111");
                                        } else if (E2_y - D_y == 0 && B_y - D_y == 0) {
                                            float ex = D_x + (E2_x - D_x) / (B_x - D_x) * (x - D_x);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E2_y), new TTPoint(E1_x, E1_y)),
                                                    new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 2222222222222");
                                        } else {
                                            float ex = D_x + (E2_x - D_x) / (B_x - D_x) * (x - D_x);
                                            float ey = D_y + (E2_y - D_y) / (B_y - D_y) * (y - D_y);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E1_x, E1_y)),
                                                    new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 3333333333333");
                                        }
                                        B_x = x;
                                        B_y = y;
                                        Log.e(TAG, "onTouchEvent: ");
                                    } else {
                                        Log.e(TAG, "onTouchEvent: ");
                                    }
                                } else {
                                    if (x > B_x && y < B_y) {
                                        if (Utils.isPointUpLine(aPoint, b_cLine) && Utils.isPointDownLine(dPoint, b_cLine)) {
                                            if (E2_x - D_x == 0 && B_x - D_x == 0) {  //之前为垂直
                                                float ey = D_y + (E2_y - D_y) / (B_y - D_y) * (y - D_y);
                                                //求出两条直线的焦点
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E2_x, ey),
                                                        new TTPoint(E1_x, E1_y)), new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 11111111111111");
                                            } else if (E2_y - D_y == 0 && B_y - D_y == 0) {
                                                float ex = D_x + (E2_x - D_x) / (B_x - D_x) * (x - D_x);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E2_y), new TTPoint(E1_x, E1_y)),
                                                        new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 2222222222222");
                                            } else {
                                                float ex = D_x + (E2_x - D_x) / (B_x - D_x) * (x - D_x);
                                                float ey = D_y + (E2_y - D_y) / (B_y - D_y) * (y - D_y);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E1_x, E1_y)),
                                                        new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 3333333333333");
                                            }
                                            B_x = x;
                                            B_y = y;
                                            Log.e(TAG, "onTouchEvent: ");
                                        } else if (Utils.isPointDownLine(aPoint, b_cLine) && Utils.isPointUpLine(dPoint, b_cLine)) {
                                            if (E2_x - D_x == 0 && B_x - D_x == 0) {  //之前为垂直
                                                float ey = D_y + (E2_y - D_y) / (B_y - D_y) * (y - D_y);
                                                //求出两条直线的焦点
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E2_x, ey),
                                                        new TTPoint(E1_x, E1_y)), new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 11111111111111");
                                            } else if (E2_y - D_y == 0 && B_y - D_y == 0) {
                                                float ex = D_x + (E2_x - D_x) / (B_x - D_x) * (x - D_x);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E2_y), new TTPoint(E1_x, E1_y)),
                                                        new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 2222222222222");
                                            } else {
                                                float ex = D_x + (E2_x - D_x) / (B_x - D_x) * (x - D_x);
                                                float ey = D_y + (E2_y - D_y) / (B_y - D_y) * (y - D_y);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E1_x, E1_y)),
                                                        new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 3333333333333");
                                            }
                                            B_x = x;
                                            B_y = y;
                                            Log.e(TAG, "onTouchEvent: ");
                                        } else {
                                            Log.e(TAG, "onTouchEvent: ");
                                        }
                                    }
                                }
    
    
                            } else if (!Utils.isPointUpLine(bPoint, a_dLine) && MOVE == 2) {
                                if (Utils.pointToLine(bPoint, a_dLine) >= 15 && Utils.pointToLine(aPoint, b_cLine) >= 15 && Utils.pointToLine(dPoint, b_cLine) >= 15) {
                                    if (Utils.isPointDownLine(aPoint, b_cLine) && Utils.isPointUpLine(dPoint, b_cLine)) {
                                        if (E2_x - D_x == 0 && B_x - D_x == 0) {  //之前为垂直
                                            float ey = D_y + (E2_y - D_y) / (B_y - D_y) * (y - D_y);
                                            //求出两条直线的焦点
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E2_x, ey),
                                                    new TTPoint(E1_x, E1_y)), new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 11111111111111");
                                        } else if (E2_y - D_y == 0 && B_y - D_y == 0) {
                                            float ex = D_x + (E2_x - D_x) / (B_x - D_x) * (x - D_x);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E2_y), new TTPoint(E1_x, E1_y)),
                                                    new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 2222222222222");
                                        } else {
                                            float ex = D_x + (E2_x - D_x) / (B_x - D_x) * (x - D_x);
                                            float ey = D_y + (E2_y - D_y) / (B_y - D_y) * (y - D_y);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E1_x, E1_y)),
                                                    new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 3333333333333");
                                        }
                                        B_x = x;
                                        B_y = y;
                                        Log.e(TAG, "onTouchEvent: ");
                                    } else if (Utils.isPointUpLine(aPoint, b_cLine) && Utils.isPointDownLine(dPoint, b_cLine)) {
                                        if (E2_x - D_x == 0 && B_x - D_x == 0) {  //之前为垂直
                                            float ey = D_y + (E2_y - D_y) / (B_y - D_y) * (y - D_y);
                                            //求出两条直线的焦点
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E2_x, ey),
                                                    new TTPoint(E1_x, E1_y)), new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 11111111111111");
                                        } else if (E2_y - D_y == 0 && B_y - D_y == 0) {
                                            float ex = D_x + (E2_x - D_x) / (B_x - D_x) * (x - D_x);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E2_y), new TTPoint(E1_x, E1_y)),
                                                    new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 2222222222222");
                                        } else {
                                            float ex = D_x + (E2_x - D_x) / (B_x - D_x) * (x - D_x);
                                            float ey = D_y + (E2_y - D_y) / (B_y - D_y) * (y - D_y);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E1_x, E1_y)),
                                                    new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 3333333333333");
                                        }
                                        B_x = x;
                                        B_y = y;
                                        Log.e(TAG, "onTouchEvent: ");
                                    } else {
                                        Log.e(TAG, "onTouchEvent: ");
                                    }
                                } else {
                                    if (x < B_x && y > B_y) {
                                        if (Utils.isPointDownLine(aPoint, b_cLine) && Utils.isPointUpLine(dPoint, b_cLine)) {
                                            if (E2_x - D_x == 0 && B_x - D_x == 0) {  //之前为垂直
                                                float ey = D_y + (E2_y - D_y) / (B_y - D_y) * (y - D_y);
                                                //求出两条直线的焦点
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E2_x, ey),
                                                        new TTPoint(E1_x, E1_y)), new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 11111111111111");
                                            } else if (E2_y - D_y == 0 && B_y - D_y == 0) {
                                                float ex = D_x + (E2_x - D_x) / (B_x - D_x) * (x - D_x);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E2_y), new TTPoint(E1_x, E1_y)),
                                                        new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 2222222222222");
                                            } else {
                                                float ex = D_x + (E2_x - D_x) / (B_x - D_x) * (x - D_x);
                                                float ey = D_y + (E2_y - D_y) / (B_y - D_y) * (y - D_y);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E1_x, E1_y)),
                                                        new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 3333333333333");
                                            }
                                            B_x = x;
                                            B_y = y;
                                            Log.e(TAG, "onTouchEvent: ");
                                        } else if (Utils.isPointUpLine(aPoint, b_cLine) && Utils.isPointDownLine(dPoint, b_cLine)) {
                                            if (E2_x - D_x == 0 && B_x - D_x == 0) {  //之前为垂直
                                                float ey = D_y + (E2_y - D_y) / (B_y - D_y) * (y - D_y);
                                                //求出两条直线的焦点
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E2_x, ey),
                                                        new TTPoint(E1_x, E1_y)), new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 11111111111111");
                                            } else if (E2_y - D_y == 0 && B_y - D_y == 0) {
                                                float ex = D_x + (E2_x - D_x) / (B_x - D_x) * (x - D_x);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E2_y), new TTPoint(E1_x, E1_y)),
                                                        new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 2222222222222");
                                            } else {
                                                float ex = D_x + (E2_x - D_x) / (B_x - D_x) * (x - D_x);
                                                float ey = D_y + (E2_y - D_y) / (B_y - D_y) * (y - D_y);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E1_x, E1_y)),
                                                        new TTLine(new TTPoint(B_x, B_y), new TTPoint(D_x, D_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 3333333333333");
                                            }
                                            B_x = x;
                                            B_y = y;
                                            Log.e(TAG, "onTouchEvent: ");
                                        } else {
                                            Log.e(TAG, "onTouchEvent: ");
                                        }
                                    }
                                }
                            }
                        } else if (DC && Math.abs(y - A_y) <= max_height / 2 && Math.abs(y - B_y) <= max_height / 2) {
                            TTPoint aPoint = new TTPoint(A_x, A_y);
                            TTPoint bPoint = new TTPoint(B_x, B_y);
                            TTPoint cPoint = new TTPoint(x, y);
                            TTPoint dPoint = new TTPoint(D_x, D_y);
                            TTLine a_dLine = new TTLine(aPoint, dPoint);
                            TTLine b_cLine = new TTLine(bPoint, cPoint);
                            if (MOVE == 0) {
                                if (Utils.isPointDownLine(cPoint, a_dLine)) {
                                    MOVE = 1;
                                } else {
                                    MOVE = 2;
                                }
                            }
                            if (Utils.isPointDownLine(cPoint, a_dLine) && MOVE == 1) {
                                if (Utils.pointToLine(cPoint, a_dLine) >= 15 && Utils.pointToLine(aPoint, b_cLine) >= 15 && Utils.pointToLine(dPoint, b_cLine) >= 15) {
                                    if (Utils.isPointUpLine(aPoint, b_cLine) && Utils.isPointDownLine(dPoint, b_cLine)) {
                                        if (E1_x - A_x == 0 && C_x - A_x == 0) {  //之前为垂直
                                            float ey = A_y + (E1_y - A_y) / (C_y - A_y) * (y - A_y);
                                            //求出两条直线的焦点
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E1_x, ey),
                                                    new TTPoint(E2_x, E2_y)), new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 11111111111111");
                                        } else if (E1_y - C_y == 0 && A_y - C_y == 0) {
                                            float ex = A_x + (E1_x - A_x) / (C_x - A_x) * (x - A_x);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E1_y), new TTPoint(E2_x, E2_y)),
                                                    new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 2222222222222");
                                        } else {
                                            float ex = A_x + (E1_x - A_x) / (C_x - A_x) * (x - A_x);
                                            float ey = A_y + (E1_y - A_y) / (C_y - A_y) * (y - A_y);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E2_x, E2_y)),
                                                    new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 3333333333333");
                                        }
                                        C_x = x;
                                        C_y = y;
                                        Log.e(TAG, "onTouchEvent: ");
                                    } else if (Utils.isPointDownLine(aPoint, b_cLine) && Utils.isPointUpLine(dPoint, b_cLine)) {
                                        if (E1_x - A_x == 0 && C_x - A_x == 0) {  //之前为垂直
                                            float ey = A_y + (E1_y - A_y) / (C_y - A_y) * (y - A_y);
                                            //求出两条直线的焦点
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E1_x, ey),
                                                    new TTPoint(E2_x, E2_y)), new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 11111111111111");
                                        } else if (E1_y - C_y == 0 && A_y - C_y == 0) {
                                            float ex = A_x + (E1_x - A_x) / (C_x - A_x) * (x - A_x);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E1_y), new TTPoint(E2_x, E2_y)),
                                                    new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 2222222222222");
                                        } else {
                                            float ex = A_x + (E1_x - A_x) / (C_x - A_x) * (x - A_x);
                                            float ey = A_y + (E1_y - A_y) / (C_y - A_y) * (y - A_y);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E2_x, E2_y)),
                                                    new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 3333333333333");
                                        }
                                        C_x = x;
                                        C_y = y;
                                        Log.e(TAG, "onTouchEvent: ");
                                    } else {
                                        Log.e(TAG, "onTouchEvent: ");
                                    }
                                } else {
                                    if (y > C_y && x < C_x) {
                                        if (Utils.isPointUpLine(aPoint, b_cLine) && Utils.isPointDownLine(dPoint, b_cLine)) {
                                            if (E1_x - A_x == 0 && C_x - A_x == 0) {  //之前为垂直
                                                float ey = A_y + (E1_y - A_y) / (C_y - A_y) * (y - A_y);
                                                //求出两条直线的焦点
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E1_x, ey),
                                                        new TTPoint(E2_x, E2_y)), new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 11111111111111");
                                            } else if (E1_y - C_y == 0 && A_y - C_y == 0) {
                                                float ex = A_x + (E1_x - A_x) / (C_x - A_x) * (x - A_x);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E1_y), new TTPoint(E2_x, E2_y)),
                                                        new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 2222222222222");
                                            } else {
                                                float ex = A_x + (E1_x - A_x) / (C_x - A_x) * (x - A_x);
                                                float ey = A_y + (E1_y - A_y) / (C_y - A_y) * (y - A_y);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E2_x, E2_y)),
                                                        new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 3333333333333");
                                            }
                                            C_x = x;
                                            C_y = y;
                                            Log.e(TAG, "onTouchEvent: ");
                                        } else if (Utils.isPointDownLine(aPoint, b_cLine) && Utils.isPointUpLine(dPoint, b_cLine)) {
                                            if (E1_x - A_x == 0 && C_x - A_x == 0) {  //之前为垂直
                                                float ey = A_y + (E1_y - A_y) / (C_y - A_y) * (y - A_y);
                                                //求出两条直线的焦点
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E1_x, ey),
                                                        new TTPoint(E2_x, E2_y)), new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 11111111111111");
                                            } else if (E1_y - C_y == 0 && A_y - C_y == 0) {
                                                float ex = A_x + (E1_x - A_x) / (C_x - A_x) * (x - A_x);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E1_y), new TTPoint(E2_x, E2_y)),
                                                        new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 2222222222222");
                                            } else {
                                                float ex = A_x + (E1_x - A_x) / (C_x - A_x) * (x - A_x);
                                                float ey = A_y + (E1_y - A_y) / (C_y - A_y) * (y - A_y);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E2_x, E2_y)),
                                                        new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 3333333333333");
                                            }
                                            C_x = x;
                                            C_y = y;
                                            Log.e(TAG, "onTouchEvent: ");
                                        } else {
                                            Log.e(TAG, "onTouchEvent: ");
                                        }
                                    }
                                }
    
    
                            } else if (!Utils.isPointDownLine(cPoint, a_dLine) && MOVE == 2) {
                                if (Utils.pointToLine(cPoint, a_dLine) >= 15 && Utils.pointToLine(aPoint, b_cLine) >= 15 && Utils.pointToLine(dPoint, b_cLine) >= 15) {
                                    if (Utils.isPointDownLine(aPoint, b_cLine) && Utils.isPointUpLine(dPoint, b_cLine)) {
                                        if (E1_x - A_x == 0 && C_x - A_x == 0) {  //之前为垂直
                                            float ey = A_y + (E1_y - A_y) / (C_y - A_y) * (y - A_y);
                                            //求出两条直线的焦点
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E1_x, ey),
                                                    new TTPoint(E2_x, E2_y)), new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 11111111111111");
                                        } else if (E1_y - C_y == 0 && A_y - C_y == 0) {
                                            float ex = A_x + (E1_x - A_x) / (C_x - A_x) * (x - A_x);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E1_y), new TTPoint(E2_x, E2_y)),
                                                    new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 2222222222222");
                                        } else {
                                            float ex = A_x + (E1_x - A_x) / (C_x - A_x) * (x - A_x);
                                            float ey = A_y + (E1_y - A_y) / (C_y - A_y) * (y - A_y);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E2_x, E2_y)),
                                                    new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 3333333333333");
                                        }
                                        C_x = x;
                                        C_y = y;
                                        Log.e(TAG, "onTouchEvent: ");
                                    } else if (Utils.isPointUpLine(aPoint, b_cLine) && Utils.isPointDownLine(dPoint, b_cLine)) {
                                        if (E1_x - A_x == 0 && C_x - A_x == 0) {  //之前为垂直
                                            float ey = A_y + (E1_y - A_y) / (C_y - A_y) * (y - A_y);
                                            //求出两条直线的焦点
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E1_x, ey),
                                                    new TTPoint(E2_x, E2_y)), new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 11111111111111");
                                        } else if (E1_y - C_y == 0 && A_y - C_y == 0) {
                                            float ex = A_x + (E1_x - A_x) / (C_x - A_x) * (x - A_x);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E1_y), new TTPoint(E2_x, E2_y)),
                                                    new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 2222222222222");
                                        } else {
                                            float ex = A_x + (E1_x - A_x) / (C_x - A_x) * (x - A_x);
                                            float ey = A_y + (E1_y - A_y) / (C_y - A_y) * (y - A_y);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E2_x, E2_y)),
                                                    new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                            if (p != null) {
                                                E1_x = p.x;
                                                E1_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 3333333333333");
                                        }
                                        C_x = x;
                                        C_y = y;
                                        Log.e(TAG, "onTouchEvent: ");
                                    } else {
                                        Log.e(TAG, "onTouchEvent: ");
                                    }
                                } else {
                                    if (y < C_y && x > C_x) {
                                        if (Utils.isPointDownLine(aPoint, b_cLine) && Utils.isPointUpLine(dPoint, b_cLine)) {
                                            if (E1_x - A_x == 0 && C_x - A_x == 0) {  //之前为垂直
                                                float ey = A_y + (E1_y - A_y) / (C_y - A_y) * (y - A_y);
                                                //求出两条直线的焦点
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E1_x, ey),
                                                        new TTPoint(E2_x, E2_y)), new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 11111111111111");
                                            } else if (E1_y - C_y == 0 && A_y - C_y == 0) {
                                                float ex = A_x + (E1_x - A_x) / (C_x - A_x) * (x - A_x);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E1_y), new TTPoint(E2_x, E2_y)),
                                                        new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 2222222222222");
                                            } else {
                                                float ex = A_x + (E1_x - A_x) / (C_x - A_x) * (x - A_x);
                                                float ey = A_y + (E1_y - A_y) / (C_y - A_y) * (y - A_y);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E2_x, E2_y)),
                                                        new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 3333333333333");
                                            }
                                            C_x = x;
                                            C_y = y;
                                            Log.e(TAG, "onTouchEvent: ");
                                        } else if (Utils.isPointUpLine(aPoint, b_cLine) && Utils.isPointDownLine(dPoint, b_cLine)) {
                                            if (E1_x - A_x == 0 && C_x - A_x == 0) {  //之前为垂直
                                                float ey = A_y + (E1_y - A_y) / (C_y - A_y) * (y - A_y);
                                                //求出两条直线的焦点
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E1_x, ey),
                                                        new TTPoint(E2_x, E2_y)), new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 11111111111111");
                                            } else if (E1_y - C_y == 0 && A_y - C_y == 0) {
                                                float ex = A_x + (E1_x - A_x) / (C_x - A_x) * (x - A_x);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E1_y), new TTPoint(E2_x, E2_y)),
                                                        new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 2222222222222");
                                            } else {
                                                float ex = A_x + (E1_x - A_x) / (C_x - A_x) * (x - A_x);
                                                float ey = A_y + (E1_y - A_y) / (C_y - A_y) * (y - A_y);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E2_x, E2_y)),
                                                        new TTLine(new TTPoint(C_x, C_y), new TTPoint(A_x, A_y)));
                                                if (p != null) {
                                                    E1_x = p.x;
                                                    E1_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 3333333333333");
                                            }
                                            C_x = x;
                                            C_y = y;
                                            Log.e(TAG, "onTouchEvent: ");
                                        } else {
                                            Log.e(TAG, "onTouchEvent: ");
                                        }
                                    }
                                }
    
                            }
                        } else if (DD && Math.abs(y - A_y) <= max_height / 2 && Math.abs(y - B_y) <= max_height / 2) {
                            TTPoint aPoint = new TTPoint(A_x, A_y);
                            TTPoint bPoint = new TTPoint(B_x, B_y);
                            TTPoint cPoint = new TTPoint(C_x, C_y);
                            TTPoint dPoint = new TTPoint(x, y);
                            TTLine b_cLine = new TTLine(bPoint, cPoint);
                            TTLine a_dLine = new TTLine(aPoint, dPoint);
                            if (MOVE == 0) {
                                if (Utils.isPointDownLine(dPoint, b_cLine)) {
                                    MOVE = 1;
                                } else {
                                    MOVE = 2;
                                }
                            }
    
                            if (Utils.isPointDownLine(dPoint, b_cLine) && MOVE == 1) {
                                if (Utils.pointToLine(dPoint, b_cLine) >= 15 && Utils.pointToLine(bPoint, a_dLine) >= 15 && Utils.pointToLine(cPoint, a_dLine) >= 15) {
                                    if (Utils.isPointUpLine(bPoint, a_dLine) && Utils.isPointDownLine(cPoint, a_dLine)) {
                                        if (E2_x - B_x == 0 && D_x - B_x == 0) {  //之前为垂直
                                            float ey = B_y + (E2_y - B_y) / (D_y - B_y) * (y - B_y);
                                            //求出两条直线的焦点
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E2_x, ey),
                                                    new TTPoint(E1_x, E1_y)), new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 11111111111111");
                                        } else if (E2_y - B_y == 0 && D_y - B_y == 0) {
                                            float ex = B_x + (E2_x - B_x) / (D_x - B_x) * (x - B_x);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E2_y), new TTPoint(E1_x, E1_y)),
                                                    new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 2222222222222");
                                        } else {
                                            float ex = B_x + (E2_x - B_x) / (D_x - B_x) * (x - B_x);
                                            float ey = B_y + (E2_y - B_y) / (D_y - B_y) * (y - B_y);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E1_x, E1_y)),
                                                    new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 3333333333333");
                                        }
    
                                        D_x = x;
                                        D_y = y;
                                        Log.e(TAG, "onTouchEvent: ");
                                    } else if (Utils.isPointDownLine(bPoint, a_dLine) && Utils.isPointUpLine(cPoint, a_dLine)) {
                                        if (E2_x - B_x == 0 && D_x - B_x == 0) {  //之前为垂直
                                            float ey = B_y + (E2_y - B_y) / (D_y - B_y) * (y - B_y);
                                            //求出两条直线的焦点
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E2_x, ey),
                                                    new TTPoint(E1_x, E1_y)), new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 11111111111111");
                                        } else if (E2_y - B_y == 0 && D_y - B_y == 0) {
                                            float ex = B_x + (E2_x - B_x) / (D_x - B_x) * (x - B_x);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E2_y), new TTPoint(E1_x, E1_y)),
                                                    new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 2222222222222");
                                        } else {
                                            float ex = B_x + (E2_x - B_x) / (D_x - B_x) * (x - B_x);
                                            float ey = B_y + (E2_y - B_y) / (D_y - B_y) * (y - B_y);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E1_x, E1_y)),
                                                    new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 3333333333333");
                                        }
                                        D_x = x;
                                        D_y = y;
                                        Log.e(TAG, "onTouchEvent: ");
                                    } else {
                                        Log.e(TAG, "onTouchEvent: ");
                                    }
                                } else {
                                    if (x > D_x && y > D_y) {
                                        if (Utils.isPointUpLine(bPoint, a_dLine) && Utils.isPointDownLine(cPoint, a_dLine)) {
                                            if (E2_x - B_x == 0 && D_x - B_x == 0) {  //之前为垂直
                                                float ey = B_y + (E2_y - B_y) / (D_y - B_y) * (y - B_y);
                                                //求出两条直线的焦点
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E2_x, ey),
                                                        new TTPoint(E1_x, E1_y)), new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 11111111111111");
                                            } else if (E2_y - B_y == 0 && D_y - B_y == 0) {
                                                float ex = B_x + (E2_x - B_x) / (D_x - B_x) * (x - B_x);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E2_y), new TTPoint(E1_x, E1_y)),
                                                        new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 2222222222222");
                                            } else {
                                                float ex = B_x + (E2_x - B_x) / (D_x - B_x) * (x - B_x);
                                                float ey = B_y + (E2_y - B_y) / (D_y - B_y) * (y - B_y);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E1_x, E1_y)),
                                                        new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 3333333333333");
                                            }
                                            D_x = x;
                                            D_y = y;
                                            Log.e(TAG, "onTouchEvent: ");
                                        } else if (Utils.isPointDownLine(bPoint, a_dLine) && Utils.isPointUpLine(cPoint, a_dLine)) {
                                            if (E2_x - B_x == 0 && D_x - B_x == 0) {  //之前为垂直
                                                float ey = B_y + (E2_y - B_y) / (D_y - B_y) * (y - B_y);
                                                //求出两条直线的焦点
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E2_x, ey),
                                                        new TTPoint(E1_x, E1_y)), new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 11111111111111");
                                            } else if (E2_y - B_y == 0 && D_y - B_y == 0) {
                                                float ex = B_x + (E2_x - B_x) / (D_x - B_x) * (x - B_x);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E2_y), new TTPoint(E1_x, E1_y)),
                                                        new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 2222222222222");
                                            } else {
                                                float ex = B_x + (E2_x - B_x) / (D_x - B_x) * (x - B_x);
                                                float ey = B_y + (E2_y - B_y) / (D_y - B_y) * (y - B_y);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E1_x, E1_y)),
                                                        new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 3333333333333");
                                            }
                                            D_x = x;
                                            D_y = y;
                                            Log.e(TAG, "onTouchEvent: ");
                                        } else {
                                            Log.e(TAG, "onTouchEvent: ");
                                        }
                                    }
                                }
    
                            } else if (!Utils.isPointDownLine(dPoint, b_cLine) && MOVE == 2) {
                                if (Utils.pointToLine(dPoint, b_cLine) >= 15 && Utils.pointToLine(bPoint, a_dLine) >= 15 && Utils.pointToLine(cPoint, a_dLine) >= 15) {
                                    if (Utils.isPointDownLine(bPoint, a_dLine) && Utils.isPointUpLine(cPoint, a_dLine)) {
                                        if (E2_x - B_x == 0 && D_x - B_x == 0) {  //之前为垂直
                                            float ey = B_y + (E2_y - B_y) / (D_y - B_y) * (y - B_y);
                                            //求出两条直线的焦点
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E2_x, ey),
                                                    new TTPoint(E1_x, E1_y)), new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 11111111111111");
                                        } else if (E2_y - B_y == 0 && D_y - B_y == 0) {
                                            float ex = B_x + (E2_x - B_x) / (D_x - B_x) * (x - B_x);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E2_y), new TTPoint(E1_x, E1_y)),
                                                    new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 2222222222222");
                                        } else {
                                            float ex = B_x + (E2_x - B_x) / (D_x - B_x) * (x - B_x);
                                            float ey = B_y + (E2_y - B_y) / (D_y - B_y) * (y - B_y);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E1_x, E1_y)),
                                                    new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 3333333333333");
                                        }
                                        D_x = x;
                                        D_y = y;
                                        Log.e(TAG, "onTouchEvent: ");
                                    } else if (Utils.isPointUpLine(bPoint, a_dLine) && Utils.isPointDownLine(cPoint, a_dLine)) {
                                        if (E2_x - B_x == 0 && D_x - B_x == 0) {  //之前为垂直
                                            float ey = B_y + (E2_y - B_y) / (D_y - B_y) * (y - B_y);
                                            //求出两条直线的焦点
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E2_x, ey),
                                                    new TTPoint(E1_x, E1_y)), new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 11111111111111");
                                        } else if (E2_y - B_y == 0 && D_y - B_y == 0) {
                                            float ex = B_x + (E2_x - B_x) / (D_x - B_x) * (x - B_x);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E2_y), new TTPoint(E1_x, E1_y)),
                                                    new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 2222222222222");
                                        } else {
                                            float ex = B_x + (E2_x - B_x) / (D_x - B_x) * (x - B_x);
                                            float ey = B_y + (E2_y - B_y) / (D_y - B_y) * (y - B_y);
                                            TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E1_x, E1_y)),
                                                    new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                            if (p != null) {
                                                E2_x = p.x;
                                                E2_y = p.y;
                                            }
                                            Log.e(TAG, "onTouchEvent1: 3333333333333");
                                        }
                                        D_x = x;
                                        D_y = y;
                                        Log.e(TAG, "onTouchEvent: ");
                                    } else {
                                        Log.e(TAG, "onTouchEvent: ");
                                    }
                                } else {
                                    if (x < D_x && y < D_y) {
                                        if (Utils.isPointDownLine(bPoint, a_dLine) && Utils.isPointUpLine(cPoint, a_dLine)) {
                                            if (E2_x - B_x == 0 && D_x - B_x == 0) {  //之前为垂直
                                                float ey = B_y + (E2_y - B_y) / (D_y - B_y) * (y - B_y);
                                                //求出两条直线的焦点
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E2_x, ey),
                                                        new TTPoint(E1_x, E1_y)), new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 11111111111111");
                                            } else if (E2_y - B_y == 0 && D_y - B_y == 0) {
                                                float ex = B_x + (E2_x - B_x) / (D_x - B_x) * (x - B_x);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E2_y), new TTPoint(E1_x, E1_y)),
                                                        new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 2222222222222");
                                            } else {
                                                float ex = B_x + (E2_x - B_x) / (D_x - B_x) * (x - B_x);
                                                float ey = B_y + (E2_y - B_y) / (D_y - B_y) * (y - B_y);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E1_x, E1_y)),
                                                        new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 3333333333333");
                                            }
                                            D_x = x;
                                            D_y = y;
                                            Log.e(TAG, "onTouchEvent: ");
                                        } else if (Utils.isPointUpLine(bPoint, a_dLine) && Utils.isPointDownLine(cPoint, a_dLine)) {
                                            if (E2_x - B_x == 0 && D_x - B_x == 0) {  //之前为垂直
                                                float ey = B_y + (E2_y - B_y) / (D_y - B_y) * (y - B_y);
                                                //求出两条直线的焦点
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(E2_x, ey),
                                                        new TTPoint(E1_x, E1_y)), new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 11111111111111");
                                            } else if (E2_y - B_y == 0 && D_y - B_y == 0) {
                                                float ex = B_x + (E2_x - B_x) / (D_x - B_x) * (x - B_x);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, E2_y), new TTPoint(E1_x, E1_y)),
                                                        new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 2222222222222");
                                            } else {
                                                float ex = B_x + (E2_x - B_x) / (D_x - B_x) * (x - B_x);
                                                float ey = B_y + (E2_y - B_y) / (D_y - B_y) * (y - B_y);
                                                TTPoint p = Utils.TwoLineToFocusPoint(new TTLine(new TTPoint(ex, ey), new TTPoint(E1_x, E1_y)),
                                                        new TTLine(new TTPoint(D_x, D_y), new TTPoint(B_x, B_y)));
                                                if (p != null) {
                                                    E2_x = p.x;
                                                    E2_y = p.y;
                                                }
                                                Log.e(TAG, "onTouchEvent1: 3333333333333");
                                            }
                                            D_x = x;
                                            D_y = y;
                                            Log.e(TAG, "onTouchEvent: ");
                                        } else {
                                            Log.e(TAG, "onTouchEvent: ");
                                        }
                                    }
                                }
                            }
    
                        } else if (E1) {
                            Log.e(TAG, "onTouchEvent: E1");
                            TTPoint aPoint = new TTPoint(A_x, A_y);
                            TTPoint cPoint = new TTPoint(C_x, C_y);
                            TTPoint e1Point = new TTPoint(x, y);
                            TTPoint e2Point = new TTPoint(E2_x, E2_y);
                            TTLine b_cLine = new TTLine(aPoint, cPoint);
                            TTLine e1_e2Line = new TTLine(e1Point, e2Point);
                            TTPoint point = Utils.TwoLineToFocusPoint(e1_e2Line, b_cLine);
                            if (point != null) {
                                E1_x = point.x;
                                E1_y = point.y;
                                if (A_x == C_x) { //a c两点为竖线
                                    K1 = (A_y - E1_y) / (E1_y - C_y);
                                } else if (A_y == C_y) { //a c点为横线
                                    K1 = (A_x - E1_x) / (E1_x - C_x);
                                } else {
                                    K1 = (A_x - E1_x) / (E1_x - C_x);
                                }
                            } else {
                                Log.e(TAG, "onTouchEvent: 没焦点");
                            }
                        } else if (E2) {
                            Log.e(TAG, "onTouchEvent: E2");
                            TTPoint aPoint = new TTPoint(B_x, B_y);
                            TTPoint cPoint = new TTPoint(D_x, D_y);
                            TTPoint e1Point = new TTPoint(E1_x, E1_y);
                            TTPoint e2Point = new TTPoint(x, y);
                            TTLine b_cLine = new TTLine(aPoint, cPoint);
                            TTLine e1_e2Line = new TTLine(e1Point, e2Point);
                            TTPoint point = Utils.TwoLineToFocusPoint(e1_e2Line, b_cLine);
                            if (point != null) {
                                E2_x = point.x;
                                E2_y = point.y;
                                if (B_x == D_x) { //a c两点为竖线
                                    K2 = (B_y - E2_y) / (E2_y - D_y);
                                } else if (B_y == D_y) { //a c点为横线
                                    K2 = (B_x - E2_x) / (E2_x - D_x);
                                } else {
                                    K2 = (B_x - E2_x) / (E2_x - D_x);
                                }
                            } else {
                                Log.e(TAG, "onTouchEvent: 没焦点");
                            }
                        } else {
                            Log.e(TAG, "onTouchEvent: ???????????");
                        }
                        //触发重新绘制
                        startTick();
                    }
                }
                case MotionEvent.ACTION_UP: {
                    //将最后移动的点,回传.
                    aciton_up = aciton_up + 1;
                    Log.e(TAG, "onTouchEvent: ACTION_UP");
                    if (aciton_up == 2) {
                        Log.e(TAG, "onTouchEvent: ACTION_UP--------------------------------------");
                        if (onfreshcallback != null) {
                            TVideoDetectParamSetup setup = new TVideoDetectParamSetup();
                            TPoint[] t = new TPoint[]{new TPoint((short)(A_x/xRatio), (short)(A_y/yRatio)), new TPoint((short)(B_x/xRatio), (short)(B_y/yRatio)),
                                    new TPoint((short)(C_x/xRatio),(short)(C_y/yRatio)), new TPoint((short)(D_x/xRatio),(short)(D_y/yRatio))};
                            setup.setAtPlateRegion4(t);
                            setup.setaStopLine(new TLine(new TPoint((short)(E1_x/xRatio), (short)(E1_y/yRatio)), new TPoint((short)(E2_x/xRatio), (short)(E2_y/yRatio))));
                            onfreshcallback.CallBack(setup);
                        }
                        MOVE = 0;
                    }
                }
            }
            return true;
        }
    
        private OnFreshCallBack onfreshcallback = null;
    
        public void setOnFreshCallBack(OnFreshCallBack callback) {
            this.onfreshcallback = callback;
        }
    
        public interface OnFreshCallBack {
            void CallBack(TVideoDetectParamSetup setup);
        }
    }
    

    2.工具类

    package com.viking.myapplication;
    
    import android.graphics.Point;
    import android.util.Log;
    
    import com.viking.qynet.TTLine;
    import com.viking.qynet.TTPoint;
    
    import java.io.BufferedOutputStream;
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.util.StringTokenizer;
    
    /**
     * Created by 25934 on 2017/12/8.
     */
    public  class Utils {
        public static String IntToIP(int x){
            String str = Integer.toBinaryString(x);
            //Log.e("TAG", "IntToIP: "+str );
            int[] bt = new int[4];
            int lenth = str.length();
            int size=0;
            if (lenth > 0){
                if (lenth%8!=0){
                    size = lenth/8+1;
                }else {
                    size = lenth/8;
                }
                for (;lenth>0;lenth-=8,size--){
                    if (lenth-8<0){
                        String st1 = str.substring(0,lenth);
                        for (int y=lenth;y<8;y++){
                            st1 = "0"+st1;
                        }
                        bt [size-1] = Integer.parseInt(st1,2);
                       // Log.e("TAG", "onCreate: "+bt[size-1]);
                    }else {
                        String st1 = str.substring(lenth-8,lenth);
                        bt [size-1] = Integer.parseInt(st1,2);
                       // Log.e("TAG", "onCreate: "+bt[size-1]);
                    }
                }
            }
            String address ="";
            for (int z= 4 ; z>0 ; z--){
                if (z==1){
                    address = bt[z-1]+address;
                }else  {
                    address = "."+bt[z-1]+address;
                }
            }
            return address;
        }
        public static String IntToIP(int x,boolean flag){
           if (!flag){
               String str = Integer.toBinaryString(x);
               //Log.e("TAG", "IntToIP: "+str );
               int[] bt = new int[4];
               int lenth = str.length();
               int size=0;
               if (lenth > 0){
                   if (lenth%8!=0){
                       size = lenth/8+1;
                   }else {
                       size = lenth/8;
                   }
                   for (;lenth>0;lenth-=8,size--){
                       if (lenth-8<0){
                           String st1 = str.substring(0,lenth);
                           for (int y=lenth;y<8;y++){
                               st1 = "0"+st1;
                           }
                           bt [size-1] = Integer.parseInt(st1,2);
                           // Log.e("TAG", "onCreate: "+bt[size-1]);
                       }else {
                           String st1 = str.substring(lenth-8,lenth);
                           bt [size-1] = Integer.parseInt(st1,2);
                           // Log.e("TAG", "onCreate: "+bt[size-1]);
                       }
                   }
               }
               String address ="";
               for (int z= 4 ; z>0 ; z--){
                   if (z==1){
                       address = bt[z-1]+address;
                   }else  {
                       address = "."+bt[z-1]+address;
                   }
               }
               return address;
    
           }else {
    
               String str = Integer.toBinaryString(x);
               //Log.e("TAG", "IntToIP: "+str );
               int[] bt = new int[4];
               int lenth = str.length();
               int size=0;
               if (lenth > 0){
                   if (lenth%8!=0){
                       size = lenth/8+1;
                   }else {
                       size = lenth/8;
                   }
                   for (;lenth>0;lenth-=8,size--){
                       if (lenth-8<0){
                           String st1 = str.substring(0,lenth);
                           for (int y=lenth;y<8;y++){
                               st1 = "0"+st1;
                           }
                           bt [size-1] = Integer.parseInt(st1,2);
                           // Log.e("TAG", "onCreate: "+bt[size-1]);
                       }else {
                           String st1 = str.substring(lenth-8,lenth);
                           bt [size-1] = Integer.parseInt(st1,2);
                           // Log.e("TAG", "onCreate: "+bt[size-1]);
                       }
                   }
               }
               String address ="";
               for (int z= 4 ; z>0 ; z--){
                   if (z==4){
                       address = address+bt[z-1];
                   }else  {
                       address = address+"."+bt[z-1];
                   }
               }
               return address;
           }
        }
        public static int iPToInt(String ip){
            String st = ip.trim();
            String stt ="";
            StringTokenizer stringTokenizer = new StringTokenizer(st,".",true);
            stringTokenizer.countTokens();
            while (stringTokenizer.hasMoreElements()){
                String st1 = stringTokenizer.nextToken();
                if (!st1.equals(".")){
                    String str2 =Integer.toBinaryString(Integer.parseInt(st1));
                    if (str2.length()==8){
                        stt = stt+str2;
                    }else {
                        for (int y=str2.length();y<8;y++){
                            str2 = "0"+str2;
                        }
                        stt = stt+str2;
                    }
                }
            }
            //取反
            //Log.e("TAG", "iPToInt: stt:" +stt);
            char ch = stt.charAt(0);
            String chh = "";
            int i =0;
            if (ch=='1'){
                int len = stt.length();
                for (int f = 0;f<32;f++){
                    char c = stt.charAt(f);
                    if (c=='1'){
                        chh=chh+'0';
                    }else {
                        chh = chh+'1';
                    }
                }
                try{
                    i = (-Integer.parseInt(chh,2)) -1;
                }catch (Exception e){
                }
            }else {
                i = Integer.parseInt(stt,2);
            }
            return i;
        }
    
        public static File saveImageFormFile(byte[] b, String path) {
            BufferedOutputStream stream = null;
            File file = null;
            try {
                file = new File(path);
                FileOutputStream fstream = new FileOutputStream(file);
                stream = new BufferedOutputStream(fstream);
                stream.write(b);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (stream != null) {
                    try {
                        stream.close();
                    } catch (IOException e1) {
                        e1.printStackTrace();
                    }
                }
            }
            return file;
        }
    
        public static boolean isPointUpLine(TTPoint point, TTLine line) {
            if (line.tStartPoint.x == line.tEndPoint.x) {
                if (point.x > line.tStartPoint.x) {
                    return false;
                }
            } else if (line.tStartPoint.y == line.tEndPoint.y) {
                if (point.y > line.tStartPoint.y) {
                    return false;
                }
            } else {
                //int y = abs((pt.x * (pt1.y - pt2.y) + pt1.x*pt2.y - pt2.x*pt1.y) / (pt1.x - pt2.x));
    
                float y = line.tStartPoint.y + (point.x - line.tStartPoint.x) * (line.tStartPoint.y - line.tEndPoint.y) / (line.tStartPoint.x - line.tEndPoint.x);
    
                if (y < point.y) {
                    return false;
                }
            }
            return true;
        }
    
        public static boolean isPointDownLine(TTPoint point, TTLine line) {
            if (line.tStartPoint.x == line.tEndPoint.x) {
                if (point.x < line.tStartPoint.x) {
                    return false;
                }
            } else if (line.tStartPoint.y == line.tEndPoint.y) {
                if (point.y < line.tStartPoint.y) {
                    return false;
                }
            } else {
                float y = line.tStartPoint.y + (point.x - line.tStartPoint.x) * (line.tStartPoint.y - line.tEndPoint.y) / (line.tStartPoint.x - line.tEndPoint.x);
                if (y > point.y) {
                    return false;
                }
            }
            return true;
        }
    
        public static TTPoint getCrossPoint(TTLine line1, TTLine line2) {
            float x;
            float y;
            float k1 = Float.MAX_VALUE;
            float k2 = Float.MAX_VALUE;
            boolean flag1 = false;
            boolean flag2 = false;
    
            if ((line1.tStartPoint.x - line1.tEndPoint.x) == 0)
                flag1 = true;
            if ((line2.tStartPoint.x - line2.tEndPoint.x) == 0)
                flag2 = true;
            if (!flag1)
                k1 = (line1.tStartPoint.y - line1.tEndPoint.y) / (line1.tStartPoint.x - line1.tEndPoint.x);
            if (!flag2)
                k2 = (line2.tStartPoint.y - line2.tEndPoint.y) / (line2.tStartPoint.x - line2.tEndPoint.x);
            if (k1 == k2)
                return null;
            if (flag1) {
                if (flag2)
                    return null;
                x = line1.tStartPoint.x;
                if (k2 == 0) {
                    y = line2.tStartPoint.y;
                } else {
                    y = k2 * (x - line2.tEndPoint.x) + line2.tEndPoint.y;
                }
            } else if (flag2) {
                x = line2.tStartPoint.x;
                if (k1 == 0) {
                    y = line1.tStartPoint.y;
                } else {
                    y = k1 * (x - line1.tEndPoint.x) + line1.tEndPoint.y;
                }
            } else {
                if (k1 == 0) {
                    y = line1.tStartPoint.y;
                    x = (y - line2.tEndPoint.y) / k2 + line2.tEndPoint.x;
                } else if (k2 == 0) {
                    y = line2.tStartPoint.y;
                    x = (y - line1.tEndPoint.y) / k1 + line1.tEndPoint.x;
                } else {
                    x = (k1 * line1.tEndPoint.x - k2 * line2.tEndPoint.x + line2.tEndPoint.y - line1.tEndPoint.y) / (k1 - k2);
                    y = k1 * (x - line1.tEndPoint.x) + line1.tEndPoint.y;
                }
            }
            if (between(line1.tStartPoint.x, line1.tEndPoint.x, x) && between(line1.tStartPoint.y, line1.tEndPoint.y, y) && between(line2.tStartPoint.x, line2.tEndPoint.x, x) && between(line2.tStartPoint.y, line2.tEndPoint.y, y)) {
                Point point = new Point();
                point.set((int) x, (int) y);
                if (point.equals(new Point((int) line1.tStartPoint.x, (int) line1.tStartPoint.y)) || point.equals(new Point((int) line1.tEndPoint.x, (int) line1.tEndPoint.y))) {
                    return null;
                }
                return new TTPoint( point.x,  point.y);
            } else {
                return null;
            }
        }
    
        public static boolean between(double a, double b, double target) {
            if (target >= a - 0.01 && target <= b + 0.01 || target <= a + 0.01 && target >= b - 0.01)
                return true;
            else
                return false;
        }
    
        public static double pointToLine(TTPoint point, TTLine line) {
            double space = 0;
            double a, b, c;
            a = lineSpace((int) line.tStartPoint.x, (int) line.tStartPoint.y,(int)  line.tEndPoint.x, (int) line.tEndPoint.y);// 线段的长度
            b = lineSpace((int) line.tStartPoint.x, (int) line.tStartPoint.y, (int) point.x, (int) point.y);// (x1,y1)到点的距离
            c = lineSpace((int) line.tEndPoint.x, (int) line.tEndPoint.y, (int) point.x,(int)  point.y);// (x2,y2)到点的距离
            if (c <= 0.000001 || b <= 0.000001) {
                space = 0;
                return space;
            }
            if (a <= 0.000001) {
                space = b;
                return space;
            }
            if (c * c >= a * a + b * b) {
                space = b;
                return space;
            }
            if (b * b >= a * a + c * c) {
                space = c;
                return space;
            }
            double p = (a + b + c) / 2;// 半周长
            double s = Math.sqrt(p * (p - a) * (p - b) * (p - c));// 海伦公式求面积
            space = 2 * s / a;// 返回点到线的距离(利用三角形面积公式求高)
            return space;
        }
    
        // 计算两点之间的距离
        private static double lineSpace(int x1, int y1, int x2, int y2) {
            double lineLength = 0;
            lineLength = Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2)
                    * (y1 - y2));
            return lineLength;
        }
    
        public static double getLineSlope(TTLine line) {
            return ((double) line.tEndPoint.y - (double) line.tStartPoint.y) / ((double) line.tEndPoint.x - (double) line.tStartPoint.x);
        }
    
        public static TTPoint TwoLineToFocusPoint(TTLine line1, TTLine line2) {
            double x = 0;
            double y = 0;
    
            double x1 = line1.tStartPoint.x;
            double y1 = line1.tStartPoint.y;
            double x2 = line1.tEndPoint.x;
            double y2 = line1.tEndPoint.y;
            double x3 = line2.tStartPoint.x;
            double y3 = line2.tStartPoint.y;
            double x4 = line2.tEndPoint.x;
            double y4 = line2.tEndPoint.y;
    
            double k1 = Float.MAX_VALUE;
            double k2 = Float.MAX_VALUE;
    
            boolean flag1 = false;
            boolean flag2 = false;
    
            if ((x1 - x2) == 0) {
                flag1 = true;
            }
            if ((x3 - x4) == 0) {
                flag2 = true;
            }
            if (!flag1) {
                k1 = (y1 - y2) / (x1 - x2);
            }
            if (!flag2) {
                k2 = (y3 - y4) / (x3 - x4);
            }
            if (k1 == k2) { //斜率相同,没有焦点
                return null;
            }
            if (flag1) { //线段一为竖直方向
                if (flag2) { //线段二也为竖直方向
                    return null;
                }
                x = x1;
                if (k2 == 0) {
                    y = y3;
                } else {
                    y = k2 * (x - x4) + y4;
                }
            } else if (flag2) {
                x = x3;
                if (k1 == 0) {
                    y = y1;
                } else {
                    y = k1 * (x - x2) + y2;
                }
            } else {
                if (k1 == 0) {
                    y = y1;
                    x = (y - y4) / k2 + x4;
                } else if (k2 == 0) {
                    y = y3;
                    x = (y - y2) / k1 + x2;
                } else {
                    x = (k1 * x2 - k2 * x4 + y4 - y2) / (k1 - k2);
                    y = k1 * (x - x2) + y2;
                }
            }
    
            if (between(x3, x4, x) && between(y3, y4, y)) {
                TTPoint point = new TTPoint((float) x, (float) y);
                Log.e("TAG", "TwoLineToFocusPoint  x:"+x+" y:"+y);
                return point;
            } else {
                Log.e("TAG", "TwoLineToFocusPoint: ");
                return null;
            }
        }
    
    }
    


    展开全文
  • 题意:给了n个点的坐标,问能有几个凸四边形 分析:数据规模小,直接暴力枚举,每次四个点判断是否会是凹四边形,条件是有一个点在另外三个点的内部,那么问题转换成判断一个点d是否在三角形abc内  易得S (abd) +...
  • 判断四边形凹凸性及凹点

    千次阅读 2016-02-21 21:41:47
    已知四边形四个点坐标 p1 = (x,y), p2 = (x,y), p3 = (x,y), p4 = (x,y) 判断凹凸性及凹点位置    t1 = (p4.x-p1.x)(p2.y-p1.y)-(p4.y-p1.y)(p2.x-p1.x) t2 = (p1.x-p2.x)(p3.y-p2.y)-(p1.y-p2.y)(p3.x-p2.x) ...
  • Time Limit: 3000/1000 MS (Java/Others)Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 4643Accepted Submission(s): 2080 Problem Description 话说上回讲到海东集团推选老总的事情,最终的...
  • 判断一个封闭图形是凹集还是凸集 代码如下:
  • 1.判断两条线段是否相交 #include <iostream> using namespace std; struct Point { double x, y; }; // 判断两条直线是否相交 double determinant(double v1, double v2, double v3, double v4) // ...
  • 判断是否为多边形

    千次阅读 2013-08-12 11:29:55
    http://acm.hdu.edu.cn/showproblem.php?pid=2108 Shape of HDU Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 4405 Accepted Submission(s):
  • 已知四边形(凸四边形)的四个点A、B、C、D(按逆时针顺序)的坐标,求点P是否在ABCD所围成的四边形内,可以通过向量叉乘的方法实现。 http://www.dewen.io/q/5805/Android 先提供一种简单情景(假定...
  • 这个问题很有趣,上面一个问题是给定一个点,判断是否在四边形内, 这个问题正好是返过来 思路1, 随机一个位置, 判断是否在四边形内。不是的话就重新随机 答:这个方法好low 于是就有了思路2 思路2,取四个点的minX...
  • 判断一个多边形是多边形还是凹多边形 输入: 输入包含多组测试数据,每组数据占2行,首先一行是一个整数n,表示多边形顶点的个数,然后一行是2×n个整数,表示逆时针顺序的n个顶点的坐标(xi,yi),n为0的...
  • 四边形坐标顺时针排序

    千次阅读 2017-07-21 10:06:58
    1. 做图像检测的时候处理数据经常遇到给出四边形的四个坐标点,要求找出左上角坐标并对乱序的坐标按顺时针或者逆时针进行排序,下面是方法,第一个函数只适用于矩形的情况,修改后的函数二适用于任意凸四边形。...
  • Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 4286 Accepted Submission(s): 1900 Problem Description 话说上回讲到海东集团推选老
  • 图片如下方所示 ![图片说明]... 可以确定的是一定是凸四边形,只有黑白两色的图,现在我希望能够通过像素点遍历的方式来寻找四边形的四个顶点的坐标。有什么比较好的实现方案么?
  • HDU3694 四边形的费马点

    千次阅读 2014-07-20 22:19:12
    1.因为只有四个点,当这四个点可以构成凸四边形时(如图):对角线形成的交点是费马点。就是点1,根据三角形的两边大于第三边可证明。   2.当不能构成凸多边形时,就是那个凹点是费马点(如图):同理可证。
  • 做图像检测的时候处理数据经常遇到给出矩形的四个坐标点,要求找出左上角坐标并对乱序的坐标按顺时针或者逆时针进行排序1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 ...4...
  • 关于DP的优化方法有很多种,低级的有矩阵快速幂,高级一点的比如四边形不等式优化、斜率优化等等。 因为在动态规划中,有这样的一类问题 状态转移方程 dp[i][j]=min{dp[i][k-1]+dp[k][j]}+w[i][j] (k>i&&...
  • 输入N个点的坐标,由程序判断该N个点是否能构成一个多边形。解题思路:用两点式推导直线一般方程(设已知的两点坐标分别为(x1,y1),(x2,y2),得x*(y1-y2)-y*(x1-x2)+(x1-x2)*y2-x1*(y1-y2)=0,令a=y1-y2,b=x1-x2,c=(x1-...
  • Java凸包问题

    2020-03-15 23:26:09
    当这个多边形是多边形的时候,我们就叫它“凸包”。如下图: 然后,什么是凸包问题? 我们把这些点放在二维坐标系里面,那么每个点都能用 (x,y) 来表示。 现给出点的数目13,和各个点的坐标。求构成凸包的点? ...
  • 21、判断一个数的所有因数的个数是偶数还是奇数(只需要你判断因数的个数是偶数个还是奇数个,那么可以这么做@滨湖&&土豆:那只在计算质因数的过程中统计一下当前质因数出现的次数,如果出现奇数次则结果为偶,然后...
  • Time Limit: 2000/1000 MS (Java/Others)Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 2484Accepted Submission(s): 1105 Problem Description T. E. Lawrence was a contro...
  • Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 5575 Accepted Submission(s): 2531 Problem Description 话说上回讲到海东集团推选老
  • 在平面直角坐标系中,给定一个点序列,判断这些点是否能够构成多边形,并且按照顺时针方向输出这些点。
  • 凸边行判断

    2017-07-12 13:47:38
    Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 4643 Accepted Submission(s): 2080Problem Description 话说上回讲到海东集团推选老总的事情,最终的...
  • TP-Link笔试面试

    千次阅读 2020-04-14 10:48:32
    面的软件开发工程师,简历里写了主语言java,问了不少java,面试先自我介绍,问了下成绩,然后问了下项目,大概持续二十分钟 ...2.判断四边形是凸四边形 四边向量叉乘大于零 3.大数乘法 把大整数存到StringBuffe...
  • 自己任意输入几个点构造一个多边形,然后再随机输入一个点,判断该点是否在多变形里面,如果不在,那么该点离多变形的最短距离是多少。 思路一: 下面是几个比较基本的方法: (1)面积法:将这个点与多边形的...
  • 如何判断凸边形或者凹变形

    千次阅读 2018-04-11 15:59:51
    已知四边形四个点坐标 p1 = (x,y), p2 = (x,y), p3 = (x,y), p4 = (x,y) 判断凹凸性及凹点位置 t1 = (p4.x-p1.x)(p2.y-p1.y)-(p4.y-p1.y)(p2.x-p1.x) t2 = (p1.x-p2.x)(p3.y-p2.y)-(p1.y-p2.y)(p3.x-p2.x) t3 = ...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 199
精华内容 79
关键字:

java判断凸四边形

java 订阅