package com.unis.detectionnum.server.utils;

import com.unis.detectionnum.common.vo.GetXYVO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.List;


public class DataMeasureUtils {

    private static final Logger log = LoggerFactory.getLogger(DataMeasureUtils.class);

    /**
     * 根据三角形的高和底边长 求三角形的弧度
     *
     * @param height 三角形高度
     * @param bottom 三角形底边
     * @return 返回弧度
     */
    public static Double getRadian(double height, double bottom) {
        double radian = Math.atan(bottom / height) * 180 / Math.PI;
        return radian;
    }

    /**
     * 根据三角形弧度 求x或者y的步长
     *
     * @param randian 三角形弧度
     * @return
     */
    public static int getSteps(double randian) {
        return (int) (Math.ceil(randian / CommonDataMeasure.ANGLE_STEP));
    }


    public static void main(String[] args) {
        double hypotenuse = DataMeasureUtils.mmToM(DataMeasureUtils.hexToInt("00005E10"));

        double height = getHeight(hypotenuse, 70.66);
        double pointZ = 8 - height;
        System.out.println("仓房高度： " + pointZ);
//        double height = DataMeasureUtils.getHeight(16638, getRadian);
//        List<GetXYVO> xyStepts1 = getXYStepts1(8, 54, 28, 30, 24, 0, "001", "002");
//        System.out.println();

//AB=24，AC=0
    }

