2020年4月 – gitweixin

Java 4月 24,2020

空间几何运算方法

private static final Logger logger = LoggerFactory.getLogger(AnalyseKit.class);
/***************************************************************************
 * 边界
 */
private static final double dis = 0.0000000001;
// 地图常量
public final static double _C_P = 0.017453292519943295;
// 地球经纬度, 偏差度
public final static double EARTH_RADIUS = 6371008.77141506;
// 单位经度
public static final long LONGITUDE_METER = 111413;
// 单位纬度
public static final long LATITUDE_METER = 111133;

/**
 * 求亮点之间的距离
 * 
 * @param str 坐标1
 * @param str2 坐标2
 * @return
 */
public static double getDistance(String str, String str2) {

    PointBean point1 = new PointBean();
    point1.setX(Double.parseDouble(str.split(",")[0]));
    point1.setY(Double.parseDouble(str.split(",")[1]));

    PointBean point2 = new PointBean();
    point2.setX(Double.parseDouble(str2.split(",")[0]));
    point2.setY(Double.parseDouble(str2.split(",")[1]));

    double meter = getDistance(point1, point2);
    return meter;
}

/**
 * 计算点是否在圆内
 * 
 * @param point 点坐标
 * @param pointPolygon 面边框坐标
 * @return
 */
public static boolean judgeMeetCircle(String point, String criclePoint, float r) {
    PointBean point1 = new PointBean();
    point1.setX(Double.parseDouble(point.split(",")[0]));
    point1.setY(Double.parseDouble(point.split(",")[1]));

    PointBean point2 = new PointBean();
    point2.setX(Double.parseDouble(criclePoint.split(",")[0]));
    point2.setY(Double.parseDouble(criclePoint.split(",")[1]));

    double d = getDistance(point1, point2);
    if (d <= r)
        return true;
    else
        return false;

}

/**
 * 判断是否在矩形内
 * 
 * @param minPt
 * @param maxPt
 * @param pt
 * @return
 */
public static boolean judgeInRect(PointBean minPt, PointBean maxPt, PointBean pt) {
    if (pt.getX() >= minPt.getX() && pt.getX() <= maxPt.getX() && pt.getY() >= minPt.getY()
            && pt.getY() <= maxPt.getY()) {
        return true;
    } else {
        return false;
    }
}

/**
 * 计算点是否在多边形内
 * 
 * @param point 点坐标
 * @param pointPolygon 面边框坐标
 * @return
 */
public static boolean judgeMeetPolygon(String linestr, String pointPolygon) {
    String string = pointPolygon;
    int index = 0;
    // 判断是否是飞地
    if (string.indexOf(";") != -1) {
        String[] points = string.split(";");
        for (String point : points) {
            if (AnalyseKit.judgeMeetPoint(linestr, point)) {
                return true;
            } else {
                index++;
            }
        }
        return (index == 0 || index > 1) ? false : true;
    } else if (string.indexOf("|") != -1) {// 判断是否是有洞
        String[] points = string.split("|");
        for (String point : points) {
            if (AnalyseKit.judgeMeetPoint(linestr, point))
                index++;
        }
        return (index == 0 || index > 1) ? false : true;
    } else {
        return AnalyseKit.judgeMeetPoint(linestr, string);
    }
}

// #################################私有方法#################################
private static boolean judgeMeetPoint(String point, String pointPolygon) {
    PointBean point2 = new PointBean();
    point2.setX(Double.parseDouble(point.split(",")[0]));
    point2.setY(Double.parseDouble(point.split(",")[1]));
    List<PointBean> list = AnalyseKit.evalPoints(pointPolygon);
    if (list.size() == 2) {
        return AnalyseKit.judgeInRect(list.get(0), list.get(1), point2);
    } else {
        return AnalyseKit.judgeMeetPoint(point2, list);
    }
}

/**
 * 转换坐标串
 * 
 * @param points
 * @return
 */
private static List<PointBean> evalPoints(String points) {
    List<PointBean> list = new ArrayList<PointBean>();
    String[] split = points.split(",");
    for (int i = 1; i < split.length; i++) {
        if (i % 2 == 1) {
            PointBean point3 = new PointBean();
            point3.setX(Double.parseDouble(split[i - 1]));
            point3.setY(Double.parseDouble(split[i]));
            list.add(point3);
        }
    }
    return list;
}

/**
 * 判断点是否在面内的算法
 * 
 * @param tpt 点坐标
 * @param polygonPtArray 面外边框坐标集合
 * @return
 */
