package bianjie;
|
|
import java.util.ArrayList;
|
import java.util.List;
|
|
import zhuye.Coordinate;
|
|
public class bianjieguihua2 {
|
/**
|
* 优化边界XY坐标字符串
|
*
|
* @param boundaryXYString 边界XY坐标字符串，格式："X0,Y0;X1,Y1;X2,Y2;..."
|
* @return 优化后的边界坐标字符串，格式："X0,Y0;X1,Y1;X2,Y2;..."
|
*/
|
public static String optimizeBoundaryXYString(String boundaryXYString) {
|
try {
|
// 检查输入数据
|
if (boundaryXYString == null || boundaryXYString.trim().isEmpty()) {
|
throw new IllegalArgumentException("边界坐标字符串不能为空");
|
}
|
|
// 解析XY坐标字符串
|
List<BoundaryAlgorithm.Coordinate> localCoordinates = parseXYString(boundaryXYString);
|
|
if (localCoordinates == null || localCoordinates.isEmpty()) {
|
throw new IllegalArgumentException("无法解析边界坐标字符串");
|
}
|
|
// 三角形小区域特殊处理，避免过度插值导致点数扩增
|
if (localCoordinates.size() == 3) {
|
double triangleArea = calculatePolygonArea(localCoordinates);
|
double trianglePerimeter = calculatePerimeter(localCoordinates);
|
|
System.out.println("检测到三角形边界，面积=" + String.format("%.2f", triangleArea) +
|
"m², 周长=" + String.format("%.2f", trianglePerimeter) + "m");
|
|
if (triangleArea < 100.0 || trianglePerimeter < 30.0) {
|
System.out.println("小三角形，跳过插值优化");
|
BoundaryAlgorithm.Coordinate firstPoint = localCoordinates.get(0);
|
List<BoundaryAlgorithm.Coordinate> trianglePoints = new ArrayList<>(localCoordinates);
|
trianglePoints.add(new BoundaryAlgorithm.Coordinate(
|
firstPoint.x,
|
firstPoint.y,
|
firstPoint.lat,
|
firstPoint.lon));
|
return convertBoundaryPointsToString(trianglePoints);
|
}
|
}
|
|
// 创建算法实例
|
BoundaryAlgorithm algorithm = new BoundaryAlgorithm();
|
|
// 自动场景分析（基于XY坐标，无高程数据）
|
BoundaryAlgorithm.SceneAnalysis sceneAnalysis = analyzeSceneFromXYCoordinates(localCoordinates);
|
System.out.println("自动场景分析结果:");
|
System.out.println(sceneAnalysis.toString());
|
|
// 根据场景分析结果获取参数
|
BoundaryAlgorithm.BoundaryParameters params =
|
algorithm.getParametersForPreset(sceneAnalysis.suggestedPreset);
|
|
System.out.println("自动选择的参数: 间隔=" + params.interval + "米, 角度阈值=" +
|
params.angleThreshold + "度");
|
|
// 使用优化算法处理边界
|
List<BoundaryAlgorithm.Coordinate> optimizedPoints =
|
algorithm.optimizeBoundaryPointsAdvanced(localCoordinates, params);
|
|
// 质量评估
|
BoundaryAlgorithm.BoundaryQuality boundaryQuality =
|
algorithm.evaluateBoundaryQuality(optimizedPoints);
|
|
System.out.println("边界质量评估结果:");
|
System.out.println(boundaryQuality.toString());
|
|
// 转换为输出字符串格式
|
return convertBoundaryPointsToString(optimizedPoints);
|
|
} catch (Exception e) {
|
throw new RuntimeException("优化边界坐标字符串时发生错误: " + e.getMessage(), e);
|
}
|
}
|
|
/**
|
* 解析XY坐标字符串为Coordinate列表
|
*
|
* @param xyString XY坐标字符串，格式："X0,Y0;X1,Y1;X2,Y2;..."
|
* @return Coordinate列表
|
*/
|
private static List<BoundaryAlgorithm.Coordinate> parseXYString(String xyString) {
|
List<BoundaryAlgorithm.Coordinate> coordinates = new ArrayList<>();
|
|
if (xyString == null || xyString.trim().isEmpty()) {
|
return coordinates;
|
}
|
|
String[] points = xyString.split(";");
|
for (String point : points) {
|
point = point.trim();
|
if (point.isEmpty()) {
|
continue;
|
}
|
|
String[] parts = point.split(",");
|
if (parts.length >= 2) {
|
try {
|
double x = Double.parseDouble(parts[0].trim());
|
double y = Double.parseDouble(parts[1].trim());
|
// lat和lon设为0，因为我们只需要XY坐标
|
coordinates.add(new BoundaryAlgorithm.Coordinate(x, y, 0.0, 0.0));
|
} catch (NumberFormatException e) {
|
System.err.println("解析坐标失败: " + point + ", 错误: " + e.getMessage());
|
}
|
}
|
}
|
|
return coordinates;
|
}
|
|
/**
|
* 基于XY坐标进行场景分析（无高程数据）
|
*/
|
private static BoundaryAlgorithm.SceneAnalysis analyzeSceneFromXYCoordinates(
|
List<BoundaryAlgorithm.Coordinate> localCoords) {
|
|
BoundaryAlgorithm.SceneAnalysis analysis = new BoundaryAlgorithm.SceneAnalysis();
|
|
if (localCoords.size() < 3) {
|
analysis.suggestedPreset = "复杂小区域";
|
return analysis;
|
}
|
|
// 计算基本统计信息
|
calculateBasicStatisticsFromCoordinates(localCoords, analysis);
|
|
// 计算边界复杂度
|
calculateBoundaryComplexityFromCoordinates(localCoords, analysis);
|
|
// 无高程数据，设置为0
|
analysis.elevationRange = 0;
|
|
// 自动选择预设场景（不考虑高程因素）
|
selectPresetAutomaticallyFromXYCoordinates(analysis);
|
|
return analysis;
|
}
|
|
/**
|
* 从XY坐标自动选择预设场景（不考虑高程因素）
|
*/
|
private static void selectPresetAutomaticallyFromXYCoordinates(BoundaryAlgorithm.SceneAnalysis analysis) {
|
// 决策逻辑基于面积和复杂度
|
double areaWeight = 0.6;
|
double complexityWeight = 0.4;
|
|
// 计算综合得分
|
double score = 0;
|
|
// 面积因素：面积越大，越适合大间隔
|
double areaScore = Math.min(1.0, analysis.area / 1000.0); // 1000平方米为基准
|
score += areaScore * areaWeight;
|
|
// 复杂度因素：复杂度越高，越需要小间隔
|
double complexityScore = analysis.complexity;
|
score += complexityScore * complexityWeight;
|
|
// 根据得分选择预设
|
if (score < 0.3) {
|
analysis.suggestedPreset = "平坦大区域";
|
} else if (score < 0.6) {
|
analysis.suggestedPreset = "常规区域";
|
} else {
|
analysis.suggestedPreset = "复杂小区域";
|
}
|
|
System.out.println("自动场景选择得分: " + String.format("%.2f", score) + " -> " + analysis.suggestedPreset);
|
}
|
|
/**
|
* 自动处理Coordinate列表并生成优化后的边界坐标（无需传入间隔和角度阈值）
|
*
|
* @param coordinates Coordinate对象列表
|
* @param baseStation 基准站坐标，格式："纬度,N/S,经度,E/W" 例如："2324.194945,N,11330.938547,E"
|
* @return 优化后的边界坐标字符串，格式："X0,Y0;X1,Y1;X2,Y2;..."
|
*/
|
public static String processCoordinateListAuto(String baseStation) {
|
List<Coordinate> coordinates =Coordinate.coordinates;
|
try {
|
// 检查输入数据
|
if (coordinates == null || coordinates.isEmpty()) {
|
throw new IllegalArgumentException("坐标列表不能为空");
|
}
|
|
if (baseStation == null || baseStation.trim().isEmpty()) {
|
throw new IllegalArgumentException("基站坐标不能为空");
|
}
|
|
// 解析基准站坐标
|
String[] baseParts = baseStation.split(",");
|
if (baseParts.length != 4) {
|
throw new IllegalArgumentException("基准站坐标格式错误，应为: 纬度,N/S,经度,E/W");
|
}
|
|
double baseLat = parseDMToDecimal(baseParts[0], baseParts[1]);
|
double baseLon = parseDMToDecimal(baseParts[2], baseParts[3]);
|
|
// 将Coordinate列表转换为局部坐标系坐标
|
List<BoundaryAlgorithm.Coordinate> localCoordinates =
|
convertToLocalCoordinates(coordinates, baseLat, baseLon);
|
|
// 三角形小区域特殊处理，避免过度插值导致点数扩增
|
if (localCoordinates.size() == 3) {
|
double triangleArea = calculatePolygonArea(localCoordinates);
|
double trianglePerimeter = calculatePerimeter(localCoordinates);
|
|
System.out.println("检测到三角形边界，面积=" + String.format("%.2f", triangleArea) +
|
"m², 周长=" + String.format("%.2f", trianglePerimeter) + "m");
|
|
if (triangleArea < 100.0 || trianglePerimeter < 30.0) {
|
System.out.println("小三角形，跳过插值优化");
|
BoundaryAlgorithm.Coordinate firstPoint = localCoordinates.get(0);
|
List<BoundaryAlgorithm.Coordinate> trianglePoints = new ArrayList<>(localCoordinates);
|
trianglePoints.add(new BoundaryAlgorithm.Coordinate(
|
firstPoint.x,
|
firstPoint.y,
|
firstPoint.lat,
|
firstPoint.lon));
|
return convertBoundaryPointsToString(trianglePoints);
|
}
|
}
|
|
// 创建算法实例
|
BoundaryAlgorithm algorithm = new BoundaryAlgorithm();
|
|
// 自动场景分析（增强版，使用高程数据）
|
BoundaryAlgorithm.SceneAnalysis sceneAnalysis = analyzeSceneFromCoordinates(localCoordinates, coordinates);
|
System.out.println("自动场景分析结果:");
|
System.out.println(sceneAnalysis.toString());
|
|
// 根据场景分析结果获取参数
|
BoundaryAlgorithm.BoundaryParameters params =
|
algorithm.getParametersForPreset(sceneAnalysis.suggestedPreset);
|
|
System.out.println("自动选择的参数: 间隔=" + params.interval + "米, 角度阈值=" +
|
params.angleThreshold + "度");
|
|
// 使用优化算法处理边界
|
List<BoundaryAlgorithm.Coordinate> optimizedPoints =
|
algorithm.optimizeBoundaryPointsAdvanced(localCoordinates, params);
|
|
// 质量评估
|
BoundaryAlgorithm.BoundaryQuality boundaryQuality =
|
algorithm.evaluateBoundaryQuality(optimizedPoints);
|
|
System.out.println("边界质量评估结果:");
|
System.out.println(boundaryQuality.toString());
|
|
// 转换为输出字符串格式
|
return convertBoundaryPointsToString(optimizedPoints);
|
|
} catch (Exception e) {
|
throw new RuntimeException("自动处理坐标列表时发生错误: " + e.getMessage(), e);
|
}
|
}
|
|
/**
|
* 基于坐标列表进行场景分析（增强版，使用高程数据）
|
*/
|
private static BoundaryAlgorithm.SceneAnalysis analyzeSceneFromCoordinates(
|
List<BoundaryAlgorithm.Coordinate> localCoords, List<Coordinate> originalCoords) {
|
|
BoundaryAlgorithm.SceneAnalysis analysis = new BoundaryAlgorithm.SceneAnalysis();
|
|
if (localCoords.size() < 3) {
|
analysis.suggestedPreset = "复杂小区域";
|
return analysis;
|
}
|
|
// 计算基本统计信息
|
calculateBasicStatisticsFromCoordinates(localCoords, analysis);
|
|
// 计算边界复杂度
|
calculateBoundaryComplexityFromCoordinates(localCoords, analysis);
|
|
// 计算高程变化（使用原始坐标的高程数据）
|
calculateElevationStatistics(originalCoords, analysis);
|
|
// 自动选择预设场景（增强版，考虑高程因素）
|
selectPresetAutomaticallyFromCoordinates(analysis);
|
|
return analysis;
|
}
|
|
/**
|
* 从坐标计算基本统计信息
|
*/
|
private static void calculateBasicStatisticsFromCoordinates(
|
List<BoundaryAlgorithm.Coordinate> points, BoundaryAlgorithm.SceneAnalysis analysis) {
|
|
// 计算总距离
|
analysis.totalDistance = 0;
|
for (int i = 1; i < points.size(); i++) {
|
analysis.totalDistance += calculateDistance(points.get(i-1), points.get(i));
|
}
|
|
// 计算面积
|
analysis.area = calculatePolygonArea(points);
|
|
// 计算平均速度 (假设时间间隔为1秒)
|
if (points.size() > 1) {
|
analysis.avgSpeed = analysis.totalDistance / (points.size() - 1);
|
} else {
|
analysis.avgSpeed = 0;
|
}
|
}
|
|
/**
|
* 计算高程统计信息
|
*/
|
private static void calculateElevationStatistics(List<Coordinate> coordinates,
|
BoundaryAlgorithm.SceneAnalysis analysis) {
|
if (coordinates == null || coordinates.isEmpty()) {
|
analysis.elevationRange = 0;
|
return;
|
}
|
|
double minElevation = Double.MAX_VALUE;
|
double maxElevation = Double.MIN_VALUE;
|
|
for (Coordinate coord : coordinates) {
|
double elevation = coord.getElevation();
|
if (elevation < minElevation) minElevation = elevation;
|
if (elevation > maxElevation) maxElevation = elevation;
|
}
|
|
analysis.elevationRange = maxElevation - minElevation;
|
|
// 计算平均高程
|
double sumElevation = 0;
|
for (Coordinate coord : coordinates) {
|
sumElevation += coord.getElevation();
|
}
|
double avgElevation = sumElevation / coordinates.size();
|
|
System.out.println("高程统计: 范围=" + String.format("%.2f", analysis.elevationRange) +
|
"米, 平均=" + String.format("%.2f", avgElevation) + "米");
|
}
|
|
/**
|
* 从坐标计算边界复杂度
|
*/
|
private static void calculateBoundaryComplexityFromCoordinates(
|
List<BoundaryAlgorithm.Coordinate> points, BoundaryAlgorithm.SceneAnalysis analysis) {
|
|
if (points.size() < 3) {
|
analysis.complexity = 0;
|
return;
|
}
|
|
double totalAngleChange = 0;
|
int angleCount = 0;
|
|
for (int i = 1; i < points.size() - 1; i++) {
|
double angleChange = Math.abs(calculateAngleChange(
|
points.get(i-1), points.get(i), points.get(i+1)
|
));
|
totalAngleChange += angleChange;
|
angleCount++;
|
}
|
|
// 复杂度基于角度变化和边界长度
|
double avgAngleChange = angleCount > 0 ? totalAngleChange / angleCount : 0;
|
|
// 标准化复杂度 (0-1范围)
|
analysis.complexity = Math.min(1.0, avgAngleChange / 45.0); // 45度作为高复杂度阈值
|
}
|
|
/**
|
* 从坐标自动选择预设场景（增强版，考虑高程因素）
|
*/
|
private static void selectPresetAutomaticallyFromCoordinates(BoundaryAlgorithm.SceneAnalysis analysis) {
|
// 决策逻辑基于多个因素
|
double areaWeight = 0.4;
|
double complexityWeight = 0.3;
|
double elevationWeight = 0.3; // 增加高程权重
|
|
// 计算综合得分
|
double score = 0;
|
|
// 面积因素：面积越大，越适合大间隔
|
double areaScore = Math.min(1.0, analysis.area / 1000.0); // 1000平方米为基准
|
score += areaScore * areaWeight;
|
|
// 复杂度因素：复杂度越高，越需要小间隔
|
double complexityScore = analysis.complexity;
|
score += complexityScore * complexityWeight;
|
|
// 高程因素：高程变化越大，越需要精细处理
|
double elevationScore = Math.min(1.0, analysis.elevationRange / 20.0); // 20米变化为基准
|
score += elevationScore * elevationWeight;
|
|
// 根据得分选择预设
|
if (score < 0.3) {
|
analysis.suggestedPreset = "平坦大区域";
|
} else if (score < 0.6) {
|
analysis.suggestedPreset = "常规区域";
|
} else {
|
analysis.suggestedPreset = "复杂小区域";
|
}
|
|
System.out.println("自动场景选择得分: " + String.format("%.2f", score) + " -> " + analysis.suggestedPreset);
|
}
|
|
/**
|
* 计算两点间距离
|
*/
|
private static double calculateDistance(BoundaryAlgorithm.Coordinate p1, BoundaryAlgorithm.Coordinate p2) {
|
double dx = p2.x - p1.x;
|
double dy = p2.y - p1.y;
|
return Math.sqrt(dx * dx + dy * dy);
|
}
|
|
/**
|
* 计算角度变化
|
*/
|
private static double calculateAngleChange(BoundaryAlgorithm.Coordinate prev,
|
BoundaryAlgorithm.Coordinate current,
|
BoundaryAlgorithm.Coordinate next) {
|
double angle1 = Math.atan2(current.y - prev.y, current.x - prev.x);
|
double angle2 = Math.atan2(next.y - current.y, next.x - current.x);
|
|
double angleChange = Math.toDegrees(angle2 - angle1);
|
|
// 规范化角度到 [-180, 180]
|
while (angleChange > 180) angleChange -= 360;
|
while (angleChange < -180) angleChange += 360;
|
|
return angleChange;
|
}
|
|
/**
|
* 计算多边形面积
|
*/
|
private static double calculatePolygonArea(List<BoundaryAlgorithm.Coordinate> points) {
|
if (points.size() < 3) return 0.0;
|
|
double area = 0.0;
|
int n = points.size();
|
|
for (int i = 0; i < n; i++) {
|
BoundaryAlgorithm.Coordinate current = points.get(i);
|
BoundaryAlgorithm.Coordinate next = points.get((i + 1) % n);
|
area += (current.x * next.y - next.x * current.y);
|
}
|
|
return Math.abs(area) / 2.0;
|
}
|
|
private static double calculatePerimeter(List<BoundaryAlgorithm.Coordinate> points) {
|
if (points == null || points.size() != 3) {
|
return 0.0;
|
}
|
double d1 = calculateDistance(points.get(0), points.get(1));
|
double d2 = calculateDistance(points.get(1), points.get(2));
|
double d3 = calculateDistance(points.get(2), points.get(0));
|
return d1 + d2 + d3;
|
}
|
|
// ============ 其他方法保持不变 ============
|
|
/**
|
* 将度分格式坐标转换为十进制度格式
|
*/
|
private static double parseDMToDecimal(String dmCoord, String direction) {
|
try {
|
if (dmCoord == null || dmCoord.isEmpty()) {
|
return 0;
|
}
|
|
int dotIndex = dmCoord.indexOf('.');
|
if (dotIndex < 2) {
|
return 0;
|
}
|
|
// 提取度部分和分部分
|
int degrees = Integer.parseInt(dmCoord.substring(0, dotIndex - 2));
|
double minutes = Double.parseDouble(dmCoord.substring(dotIndex - 2));
|
|
// 转换为十进制度
|
double decimal = degrees + minutes / 60.0;
|
|
// 根据方向调整正负
|
if ("S".equals(direction) || "W".equals(direction)) {
|
decimal = -decimal;
|
}
|
|
return decimal;
|
|
} catch (Exception e) {
|
throw new IllegalArgumentException("度分坐标解析错误: " + dmCoord, e);
|
}
|
}
|
|
/**
|
* 将Coordinate列表转换为局部坐标系坐标
|
*/
|
private static List<BoundaryAlgorithm.Coordinate> convertToLocalCoordinates(
|
List<Coordinate> coordinates, double baseLat, double baseLon) {
|
|
List<BoundaryAlgorithm.Coordinate> localCoords = new ArrayList<>();
|
|
for (Coordinate coord : coordinates) {
|
try {
|
// 解析度分格式坐标为十进制度
|
double lat = parseDMToDecimal(coord.getLatitude(), coord.getLatDirection());
|
double lon = parseDMToDecimal(coord.getLongitude(), coord.getLonDirection());
|
|
// 转换为局部坐标系
|
BoundaryAlgorithm.Coordinate localCoord =
|
convertToLocalCoordinate(lat, lon, baseLat, baseLon);
|
|
localCoords.add(localCoord);
|
|
} catch (Exception e) {
|
System.err.println("坐标转换失败: " + coord + ", 错误: " + e.getMessage());
|
}
|
}
|
|
return localCoords;
|
}
|
|
/**
|
* 将经纬度坐标转换为局部坐标系
|
*/
|
private static BoundaryAlgorithm.Coordinate convertToLocalCoordinate(
|
double lat, double lon, double baseLat, double baseLon) {
|
|
double earthRadius = 6371000; // 地球半径（米）
|
|
// 计算北方向距离
|
double deltaLat = lat - baseLat;
|
double northDistance = deltaLat * Math.PI / 180.0 * earthRadius;
|
|
// 计算东方向距离（考虑纬度对经度距离的影响）
|
double deltaLon = lon - baseLon;
|
double eastDistance = deltaLon * Math.PI / 180.0 * earthRadius * Math.cos(baseLat * Math.PI / 180.0);
|
|
return new BoundaryAlgorithm.Coordinate(eastDistance, northDistance, lat, lon);
|
}
|
|
/**
|
* 将边界点列表转换为字符串格式
|
*/
|
private static String convertBoundaryPointsToString(List<BoundaryAlgorithm.Coordinate> points) {
|
if (points == null || points.isEmpty()) {
|
return "";
|
}
|
|
StringBuilder coordinatesBuilder = new StringBuilder();
|
for (int i = 0; i < points.size(); i++) {
|
BoundaryAlgorithm.Coordinate point = points.get(i);
|
coordinatesBuilder.append(String.format("%.2f,%.2f", point.x, point.y));
|
if (i < points.size() - 1) {
|
coordinatesBuilder.append(";");
|
}
|
}
|
|
return coordinatesBuilder.toString();
|
}
|
|
// // ============ 测试方法 ============
|
//
|
// /**
|
// * 测试方法
|
// */
|
// public static void main(String[] args) {
|
// try {
|
// // 创建测试Coordinate列表（包含高程数据）
|
// int count = Coordinate.loadFromGNGGAFile();
|
// List<Coordinate> coordinateList=Coordinate.coordinates;
|
//
|
// // 设置基准站坐标
|
// String baseStation = "3949.91202005,N,11616.85440851,E";
|
//
|
// // 调用自动处理方法
|
// String result = bianjieguihua2.processCoordinateListAuto(coordinateList, baseStation);
|
//
|
// System.out.println("自动处理的边界点坐标结果: " + result);
|
//
|
// } catch (Exception e) {
|
// System.err.println("处理失败: " + e.getMessage());
|
// e.printStackTrace();
|
// }
|
// }
|
}
|