    /**
     * @param machineHeight    仓房高度
     * @param houseLength      仓房长度
     * @param houseWide        仓房宽度
     * @param houseLengthLeft  仓房左边长度
     * @param houseLengthRight 仓房右边长度
     * @param altitudeHeight   粮食基准面高度
     * @param operateId        扫描记录code
     * @param sbCode           设备code
     * @return
     */
    public static List<GetXYVO> getXYStepts1(double machineHeight, double houseLength, double houseWide, double houseLengthRight, double houseLengthLeft, double altitudeHeight, String operateId, String sbCode) {

        //初始化点数集合
        List<GetXYVO> getScanPoints = new ArrayList();
//        int houseLengthLeft;   //左半边仓房长度，按目前仓房来算，30米
//        int houseLengthRight;   //右半边仓房长度，按目前仓房来算，24米
//        int houseWide;   //仓房宽度，按目前仓房来算，29米
//        int machineHeight;   //设备高度，以上三项均从基础数据中来
//        int altitudeHeight;    //基准面高度，第一次的值为装粮线
        double AA, AB = 0, AC = 0, Aa, Ab, Ac;   //如上图,A舵机，大写ABC代表三个边，小写abc代表三个角。
        double BA, BB, BC, Ba, Bb, Bc;   //如上图,B舵机，大写ABC代表三个边，小写abc代表三个角。

        double aAngle;   //a舵机旋转角度，类型不对自己换
        double bAngle;   //b舵机旋转角度，类型不对自己换

        double a, b;
        a = houseWide / 2 + 1;   // 1是中间那一行一列点
        b = ((houseLengthLeft + houseLengthRight) / 2 + 1) * 3;   // 1是中间那一行一列点
        double[][] pointPool = new double[(int) a][(int) b]; //建立点位池
//        memset(pointPool,0,sizeof(pointPool));   //初始化点位池
        //初始化返回xy
        GetXYVO[][] getXY = new GetXYVO[(int) a][(int) b];
        int i, j;
        int m = 0, n = 0;   //点位池角标累加
        int tempN, tempM;
        int result;

        //测1区域
        for (i = 0; i <= houseWide / 2; i += 2)//14
        {
            n = 0;
            for (j = 0; j <= houseLengthLeft; j += 2)//
            {
                //A舵机旋转角度
                if (j == houseLengthLeft) {
                    Ac = 0.0;   //Ac角度为0，也就是默认的位置
                    aAngle = Ac;
                    AA = houseWide / 2 - i;
                } else {
                    AB = houseLengthLeft - j;     //2是步长
                    AC = houseWide / 2 - i;   //2是步长

                    Ac = Math.atan(AB / AC) / (Math.PI / 180);     //如图12，已知AB边AC边以及Ab角（90度），默认执行完这个函数，三角形6要素其它三个已得出,可求Ac(转动方向1500+)
                    aAngle = getSteps(Ac);
                    AA = AB / Math.sin(Math.toRadians(Ac));//求出AA，以便将AA赋值给BB
                }

                //B舵机旋转角度
                if (j == houseLengthLeft && i == houseWide / 2) {
                    Bc = 0.0;   //Bc角度为0，也就是默认的位置
                    bAngle = Bc;
                } else {
                    BC = machineHeight - altitudeHeight;   //如图8，设备距离基准面的垂直高度
                    BB = AA;      //AA为上次A舵机旋转时求出的斜边的长度，对应B舵机的一条直角边BB
                    Bc = Math.atan(BB / BC) / (Math.PI / 180);  //如图8，BC为设备距离基准面距离，BB为A设备当时求出的斜边，Bb角为90度，默认执行完这个函数，三角形6要素其它三个已得出，可求Bc(转动方向1500-)
                    bAngle = getSteps(Bc);
                }
                getXY[i][j] = new GetXYVO((CommonDataMeasure.INITIAL_YD1 + aAngle), (CommonDataMeasure.INITIAL_YD1 + bAngle), Bc, Ac, UUIDUtils.getUUID(), operateId, sbCode, m, n, (n + 1), (n + 2), j, i, 1, houseLengthLeft, houseLengthRight, houseWide);
                getScanPoints.add(getXY[i][j]);
                n += 3;
            }
            m++;
        }
        tempN = n;

        //测2区域
        m = 0;
        for (i = 0; i < houseWide / 2; i += 2) {
            n = tempN;
            for (j = 0; j < houseLengthRight; j += 2) {
                //A舵机旋转角度
                AB = houseLengthRight - j;     //2是步长
                AC = houseWide / 2 - i;   //2是步长

                Ac = Math.atan(AB / AC) / (Math.PI / 180);     //如图12，已知AB边AC边以及Ab角（90度），默认执行完这个函数，三角形6要素其它三个已得出,可求Ac(转动方向1500-)
                aAngle = getSteps(Ac);
                AA = AB / Math.sin(Math.toRadians(Ac));//求出AA，以便将AA赋值给BB

                //B舵机旋转角度
                BC = machineHeight - altitudeHeight;   //如图8，设备距离基准面的垂直高度
                BB = AA;      //AA为上次A舵机旋转时求出的斜边的长度，对应B舵机的一条直角边BB
                Bc = Math.atan(BB / BC) / (Math.PI / 180);  //如图8，BC为设备距离基准面距离，BB为A设备当时求出的斜边，Bb角为90度，默认执行完这个函数，三角形6要素其它三个已得出，可求Bc(转动方向1500-)
                bAngle = getSteps(Bc);

                getXY[i][j] = new GetXYVO((CommonDataMeasure.INITIAL_YD1 - aAngle), (CommonDataMeasure.INITIAL_YD1 + bAngle), Bc, Ac, UUIDUtils.getUUID(), operateId, sbCode, m, n, (n + 1), (n + 2), (houseLengthRight + AB), i, 2, houseLengthLeft, houseLengthRight, houseWide);
                getScanPoints.add(getXY[i][j]);
                n += 3;
            }
            m++;
        }

        //测3区域
        tempM = m;
        m++;

        int tempaa = 0;
        for (i = 0; i < houseWide / 2; i += 2) {
            n = 0;
            for (j = 0; j < houseLengthLeft; j += 2) {
                //A舵机旋转角度
                AB = houseLengthLeft - j;     //2是步长
                AC = houseWide / 2 - i;   //2是步长

                Ac = Math.atan(AB / AC) / (Math.PI / 180);     //如图12，已知AB边AC边以及Ab角（90度），默认执行完这个函数，三角形6要素其它三个已得出,可求Ac(转动方向1500+)
                aAngle = getSteps(Ac);
                AA = AB / Math.sin(Math.toRadians(Ac));//求出AA，以便将AA赋值给BB

                //B舵机旋转角度
                BC = machineHeight - altitudeHeight;   //如图8，设备距离基准面的垂直高度
                BB = AA;      //AA为上次A舵机旋转时求出的斜边的长度，对应B舵机的一条直角边BB
                Bc = Math.atan(BB / BC) / (Math.PI / 180);  //如图8，BC为设备距离基准面距离，BB为A设备当时求出的斜边，Bb角为90度，默认执行完这个函数，三角形6要素其它三个已得出，可求Bc(转动方向1500+)
                bAngle = getSteps(Bc);

                getXY[i][j] = new GetXYVO((CommonDataMeasure.INITIAL_YD1 - aAngle), (CommonDataMeasure.INITIAL_YD1 - bAngle), Bc, Ac, UUIDUtils.getUUID(), operateId, sbCode, m, n, (n + 1), (n + 2), j, (houseWide / 2 + AC), 3, houseLengthLeft, houseLengthRight, houseWide);
                getScanPoints.add(getXY[i][j]);

                tempaa++;
                n += 3;
            }
            m++;
        }
        tempN = n;


        //测4区域
        m = tempM;
        for (i = 0; i <= houseWide / 2; i += 2) {
            n = tempN;
            for (j = 0; j <= houseLengthRight; j += 2) {
                //A舵机旋转角度
                if (j == houseLengthRight) {
                    Ac = 0.0;   //Ac角度为0，也就是默认的位置
                    aAngle = getSteps(Ac);
                    AA = houseWide / 2 - i;
                } else {
                    AB = houseLengthRight - j;     //2是步长
                    AC = houseWide / 2 - i;    //2是步长

                    Ac = Math.atan(AB / AC) / (Math.PI / 180);     //如图12，已知AB边AC边以及Ab角（90度），默认执行完这个函数，三角形6要素其它三个已得出,可求Ac(转动方向1500-)
                    aAngle = getSteps(Ac);
                    AA = AB / Math.sin(Math.toRadians(Ac));//求出AA，以便将AA赋值给BB
                }

                //B舵机旋转角度
                if (j == houseLengthRight && i == houseWide / 2) {
                    break;
                } else {
                    BC = machineHeight - altitudeHeight;   //如图8，设备距离基准面的垂直高度
                    BB = AA;      //AA为上次A舵机旋转时求出的斜边的长度，对应B舵机的一条直角边BB
                    Bc = Math.atan(BB / BC) / (Math.PI / 180);    //如图8，BC为设备距离基准面距离，BB为A设备当时求出的斜边，Bb角为90度，默认执行完这个函数，三角形6要素其它三个已得出，可求Bc(转动方向1500+)
                    bAngle = getSteps(Bc);
                }

                getXY[i][j] = new GetXYVO((CommonDataMeasure.INITIAL_YD1 + aAngle), (CommonDataMeasure.INITIAL_YD1 - bAngle), Bc, Ac, UUIDUtils.getUUID(), operateId, sbCode, m, n, (n + 1), (n + 2), (houseLengthRight + AB), (houseWide / 2 + AC), 4, houseLengthLeft, houseLengthRight, houseWide);
                getScanPoints.add(getXY[i][j]);
                n += 3;
            }
            m++;
        }
        return getScanPoints;
    }

