package bianjie;
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.Locale;
|
|
/**
|
* 自动化边界优化工具类 - 自适应增强版
|
* 目标：95%+ 还原度，自动识别直线与曲线，最少化点数
|
*/
|
public class Bianjieyouhuatoxy {
|
private static final double EARTH_RADIUS = 6378137.0;
|
// 基准阈值配置
|
private static final double MIN_DIST_THRESHOLD = 0.03; // 最小去重位移(3cm)
|
private static final double BASE_EPSILON = 0.05; // 基础共线误差(5cm)
|
private static final double MAX_EPSILON = 0.15; // 直线段最大容忍误差(15cm)
|
|
private static class PointXY {
|
double x, y;
|
public PointXY(double x, double y) {
|
this.x = x;
|
this.y = y;
|
}
|
}
|
|
/**
|
* 静态入口方法
|
* @param originStr "3949.89151752,N,11616.79267501,E"
|
* @param boundaryStr "(lat1,lon1,alt1;...)"
|
*/
|
public static String optimizeBoundary(String originStr, String boundaryStr) {
|
try {
|
// 1. 解析参考原点
|
double[] originDD = parseNmeaToDD(originStr);
|
double originLat = originDD[0];
|
double originLon = originDD[1];
|
|
// 2. 坐标投影比例
|
double metersPerDegLat = Math.PI * EARTH_RADIUS / 180.0;
|
double metersPerDegLon = metersPerDegLat * Math.cos(Math.toRadians(originLat));
|
|
// 3. 数据清洗与初步投影
|
List<PointXY> rawPoints = extractPoints(boundaryStr, originLat, originLon, metersPerDegLat, metersPerDegLon);
|
if (rawPoints.size() < 3) return formatOutput(rawPoints);
|
|
// 4. 第一步：静态滤波（去除物理意义上的重复点）
|
List<PointXY> filteredPoints = staticFilter(rawPoints);
|
|
// 5. 第二步：自适应特征识别压缩 (核心算法)
|
List<PointXY> optimizedPoints = adaptiveSimplify(filteredPoints);
|
|
return formatOutput(optimizedPoints);
|
} catch (Exception e) {
|
return "ERROR: " + e.getMessage();
|
}
|
}
|
|
/**
|
* 自适应简化算法
|
* 原理：计算当前点前后的向量夹角，夹角越接近180度（直线），容忍度越高；
|
* 夹角越小（急转弯），容忍度越低。
|
*/
|
private static List<PointXY> adaptiveSimplify(List<PointXY> points) {
|
if (points.size() < 3) return points;
|
|
List<PointXY> result = new ArrayList<>();
|
result.add(points.get(0));
|
|
int anchorIdx = 0; // 锚点（线段起点）
|
|
for (int i = 1; i < points.size() - 1; i++) {
|
PointXY pA = points.get(anchorIdx);
|
PointXY pB = points.get(i);
|
PointXY pC = points.get(i + 1);
|
|
// 1. 计算点B到AC直线的垂直距离
|
double dist = getVerticalDistance(pB, pA, pC);
|
|
// 2. 计算自适应阈值：分析特征
|
// 计算向量 AB 和 BC 的夹角余弦值
|
double cosTheta = calculateCosine(pA, pB, pC);
|
|
// 动态阈值逻辑：
|
// 如果 cosTheta 接近 -1 (即方向几乎没变，180度)，使用 MAX_EPSILON
|
// 如果 cosTheta 偏离较大 (转弯)，使用 BASE_EPSILON
|
double dynamicEpsilon = BASE_EPSILON + (MAX_EPSILON - BASE_EPSILON) * Math.abs(cosTheta + 1);
|
// 针对割草机特征优化：夹角越锐利，阈值越小，确保拐角不被削平
|
if (cosTheta > -0.7) {
|
dynamicEpsilon = MIN_DIST_THRESHOLD; // 疑似急转弯，强制保留特征
|
}
|
|
if (dist > dynamicEpsilon) {
|
result.add(pB);
|
anchorIdx = i;
|
}
|
}
|
|
result.add(points.get(points.size() - 1));
|
return result;
|
}
|
|
private static double getVerticalDistance(PointXY p, PointXY start, PointXY end) {
|
double area = Math.abs(0.5 * (start.x * end.y + end.x * p.y + p.x * start.y
|
- end.x * start.y - p.x * end.y - start.x * p.y));
|
double bottom = Math.sqrt(Math.pow(start.x - end.x, 2) + Math.pow(start.y - end.y, 2));
|
return (bottom == 0) ? 0 : (2.0 * area) / bottom;
|
}
|
|
private static double calculateCosine(PointXY a, PointXY b, PointXY c) {
|
double v1x = b.x - a.x;
|
double v1y = b.y - a.y;
|
double v2x = c.x - b.x;
|
double v2y = c.y - b.y;
|
double mag1 = Math.sqrt(v1x*v1x + v1y*v1y);
|
double mag2 = Math.sqrt(v2x*v2x + v2y*v2y);
|
if (mag1 == 0 || mag2 == 0) return -1;
|
return (v1x*v2x + v1y*v2y) / (mag1 * mag2);
|
}
|
|
private static List<PointXY> staticFilter(List<PointXY> input) {
|
List<PointXY> res = new ArrayList<>();
|
res.add(input.get(0));
|
for (int i = 1; i < input.size(); i++) {
|
PointXY cur = input.get(i);
|
PointXY last = res.get(res.size() - 1);
|
if (Math.sqrt(Math.pow(cur.x-last.x,2) + Math.pow(cur.y-last.y,2)) > MIN_DIST_THRESHOLD) {
|
res.add(cur);
|
}
|
}
|
return res;
|
}
|
|
private static double[] parseNmeaToDD(String nmea) {
|
String clean = nmea.replaceAll("[()\\s]", "");
|
String[] p = clean.split("[,，]");
|
// 兼容原点格式 (3949.89,N,11616.79,E) 或 (3949.89,11616.79)
|
double lat = dmToDd(Double.parseDouble(p[0]));
|
double lon = (p.length >= 3) ? dmToDd(Double.parseDouble(p[2])) : dmToDd(Double.parseDouble(p[1]));
|
return new double[]{lat, lon};
|
}
|
|
private static double dmToDd(double dm) {
|
int d = (int)(dm / 100);
|
return d + (dm - d * 100) / 60.0;
|
}
|
|
private static List<PointXY> extractPoints(String raw, double oLat, double oLon, double mLat, double mLon) {
|
List<PointXY> list = new ArrayList<>();
|
String clean = raw.replaceAll("[()\\s]", "");
|
for (String segment : clean.split(";")) {
|
String[] p = segment.split("[,，]");
|
if (p.length < 2) continue;
|
double lat = dmToDd(Double.parseDouble(p[0]));
|
double lon = dmToDd(Double.parseDouble(p[1]));
|
list.add(new PointXY((lon - oLon) * mLon, (lat - oLat) * mLat));
|
}
|
return list;
|
}
|
|
private static String formatOutput(List<PointXY> points) {
|
StringBuilder sb = new StringBuilder();
|
for (int i = 0; i < points.size(); i++) {
|
sb.append(String.format(Locale.US, "%.3f,%.3f", points.get(i).x, points.get(i).y));
|
if (i < points.size() - 1) sb.append(";");
|
}
|
return sb.toString();
|
}
|
|
/**
|
* 根据优化后的坐标字符串计算地块面积
|
* @param optimizedXYStr 格式为 "X0,Y0;X1,Y1;X2,Y2..." 的字符串
|
* @return 面积字符串，单位平方米（保留两位小数）
|
*/
|
public static String calculateArea(String optimizedXYStr) {
|
if (optimizedXYStr == null || optimizedXYStr.isEmpty()) {
|
return "0.00";
|
}
|
|
List<PointXY> points = new ArrayList<>();
|
try {
|
String[] pairs = optimizedXYStr.split(";");
|
for (String pair : pairs) {
|
String[] coords = pair.split(",");
|
if (coords.length == 2) {
|
points.add(new PointXY(
|
Double.parseDouble(coords[0]),
|
Double.parseDouble(coords[1])
|
));
|
}
|
}
|
|
if (points.size() < 3) return "0.00";
|
|
// 使用鞋带公式 (Shoelace Formula) 计算多边形面积
|
double area = 0.0;
|
int n = points.size();
|
|
for (int i = 0; i < n; i++) {
|
PointXY p1 = points.get(i);
|
PointXY p2 = points.get((i + 1) % n); // 自动闭合到起点
|
|
// 核心计算：(x1*y2 - x2*y1)
|
area += (p1.x * p2.y) - (p2.x * p1.y);
|
}
|
|
area = Math.abs(area) / 2.0;
|
|
// 格式化输出，保留两位小数
|
return String.format(Locale.US, "%.2f", area);
|
|
} catch (Exception e) {
|
e.printStackTrace();
|
return "0.00";
|
}
|
}
|
|
/**
|
* 根据优化后的坐标字符串计算边界点数
|
* @param optimizedXYStr 格式为 "X0,Y0;X1,Y1;X2,Y2..." 的字符串
|
* @return 边界点数
|
*/
|
public static int calculatePointCount(String optimizedXYStr) {
|
if (optimizedXYStr == null || optimizedXYStr.isEmpty()) {
|
return 0;
|
}
|
|
try {
|
String[] pairs = optimizedXYStr.split(";");
|
int count = 0;
|
for (String pair : pairs) {
|
String[] coords = pair.split(",");
|
if (coords.length == 2) {
|
count++;
|
}
|
}
|
return count;
|
} catch (Exception e) {
|
e.printStackTrace();
|
return 0;
|
}
|
}
|
}
|
