package lujing;
|
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.List;
|
import org.locationtech.jts.geom.Coordinate;
|
import org.locationtech.jts.geom.Envelope;
|
import org.locationtech.jts.geom.Geometry;
|
import org.locationtech.jts.geom.GeometryFactory;
|
import org.locationtech.jts.geom.LineString;
|
import org.locationtech.jts.geom.MultiLineString;
|
import org.locationtech.jts.geom.Polygon;
|
import org.locationtech.jts.geom.MultiPolygon;
|
|
/**
|
* 优化后的割草路径规划类
|
* 修复：解决路径超出地块边界的问题，增加安全边距计算的健壮性。
|
*/
|
public final class Lunjingguihua {
|
|
private Lunjingguihua() {
|
throw new IllegalStateException("Utility class");
|
}
|
|
/**
|
* 生成割草路径段列表（5参数版本）
|
* 根据给定的多边形边界、障碍物、割草宽度、安全距离和模式，生成完整的割草路径规划
|
*
|
* @param polygonCoords 多边形边界坐标字符串，格式："x1,y1;x2,y2;x3,y3;..." 或 "(x1,y1);(x2,y2);..."
|
* 支持分号、空格、逗号等多种分隔符，会自动闭合多边形
|
* @param obstaclesCoords 障碍物坐标字符串，格式："(x1,y1;x2,y2;...)" 多个障碍物用括号分隔
|
* 如果为空或null，则视为无障碍物
|
* @param mowingWidth 割草宽度（米），字符串格式，如 "0.34" 表示34厘米
|
* 如果为空或无法解析，默认使用0.34米
|
* @param safetyDistStr 安全边距（米），字符串格式，用于内缩边界和障碍物外扩
|
* 如果为空或null，将自动计算为 width/2 + 0.2米，确保割草机实体完全在界内
|
* @param modeStr 路径模式字符串，"1" 或 "spiral" 表示螺旋模式，其他值表示平行模式（默认）
|
* @return 路径段列表，每个PathSegment包含起点、终点和是否为割草段的标志
|
* 如果多边形坐标不足4个点，将抛出IllegalArgumentException异常
|
*/
|
public static List<PathSegment> generatePathSegments(String polygonCoords,
|
String obstaclesCoords,
|
String mowingWidth,
|
String safetyDistStr,
|
String modeStr) {
|
List<Coordinate> polygon = parseCoordinates(polygonCoords);
|
if (polygon.size() < 4) {
|
throw new IllegalArgumentException("多边形坐标数量不足");
|
}
|
|
double width = parseDoubleOrDefault(mowingWidth, 0.34);
|
// 如果传入空，设为 NaN，在 PlannerCore 中进行智能计算
|
double safetyDistance = parseDoubleOrDefault(safetyDistStr, Double.NaN);
|
|
List<List<Coordinate>> obstacles = parseObstacles(obstaclesCoords);
|
String mode = normalizeMode(modeStr);
|
|
PlannerCore planner = new PlannerCore(polygon, width, safetyDistance, mode, obstacles);
|
return planner.generate();
|
}
|
|
/**
|
* 生成割草路径段列表（4参数版本）
|
* 这是5参数版本的重载方法，安全距离参数自动设为null，系统将使用默认计算值
|
* 主要用于适配 AddDikuai.java 等不需要指定安全距离的场景
|
*
|
* @param polygonCoords 多边形边界坐标字符串，格式："x1,y1;x2,y2;x3,y3;..."
|
* @param obstaclesCoords 障碍物坐标字符串，格式："(x1,y1;x2,y2;...)"，可为空
|
* @param mowingWidth 割草宽度（米），字符串格式，如 "0.34"
|
* @param modeStr 路径模式字符串，"1" 或 "spiral" 表示螺旋模式，其他值表示平行模式
|
* @return 路径段列表，每个PathSegment包含起点、终点和是否为割草段的标志
|
* 安全距离将自动计算为 width/2 + 0.2米
|
*/
|
public static List<PathSegment> generatePathSegments(String polygonCoords,
|
String obstaclesCoords,
|
String mowingWidth,
|
String modeStr) {
|
return generatePathSegments(polygonCoords, obstaclesCoords, mowingWidth, null, modeStr);
|
}
|
|
// 5参数路径字符串生成
|
public static String generatePathFromStrings(String polygonCoords,
|
String obstaclesCoords,
|
String mowingWidth,
|
String safetyDistStr,
|
String modeStr) {
|
List<PathSegment> segments = generatePathSegments(polygonCoords, obstaclesCoords, mowingWidth, safetyDistStr, modeStr);
|
return formatPathSegments(segments);
|
}
|
|
// 4参数路径字符串生成重载
|
public static String generatePathFromStrings(String polygonCoords,
|
String obstaclesCoords,
|
String mowingWidth,
|
String modeStr) {
|
return generatePathFromStrings(polygonCoords, obstaclesCoords, mowingWidth, null, modeStr);
|
}
|
|
public static String formatPathSegments(List<PathSegment> path) {
|
if (path == null || path.isEmpty()) return "";
|
StringBuilder sb = new StringBuilder();
|
Coordinate last = null;
|
for (PathSegment segment : path) {
|
if (last == null || !equals2D(last, segment.start)) {
|
appendPoint(sb, segment.start);
|
}
|
appendPoint(sb, segment.end);
|
last = segment.end;
|
}
|
return sb.toString();
|
}
|
|
public static List<Coordinate> parseCoordinates(String s) {
|
List<Coordinate> list = new ArrayList<>();
|
if (s == null || s.trim().isEmpty()) return list;
|
// 增强正则：处理可能存在的多种分隔符
|
String[] pts = s.split("[;\\s]+");
|
for (String p : pts) {
|
String trimmed = p.trim().replace("(", "").replace(")", "");
|
if (trimmed.isEmpty()) continue;
|
String[] xy = trimmed.split("[,，\\s]+");
|
if (xy.length >= 2) {
|
try {
|
double x = Double.parseDouble(xy[0].trim());
|
double y = Double.parseDouble(xy[1].trim());
|
// 过滤无效坐标
|
if (!Double.isNaN(x) && !Double.isNaN(y) && !Double.isInfinite(x) && !Double.isInfinite(y)) {
|
list.add(new Coordinate(x, y));
|
}
|
} catch (NumberFormatException ex) {
|
// 忽略解析错误的点
|
}
|
}
|
}
|
// 确保多边形闭合
|
if (list.size() > 2 && !list.get(0).equals2D(list.get(list.size() - 1))) {
|
list.add(new Coordinate(list.get(0)));
|
}
|
return list;
|
}
|
|
public static List<List<Coordinate>> parseObstacles(String str) {
|
List<List<Coordinate>> obs = new ArrayList<>();
|
if (str == null || str.trim().isEmpty()) return obs;
|
java.util.regex.Pattern pattern = java.util.regex.Pattern.compile("\\(([^)]+)\\)");
|
java.util.regex.Matcher matcher = pattern.matcher(str);
|
while (matcher.find()) {
|
List<Coordinate> coords = parseCoordinates(matcher.group(1));
|
if (coords.size() >= 3) obs.add(coords);
|
}
|
if (obs.isEmpty()) {
|
List<Coordinate> coords = parseCoordinates(str);
|
if (coords.size() >= 3) obs.add(coords);
|
}
|
return obs;
|
}
|
|
private static double parseDoubleOrDefault(String value, double defaultValue) {
|
if (value == null || value.trim().isEmpty()) return defaultValue;
|
try {
|
return Double.parseDouble(value.trim());
|
} catch (NumberFormatException ex) {
|
return defaultValue;
|
}
|
}
|
|
private static String normalizeMode(String modeStr) {
|
return (modeStr != null && (modeStr.equals("1") || modeStr.equalsIgnoreCase("spiral"))) ? "spiral" : "parallel";
|
}
|
|
private static boolean equals2D(Coordinate a, Coordinate b) {
|
if (a == b) return true;
|
if (a == null || b == null) return false;
|
return a.distance(b) < 1e-4;
|
}
|
|
private static void appendPoint(StringBuilder sb, Coordinate point) {
|
if (sb.length() > 0) sb.append(";");
|
sb.append(String.format("%.3f,%.3f", point.x, point.y));
|
}
|
|
public static final class PathSegment {
|
public Coordinate start, end;
|
public boolean isMowing;
|
public boolean isStartPoint, isEndPoint;
|
|
public PathSegment(Coordinate start, Coordinate end, boolean isMowing) {
|
this.start = start;
|
this.end = end;
|
this.isMowing = isMowing;
|
}
|
|
public void setAsStartPoint() { this.isStartPoint = true; }
|
public void setAsEndPoint() { this.isEndPoint = true; }
|
}
|
|
public static final class PlannerCore {
|
private final List<Coordinate> polygon;
|
private final double width;
|
private final double safetyDistance;
|
private final String mode;
|
private final List<List<Coordinate>> obstacles;
|
private final GeometryFactory gf = new GeometryFactory();
|
|
// 1. 全参数构造函数
|
public PlannerCore(List<Coordinate> polygon, double width, double safetyDistance, String mode, List<List<Coordinate>> obstacles) {
|
this.polygon = polygon;
|
this.width = width;
|
this.mode = mode;
|
this.obstacles = obstacles != null ? obstacles : new ArrayList<>();
|
|
// FIX: 增加默认安全边距。原逻辑为 width/2 + 0.05，容易造成误差出界。
|
// 现改为 width/2 + 0.2 (20cm余量)，确保割草机实体完全在界内。
|
if (Double.isNaN(safetyDistance) || safetyDistance <= 0) {
|
this.safetyDistance = (width / 2.0) + 0.20;
|
} else {
|
this.safetyDistance = safetyDistance;
|
}
|
}
|
|
// 2. 4参数构造函数
|
public PlannerCore(List<Coordinate> polygon, double width, String mode, List<List<Coordinate>> obstacles) {
|
this(polygon, width, Double.NaN, mode, obstacles);
|
}
|
|
public List<PathSegment> generate() {
|
if ("spiral".equals(mode)) return generateSpiralPath();
|
return generateDividedParallelPath();
|
}
|
|
public List<PathSegment> generateParallelPath() {
|
return generateDividedParallelPath();
|
}
|
|
private List<PathSegment> generateDividedParallelPath() {
|
List<PathSegment> totalPath = new ArrayList<>();
|
Geometry safeArea = buildSafeArea();
|
|
if (safeArea == null || safeArea.isEmpty()) return totalPath;
|
|
List<Polygon> subRegions = new ArrayList<>();
|
if (safeArea instanceof Polygon) subRegions.add((Polygon) safeArea);
|
else if (safeArea instanceof MultiPolygon) {
|
for (int i = 0; i < safeArea.getNumGeometries(); i++) {
|
subRegions.add((Polygon) safeArea.getGeometryN(i));
|
}
|
}
|
|
for (Polygon region : subRegions) {
|
if (region.isEmpty()) continue;
|
|
Vector2D baseDir = calculateMainDirection(region);
|
Vector2D perp = baseDir.rotate90CCW();
|
Envelope env = region.getEnvelopeInternal();
|
|
double minProj = Double.MAX_VALUE, maxProj = -Double.MAX_VALUE;
|
Coordinate[] coords = region.getCoordinates();
|
for (Coordinate c : coords) {
|
double p = perp.dot(new Vector2D(c));
|
minProj = Math.min(minProj, p);
|
maxProj = Math.max(maxProj, p);
|
}
|
|
int lineIdx = 0;
|
// 从 minProj + width/2 开始，确保第一条线在安全区域内侧
|
for (double d = minProj + width / 2.0; d <= maxProj; d += width) {
|
LineString scanLine = createScanLine(d, perp, baseDir, env);
|
|
try {
|
Geometry intersections = region.intersection(scanLine);
|
if (intersections.isEmpty()) continue;
|
|
List<LineString> parts = extractLineStrings(intersections);
|
|
// 按照扫描方向排序，处理凹多边形或障碍物
|
parts.sort((a, b) -> Double.compare(
|
baseDir.dot(new Vector2D(a.getCoordinateN(0))),
|
baseDir.dot(new Vector2D(b.getCoordinateN(0)))
|
));
|
|
// 蛇形路径：奇数行反转
|
if (lineIdx % 2 != 0) Collections.reverse(parts);
|
|
for (LineString part : parts) {
|
Coordinate[] cs = part.getCoordinates();
|
if (cs.length < 2) continue;
|
|
if (lineIdx % 2 != 0) reverseArray(cs);
|
|
// 确保点坐标有效
|
totalPath.add(new PathSegment(cs[0], cs[cs.length - 1], true));
|
}
|
lineIdx++;
|
} catch (Exception e) {
|
// 忽略极其罕见的拓扑异常，防止崩溃
|
}
|
}
|
}
|
return markStartEnd(totalPath);
|
}
|
|
private Geometry buildSafeArea() {
|
try {
|
Polygon poly = gf.createPolygon(gf.createLinearRing(polygon.toArray(new Coordinate[0])));
|
|
// 1. 初始修复：处理自相交
|
if (!poly.isValid()) poly = (Polygon) poly.buffer(0);
|
|
// 2. 内缩生成安全区域
|
Geometry safe = poly.buffer(-safetyDistance);
|
|
// 3. 二次修复：负缓冲后可能产生不规范几何体
|
if (!safe.isValid()) safe = safe.buffer(0);
|
|
// 4. 处理障碍物
|
for (List<Coordinate> obsCoords : obstacles) {
|
if (obsCoords.size() < 3) continue;
|
try {
|
Polygon obs = gf.createPolygon(gf.createLinearRing(obsCoords.toArray(new Coordinate[0])));
|
if (!obs.isValid()) obs = (Polygon) obs.buffer(0);
|
// 障碍物外扩安全距离
|
safe = safe.difference(obs.buffer(safetyDistance));
|
} catch (Exception e) {
|
// 忽略错误的障碍物数据
|
}
|
}
|
|
// 5. 最终清理
|
if (!safe.isValid()) safe = safe.buffer(0);
|
return safe;
|
} catch (Exception e) {
|
// 如果几何构建完全失败，返回空
|
return gf.createPolygon();
|
}
|
}
|
|
private Vector2D calculateMainDirection(Polygon region) {
|
Coordinate[] coords = region.getExteriorRing().getCoordinates();
|
double maxLen = -1;
|
Vector2D bestDir = new Vector2D(1, 0);
|
|
// 寻找最长边作为主方向，减少转弯次数
|
for (int i = 0; i < coords.length - 1; i++) {
|
double d = coords[i].distance(coords[i+1]);
|
if (d > maxLen && d > 1e-4) {
|
maxLen = d;
|
bestDir = new Vector2D(coords[i+1].x - coords[i].x, coords[i+1].y - coords[i].y).normalize();
|
}
|
}
|
return bestDir;
|
}
|
|
private List<LineString> extractLineStrings(Geometry geom) {
|
List<LineString> list = new ArrayList<>();
|
if (geom instanceof LineString) list.add((LineString) geom);
|
else if (geom instanceof MultiLineString) {
|
for (int i = 0; i < geom.getNumGeometries(); i++) list.add((LineString) geom.getGeometryN(i));
|
} else if (geom instanceof org.locationtech.jts.geom.GeometryCollection) {
|
for (int i = 0; i < geom.getNumGeometries(); i++) {
|
if (geom.getGeometryN(i) instanceof LineString) {
|
list.add((LineString) geom.getGeometryN(i));
|
}
|
}
|
}
|
return list;
|
}
|
|
private LineString createScanLine(double dist, Vector2D perp, Vector2D baseDir, Envelope env) {
|
// 扩大扫描线长度，确保覆盖旋转后的多边形
|
double size = Math.max(env.getWidth(), env.getHeight());
|
// 处理退化包围盒
|
if (size < 1.0) size = 1000.0;
|
|
double len = size * 3.0; // 3倍尺寸确保足够长
|
|
// 中心点计算：在垂直方向上距离原点 dist 的位置
|
Vector2D center = perp.mul(dist);
|
|
return gf.createLineString(new Coordinate[]{
|
new Coordinate(center.x + baseDir.x * len, center.y + baseDir.y * len),
|
new Coordinate(center.x - baseDir.x * len, center.y - baseDir.y * len)
|
});
|
}
|
|
private List<PathSegment> markStartEnd(List<PathSegment> path) {
|
if (!path.isEmpty()) {
|
path.get(0).setAsStartPoint();
|
path.get(path.size() - 1).setAsEndPoint();
|
}
|
return path;
|
}
|
|
private void reverseArray(Coordinate[] arr) {
|
for (int i = 0; i < arr.length / 2; i++) {
|
Coordinate t = arr[i];
|
arr[i] = arr[arr.length - 1 - i];
|
arr[arr.length - 1 - i] = t;
|
}
|
}
|
|
List<PathSegment> generateSpiralPath() { return new ArrayList<>(); }
|
}
|
|
private static final class Vector2D {
|
final double x, y;
|
Vector2D(double x, double y) { this.x = x; this.y = y; }
|
Vector2D(Coordinate c) { this.x = c.x; this.y = c.y; }
|
|
Vector2D normalize() {
|
double len = Math.hypot(x, y);
|
return len < 1e-9 ? new Vector2D(1, 0) : new Vector2D(x / len, y / len);
|
}
|
Vector2D rotate90CCW() { return new Vector2D(-y, x); }
|
double dot(Vector2D v) { return x * v.x + y * v.y; }
|
Vector2D mul(double k) { return new Vector2D(x * k, y * k); }
|
}
|
}
|