    /**
     * 根据三角形的斜边长和弧度，求三角形的高
     *
     * @param hypotenuse 三角形斜边长
     * @param angle      弧度
     * @return 三角形高
     */
    public static double getHeight(double hypotenuse, double angle) {
//        double height = hypotenuse * Math.cos(angle * Math.PI / 180);
        double height = hypotenuse * Math.cos(Math.toRadians(angle));
        return height;
    }

    /**
     * 十进制转十六进制  解决高低位问题
     *
     * @param var0 十进制数
     * @return 十六进制
     */
    public static String lowHigh(int var0) {
        int var1 = 1;
        int var2 = var0 >> 8;
        int var3 = var0 & 255;
        String var4 = intToHex(var2);
        String var5 = intToHex(var3);
        if (var4.length() > 2) {
            do {
                if (var1 > 1) {
                    var2 >>= 8;
                }
                var4 = Integer.toHexString(var2 >> 8);
                var5 = var5 + Integer.toHexString(var2 & 255);
                ++var1;
            } while (var4.length() > 2);
        }
        if (var4.length() < 2) {
            var4 = "0" + var4;

            if (var4.length() < 2) {
                var4 = "0" + var4;
            }
        }
        if (var5.length() < 2) {
            var5 = "0" + var5;

            if (var5.length() < 2) {
                var5 = "0" + var5;
            }
        }
        return var4 + " " + var5;
    }