private static boolean judgeMeetPoint(PointBean tpt, List<PointBean> polygonPtArray) {
    int MeetPointNum = 0;
    for (int i = 1; i < polygonPtArray.size(); i++) {
        PointBean pt1 = polygonPtArray.get(i - 1);
        PointBean pt2 = polygonPtArray.get(i);
        if (((tpt.getX() <= pt1.getX() && tpt.getX() >= pt2.getX())
                || (tpt.getX() >= pt1.getX() && tpt.getX() <= pt2.getX()))
                & (tpt.getY() >= pt1.getY() || tpt.getY() >= pt2.getY())
                & (pt1.getX() != pt2.getX() && pt1.getY() != pt2.getY())) {
            // 判断点是否在线上
            if (judgePtInLine(pt1, pt2, tpt)) {
                return true;
            }
            // 处理特殊情况，交点是端点的情况
            double temp;
            // temp相当于被除数(斜率的分母)
            temp = pt1.getX() - pt2.getX();
            if (temp >= -dis && temp <= dis) {
                // 处理交点情况
                double dx = tpt.getX() - pt1.getX();
                if (dx >= -dis && dx <= dis) {
                    int[] indexs = new int[2];
                    indexs[0] = 0;
                    indexs[1] = 0;
                    getNotSame(polygonPtArray, i, indexs);
                    PointBean linePt1, linePt2;
                    linePt1 = polygonPtArray.get(indexs[0]);
                    linePt2 = polygonPtArray.get(indexs[1]);
                    if (i > indexs[0]) {
                        break;
                    } else {
                        i = indexs[0] + 1;
                    }
                    if (tpt.getY() > pt1.getY() && ((tpt.getX() >= linePt1.getX() && tpt.getX() <= linePt2.getX())
                            || (tpt.getX() >= linePt2.getX() && tpt.getX() <= linePt1.getX())))
                        MeetPointNum++;
                }

            } else {
                double kk, bb;
                double MeetPtY, MeetPtX;
                kk = (pt1.getY() - pt2.getY()) / (pt1.getX() - pt2.getX());
                bb = pt1.getY() - kk * pt1.getX();
                MeetPtY = kk * tpt.getX() + bb;
                MeetPtX = tpt.getX();
                // 处理特殊情况，交点是端点的情况
                double dx, dy, dx2, dy2;
                dx = MeetPtX - pt1.getX();
                dy = MeetPtY - pt1.getY();
                dx2 = MeetPtX - pt2.getX();
                dy2 = MeetPtY - pt2.getY();
                if ((dx >= -dis && dx <= dis && dy >= -dis && dy <= dis)) {
                    PointBean pt3;
                    if (i == 1) {
                        pt3 = polygonPtArray.get(polygonPtArray.size() - 2);
                    } else {
                        pt3 = polygonPtArray.get(i - 2);
                    }
                    // 提取交点的上下两点分别在垂线的两侧
                    if (tpt.getY() > MeetPtY && ((MeetPtX >= pt3.getY() && MeetPtX <= pt2.getX())
                            || (MeetPtX >= pt2.getX() && MeetPtX <= pt3.getX())))
                        MeetPointNum++;
                } else if (!(dx2 >= -dis && dx2 <= dis && dy2 >= -dis && dy2 <= dis)) {
                    if (tpt.getY() > MeetPtY) {
                        MeetPointNum++;
                    }
                }
            }
        }
    }
    if (MeetPointNum % 2 == 1)
        return true;
    else
        return false;
}

/**
 * 判断点是否在线上
 * 
 * @param tpt1
 * @param tpt2
 * @param tpt
 * @return
 */
private static boolean judgePtInLine(PointBean tpt1, PointBean tpt2, PointBean tpt) {
    double dx1 = getDistance(tpt1, tpt2);
    double dx2 = getDistance(tpt, tpt1);
    double dx3 = getDistance(tpt, tpt2);
    double dx = dx3 + dx2 - dx1;
    if (dx >= -dis && dx <= dis) {
        return true;
    }
    return false;
}

private static double getDistance(PointBean p1, PointBean p2) {
    double k = 0.0;
    double h = (p2.x - p1.x) * _C_P;
    double g = (p2.y - p1.y) * _C_P;
    double f = Math.sin(0.5 * g) * Math.sin(0.5 * g)
            + Math.cos(p1.y * _C_P) * Math.cos(p2.y * _C_P) * (Math.sin(0.5 * h) * Math.sin(0.5 * h));

    f = Math.abs(f);

    if (f > 1) {
        logger.info("不合法数据:" + f + ",P1:" + p1.toString() + ",P2:" + p2.toString());
        return -1;
    }
    double m = 2 * Math.atan2(Math.sqrt(f), Math.sqrt(1 - f));
    k = m * EARTH_RADIUS;
    if (Math.abs(p2.x - p1.x) > 180 || Math.abs(p2.y - p1.y) > 180) {
        k = 2 * Math.PI * EARTH_RADIUS - k;
    }
    k = Math.ceil(k);

    int meter = (int) k;

    return meter;
}

/**
 * 在链表中获取x轴不相同的点
 * 
 * @param pointArray
 * @param index
 * @param indexs
 */