    /**
     * 十进制转十六进制
     *
     * @param n 十进制
     * @return 十六进制的字符串
     */
    public static String intToHex(int n) {
        StringBuffer s = new StringBuffer();
        String a;
        char[] b = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
        while (n != 0) {
            s = s.append(b[n % 16]);
            n = n / 16;
        }
        a = s.reverse().toString();
        return a;
    }

    /**
     * 十六进制转十进制
     *
     * @param hex 十六进制的字符串
     * @return 十进制
     */
    public static int hexToInt(String hex) {
        return (int) Long.parseLong(hex, 16);
    }

    /**
     * houseLength = 50;   //仓房长度，按目前仓房来算，55米
     * houseWide = 30;   //仓房宽度，按目前仓房来算，29米
     * machineHeight = 8;   //设备高度，以上三项均从基础数据中来
     * altitudeHeight = 0;    //基准面高度，第一次的值为装粮线
     * lengthPoint;   //此仓房长度有多少个点
     * widePoint;  //此仓房宽度有多少个点，以上两项均以步长为两米
     * operateId 扫描记录id
     * sbCode 设备code
     */
    public static double mmToM(double mm) {
        return mm / 1000;
    }


    public static List<GetXYVO> getXYStepts5(double machineHeight, double houseLength, double houseWide, double lengthPoint, double widePoint, double altitudeHeight, String operateId, String sbCode) {

        //初始化点数集合
        List<GetXYVO> getScanPoints = new ArrayList();
        log.info("第1象限");
//        int houseLength = 50;   //仓房长度，按目前仓房来算，55米
//        int houseWide = 30;   //仓房宽度，按目前仓房来算，29米
//        int machineHeight = 8;   //设备高度，以上三项均从基础数据中来
//        int altitudeHeight = 0;    //基准面高度，第一次的值为装粮线
//        double lengthPoint;   //此仓房长度有多少个点
//        double widePoint;  //此仓房宽度有多少个点，以上两项均以步长为两米
        double AA, AB, AC, Aa, Ab, Ac;   //如上图,A舵机，大写ABC代表三个边，小写abc代表三个角。
        double BA, BB, BC, Ba, Bb, Bc;   //如上图,B舵机，大写ABC代表三个边，小写abc代表三个角。

//        lengthPoint = houseLength / 2;   //27个点
//        widePoint = houseWide / 2;   //14个点
        double lengthRemainder = lengthPoint % 2;   //取长度点数余数
        double wideRemainder = widePoint % 2;   //取宽度点数余数
        //四种情况：如果长度余数为0，宽度余数为0，情况如上图1
        //四种情况：如果长度余数为1，宽度余数为0，情况如上图2
        //四种情况：如果长度余数为0，宽度余数为1，情况如上图3
        //四种情况：如果长度余数为1，宽度余数为1，情况如上图4
        int aAngle;   //a舵机旋转角度，类型不对自己换
        int bAngle;   //b舵机旋转角度，类型不对自己换

        //初始化返回xy
        GetXYVO[][] getXY = new GetXYVO[(int) lengthPoint][(int) widePoint];

        int i, j;
        //测1区域
        for (i = 0; i < widePoint / 2; i++) {
            for (j = 0; j < lengthPoint / 2; j++) {
                //A舵机旋转角度
                if (lengthRemainder == 1)
                    AB = 2 * (lengthPoint / 2) - j * 2;   //2是步长
                else            //其实就是等于0
                    AB = 2 * (lengthPoint / 2) - 1 - j * 2;   //2是步长

                if (wideRemainder == 1)
                    AC = 2 * (widePoint / 2) - i * 2;   //2是步长
                else            //其实就是等于0
                    AC = 2 * (widePoint / 2) - 1 - i * 2;   //2是步长

//                AntiTriangle(AB,AC,Ab);   //如图7，已知AB边AC边以及Ab角（90度），默认执行完这个函数，三角形6要素其它三个已得出,可求Ac
                Ac = Math.atan(AB / AC) / (Math.PI / 180);
                aAngle = getSteps(Ac);
                AA = AB / Math.sin(Math.toRadians(Ac));

                //B舵机旋转角度
                BC = machineHeight - altitudeHeight;   //如图8，设备距离基准面的垂直高度
                BB = AA;    //AA为上次A舵机旋转时求出的斜边的长度，对应B舵机的一条直角边BB
                //如图8，BC为设备距离基准面距离，BB为A设备当时求出的斜边，Bb角为90度，默认执行完这个函数，三角形6要素其它三个已得出，可求Bc
                Bc = Math.atan(BB / Double.valueOf(BC)) / (Math.PI / 180);
                bAngle = getSteps(Bc);
//                BA = BB / Math.sin(Bc);//获取BA斜边长;
                //x不涉及修正即1500；y需要进行修正即step_down=1450
//                getXY[i][j] = new GetXYVO((1450 + aAngle), (1450 - bAngle), Bc, Ac, UUIDUtils.getUUID(), operateId, sbCode);
                getScanPoints.add(getXY[i][j]);


/**                AntiTriangle(Ab,AB,Ac);   //如图9，已知道Ac角度(上面已经求出并转动)，Ab角度了(90度)，以及直角边AB(为仓房长的一半,houseLength/2)，那么就可得出AA等于多少时，打到了墙上。
 //AA = AB / Math.sin(Ac)

 AntiTriangle(Bc,BB,Bb);   //如图10，已知道Bc角度(上面已经求出并转动)，Bb角度了(90度)，以及直角边BB(上面求出的俯视图的AA)，那么就可得出BA等于多少时，打到了墙上。
 //BA = BB / Math.sin(Bc)

 if(result>=BA)    //说明打到墙上了
 continue;    //跳过，这个点不要了
 else*/

            }
        }
        return getScanPoints;
    }