private static void getNotSame(List<PointBean> pointArray, int index, int[] indexs) {
    indexs[0] = indexs[1] = -1;
    int size = pointArray.size();
    PointBean buftpt, tpt;
    tpt = pointArray.get(index);
    for (int i = index; i < size; i++) {
        buftpt = pointArray.get(i);
        if (buftpt.getX() != tpt.getX()) {
            indexs[0] = i;
            break;
        }
    }
    if (indexs[0] == -1) {
        for (int i = 0; i < size; i++) {
            buftpt = (PointBean) pointArray.get(i);
            if (buftpt.getX() != tpt.getX()) {
                indexs[0] = i;
                break;
            }
        }
    }
    for (int j = index; j >= 0; j--) {
        buftpt = (PointBean) pointArray.get(j);
        if (buftpt.getX() != tpt.getX()) {
            indexs[1] = j;
            break;
        }
    }
    if (indexs[1] == -1) {
        for (int j = size - 1; j >= 0; j--) {
            buftpt = pointArray.get(j);
            if (buftpt.getX() != tpt.getX()) {
                indexs[1] = j;
                break;
            }
        }
    }
}

/**
 * 计算指定处的距离(米)换算为距离(度) ---纬度方向上
 * 
 * @param distance 单位m
 * @return 纬度方向上
 */
public static double lenToLat(double distance) {
    return distance / LATITUDE_METER;
}

/**
 * 计算指定处的距离(米)换算为距离(度) ---经度方向上
 * 
 * @param distnace 单位m
 * @param r 指定点的纬度值
 * @return
 */
public static double lenToLong(double distnace, double degree) {
    double dLatRaian = degree * Math.PI / 180;
    return distnace / (LONGITUDE_METER * Math.cos(dLatRaian));
}

作者 east

Java 4月 24,2020

计算地图2点距离-地图工具类

private static final double DEF_PI = 3.14159265359;

private static final double DEF_2PI = 6.28318530712;

private static final double DEF_PI180 = 0.01745329252;

private static final double DEF_R = 6370693.5; // 地球半径

/**
 * 利用勾股定理计算，适用两点距离很近的情况
 *
 * @param lon1 第一个坐标经度
 * @param lat1 第一个坐标纬度
 * @param lon2 第二个坐标经度
 * @param lat2 第二个坐标纬度
 * @return
 */
public static double getShortDistance(double lon1, double lat1, double lon2, double lat2) {
    double ew1;
    double ns1;
    double ew2;
    double ns2;

    double dx;
    double dy;
    double dew;

    double distance;
    // 角度转换为弧度
    ew1 = lon1 * DEF_PI180;
    ns1 = lat1 * DEF_PI180;
    ew2 = lon2 * DEF_PI180;
    ns2 = lat2 * DEF_PI180;
    // 经度差
    dew = ew1 - ew2;
    // 若跨东经和西经180度，进行调整
    if (dew > DEF_PI) {
        dew = DEF_2PI - dew;
    } else if (dew < -DEF_PI) {
        dew = DEF_2PI + dew;
    }
    dx = DEF_R * Math.cos(ns1) * dew; // 东西方向长度（在纬度圆上的投影长度）
    dy = DEF_R * (ns1 - ns2); // 南北方向长度（在经度圆上的投影长度）
    // 勾股定理求你斜边长
    distance = Math.sqrt(dx * dx + dy * dy);
    return distance;
}

/**
 * 按标准的球面大圆劣弧长度计算，适用距离较远的情况
 *
 * @param lon1 第一个坐标经度
 * @param lat1 第一个坐标纬度
 * @param lon2 第二个坐标经度
 * @param lat2 第二个坐标纬度
 * @return
 */
public static double getLongDistance(double lon1, double lat1, double lon2, double lat2) {
    double ew1;
    double ns1;
    double ew2;
    double ns2;
    double distance;
    // 角度转换为弧度
    ew1 = lon1 * DEF_PI180;
    ns1 = lat1 * DEF_PI180;
    ew2 = lon2 * DEF_PI180;
    ns2 = lat2 * DEF_PI180;
    // 求大圆劣弧与球心所夹的角（弧度）
    distance = Math.sin(ns1) * Math.sin(ns2) + Math.cos(ns1) * Math.cos(ns2) * Math.cos(ew1 - ew2);
    // 调整到[-1..1]范围内，避免溢出
    if (distance > 1.0) {
        distance = 1.0;
    } else if (distance < -1.0) {
        distance = -1.0;
    }
    // 求大圆劣弧长度
    distance = DEF_R * Math.acos(distance);
    return distance;
}

作者 east

bug清单 4月 13,2020

lnmp解决mysql The server quit without updating PID file

lnmp安装包，挂个小网站，mysql跑了几年，一直没去动它。后来有时mysql 挂掉了，偷懒写个自动重启脚本，又继续安稳几个月时间。今天突然发现mysql挂了，重启了报“The server quit without updating PID file”。按网上方法试了还是没解决，后来看到有点说磁盘满了，“df -l”一查看，果真满了，请了日志后果然能重启mysql正常了。

后来又遇到这个问题，磁盘没满。看到错误日志有
“Plugin ‘FEDERATED’ is disabled”

在my.cnf文件中的 [mysqld] 中增加一行
tmpdir=”/usr/local/mysql/var”

同时增加权限 chown mysql:mysql /usr/local/mysql/var

运行service mysql start还是出错，查看错误日志看到

InnoDB: Database page corruption on disk or a failed

添加下面内容:

innodb_force_recovery=1

再启动mysql

则可以正常启动。

作者 east

月度归档4月 2020