    public static List<GetXYVO> getXYStepts6(double machineHeight, double houseLength, double houseWide, double lengthPoint, double widePoint, double altitudeHeight, String operateId, String sbCode) {

        //初始化点数集合
        List<GetXYVO> getScanPoints = new ArrayList();
        log.info("第2象限");
        double AA, AB, AC, Aa, Ab, Ac;   //如上图,A舵机，大写ABC代表三个边，小写abc代表三个角。
        double BA, BB, BC, Ba, Bb, Bc;   //如上图,B舵机，大写ABC代表三个边，小写abc代表三个角。

        double lengthRemainder = lengthPoint % 2;   //取长度点数余数
        double wideRemainder = widePoint % 2;   //取宽度点数余数
        //四种情况：如果长度余数为0，宽度余数为0，情况如上图1
        //四种情况：如果长度余数为1，宽度余数为0，情况如上图2
        //四种情况：如果长度余数为0，宽度余数为1，情况如上图3
        //四种情况：如果长度余数为1，宽度余数为1，情况如上图4
        int aAngle;   //a舵机旋转角度，类型不对自己换
        int bAngle;   //b舵机旋转角度，类型不对自己换
        //初始化返回xy
        GetXYVO[][] getXY = new GetXYVO[(int) lengthPoint][(int) widePoint];
        int i, j;
        //测2区域
        for (i = 0; i < widePoint / 2; i++) {
            for (j = 0; j < lengthPoint / 2; j++) {
                //A舵机旋转角度
                if (lengthRemainder == 1)
                    AB = 2 * (lengthPoint / 2) - j * 2;     //2是步长
                else            //其实就是等于0
                    AB = 2 * (lengthPoint / 2) - 1 - j * 2;   //2是步长

                if (wideRemainder == 1)
                    AC = 2 * (widePoint / 2) - i * 2;   //2是步长
                else            //其实就是等于0
                    AC = 2 * (widePoint / 2) - 1 - i * 2;     //2是步长

                Ac = Math.atan(AB / AC) / (Math.PI / 180);     //如图12，已知AB边AC边以及Ab角（90度），默认执行完这个函数，三角形6要素其它三个已得出,可求Ac(逆时针旋转)
                aAngle = getSteps(Ac);
                AA = AB / Math.sin(Math.toRadians(Ac));//求出AA，以便将AA赋值给BB

                //B舵机旋转角度
                BC = machineHeight - altitudeHeight;   //如图8，设备距离基准面的垂直高度
                BB = AA;      //AA为上次A舵机旋转时求出的斜边的长度，对应B舵机的一条直角边BB
//                AntiTriangle(BB,BC,Bb);
                Bc = Math.atan(BB / BC) / (Math.PI / 180);  //如图8，BC为设备距离基准面距离，BB为A设备当时求出的斜边，Bb角为90度，默认执行完这个函数，三角形6要素其它三个已得出，可求Bc(逆时针旋转)
                bAngle = getSteps(Bc);
                //x不涉及修正即1500；y需要进行修正即step_down=1450
//                getXY[i][j] = new GetXYVO((1450 - aAngle), (1450 - bAngle), Bc, Ac, UUIDUtils.getUUID(), operateId, sbCode);
                getScanPoints.add(getXY[i][j]);

            }
        }
        return getScanPoints;
    }

    public static List<GetXYVO> getXYStepts7(double machineHeight, double houseLength, double houseWide, double lengthPoint, double widePoint, double altitudeHeight, String operateId, String sbCode) {

        //初始化点数集合
        List<GetXYVO> getScanPoints = new ArrayList();
        log.info("第3象限");
        double AA, AB, AC, Aa, Ab, Ac;   //如上图,A舵机，大写ABC代表三个边，小写abc代表三个角。
        double BA, BB, BC, Ba, Bb, Bc;   //如上图,B舵机，大写ABC代表三个边，小写abc代表三个角。

        double lengthRemainder = lengthPoint % 2;   //取长度点数余数
        double wideRemainder = widePoint % 2;   //取宽度点数余数
        //四种情况：如果长度余数为0，宽度余数为0，情况如上图1
        //四种情况：如果长度余数为1，宽度余数为0，情况如上图2
        //四种情况：如果长度余数为0，宽度余数为1，情况如上图3
        //四种情况：如果长度余数为1，宽度余数为1，情况如上图4
        int aAngle;   //a舵机旋转角度，类型不对自己换
        int bAngle;   //b舵机旋转角度，类型不对自己换
        //初始化返回xy
        GetXYVO[][] getXY = new GetXYVO[(int) lengthPoint][(int) widePoint];
        int i, j;
        //测2区域
        for (i = 0; i < widePoint / 2; i++) {
            for (j = 0; j < lengthPoint / 2; j++) {
                //A舵机旋转角度
                if (lengthRemainder == 1)
                    AB = 2 * (lengthPoint / 2) - j * 2;     //2是步长
                else            //其实就是等于0
                    AB = 2 * (lengthPoint / 2) - 1 - j * 2;   //2是步长

                if (wideRemainder == 1)
                    AC = 2 * (widePoint / 2) - i * 2;   //2是步长
                else            //其实就是等于0
                    AC = 2 * (widePoint / 2) - 1 - i * 2;     //2是步长

                Ac = Math.atan(AB / AC) / (Math.PI / 180);     //如图12，已知AB边AC边以及Ab角（90度），默认执行完这个函数，三角形6要素其它三个已得出,可求Ac(逆时针旋转)
                aAngle = getSteps(Ac);
                AA = AB / Math.sin(Math.toRadians(Ac));//求出AA，以便将AA赋值给BB

                //B舵机旋转角度
                BC = machineHeight - altitudeHeight;   //如图8，设备距离基准面的垂直高度
                BB = AA;      //AA为上次A舵机旋转时求出的斜边的长度，对应B舵机的一条直角边BB
//                AntiTriangle(BB,BC,Bb);
                Bc = Math.atan(BB / BC) / (Math.PI / 180);  //如图8，BC为设备距离基准面距离，BB为A设备当时求出的斜边，Bb角为90度，默认执行完这个函数，三角形6要素其它三个已得出，可求Bc(逆时针旋转)
                bAngle = getSteps(Bc);
                //x不涉及修正即1500；y需要进行修正即step_down=1450
//                getXY[i][j] = new GetXYVO((1450 + aAngle), (1450 + bAngle), Bc, Ac, UUIDUtils.getUUID(), operateId, sbCode);
                getScanPoints.add(getXY[i][j]);

            }
        }
        return getScanPoints;
    }

    public static List<GetXYVO> getXYStepts8(double machineHeight, double houseLength, double houseWide, double lengthPoint, double widePoint, double altitudeHeight, String operateId, String sbCode) {

        //初始化点数集合
        List<GetXYVO> getScanPoints = new ArrayList();
        log.info("第4象限");
        double AA, AB, AC, Aa, Ab, Ac;   //如上图,A舵机，大写ABC代表三个边，小写abc代表三个角。
        double BA, BB, BC, Ba, Bb, Bc;   //如上图,B舵机，大写ABC代表三个边，小写abc代表三个角。

        double lengthRemainder = lengthPoint % 2;   //取长度点数余数
        double wideRemainder = widePoint % 2;   //取宽度点数余数
        //四种情况：如果长度余数为0，宽度余数为0，情况如上图1
        //四种情况：如果长度余数为1，宽度余数为0，情况如上图2
        //四种情况：如果长度余数为0，宽度余数为1，情况如上图3
        //四种情况：如果长度余数为1，宽度余数为1，情况如上图4
        int aAngle;   //a舵机旋转角度，类型不对自己换
        int bAngle;   //b舵机旋转角度，类型不对自己换
        //初始化返回xy
        GetXYVO[][] getXY = new GetXYVO[(int) lengthPoint][(int) widePoint];
        int i, j;
        //测2区域
        for (i = 0; i < widePoint / 2; i++) {
            for (j = 0; j < lengthPoint / 2; j++) {
                //A舵机旋转角度
                if (lengthRemainder == 1)
                    AB = 2 * (lengthPoint / 2) - j * 2;     //2是步长
                else            //其实就是等于0
                    AB = 2 * (lengthPoint / 2) - 1 - j * 2;   //2是步长

                if (wideRemainder == 1)
                    AC = 2 * (widePoint / 2) - i * 2;   //2是步长
                else            //其实就是等于0
                    AC = 2 * (widePoint / 2) - 1 - i * 2;     //2是步长

                Ac = Math.atan(AB / AC) / (Math.PI / 180);     //如图12，已知AB边AC边以及Ab角（90度），默认执行完这个函数，三角形6要素其它三个已得出,可求Ac(逆时针旋转)
                aAngle = getSteps(Ac);
                AA = AB / Math.sin(Math.toRadians(Ac));//求出AA，以便将AA赋值给BB

                //B舵机旋转角度
                BC = machineHeight - altitudeHeight;   //如图8，设备距离基准面的垂直高度
                BB = AA;      //AA为上次A舵机旋转时求出的斜边的长度，对应B舵机的一条直角边BB
//                AntiTriangle(BB,BC,Bb);
                Bc = Math.atan(BB / BC) / (Math.PI / 180);  //如图8，BC为设备距离基准面距离，BB为A设备当时求出的斜边，Bb角为90度，默认执行完这个函数，三角形6要素其它三个已得出，可求Bc(逆时针旋转)
                bAngle = getSteps(Bc);
                //x不涉及修正即1500；y需要进行修正即step_down=1450
//                getXY[i][j] = new GetXYVO((1450 - aAngle), (1450 + bAngle), Bc, Ac, UUIDUtils.getUUID(), operateId, sbCode);
                getScanPoints.add(getXY[i][j]);
            }
        }
        return getScanPoints;
    }


}