新增了导航预览功能

张世豪

4 天以前 dc9dce0555beb85d1262893fd5d56747d6a83855

 src/zhuye/MapRenderer.java

@@ -18,6 +18,7 @@
import java.util.List;
import java.util.Locale;
import java.util.Set;
import java.io.File;
import set.Setsys;
import gecaoji.Device;
import gecaoji.Gecaoji;
@@ -52,6 +53,7 @@
    private static final Color GRASS_FILL_COLOR = new Color(144, 238, 144, 120);
    private static final Color GRASS_BORDER_COLOR = new Color(60, 179, 113);
    private static final Color BOUNDARY_POINT_COLOR = new Color(128, 0, 128);
    private static final Color OBSTACLE_POINT_COLOR = new Color(255, 140, 0); // 橙色，用于区分障碍物点
    private static final Color CIRCLE_SAMPLE_COLOR = new Color(220, 20, 60, 230);
    private static final double CIRCLE_SAMPLE_SIZE = 0.54d;
    private static final double BOUNDARY_POINT_MERGE_THRESHOLD = 0.05;
@@ -71,6 +73,8 @@
    private String currentObstacleLandNumber;
    private String boundaryName;
    private boolean boundaryPointsVisible;
    private boolean obstaclePointsVisible;
    private boolean boundaryLengthVisible = false;  // 是否显示边界距离，默认关闭
    private double boundaryPointSizeScale = 1.0d;
    private boolean previewSizingEnabled;
    private String currentBoundaryLandNumber;
@@ -81,6 +85,7 @@
    private CircleCaptureOverlay circleCaptureOverlay;
    private final List<double[]> circleSampleMarkers = new ArrayList<>();
    private final List<Point2D.Double> realtimeMowingTrack = new ArrayList<>();
    private final List<Point2D.Double> navigationPreviewTrack = new ArrayList<>(); // 导航预览轨迹
    private final Deque<tuowei.TrailSample> idleMowerTrail = new ArrayDeque<>();
    private final List<Point2D.Double> handheldBoundaryPreview = new ArrayList<>();
    private double boundaryPreviewMarkerScale = 1.0d;
@@ -94,6 +99,7 @@
    private double mowingCompletionRatio;
    private long lastTrackPersistTimeMillis;
    private boolean trackDirty;
    private boolean measurementModeActive = false;  // 测量模式是否激活
    private boolean handheldBoundaryPreviewActive;
    private boolean pendingTrackBreak = true;
    private boolean idleTrailSuppressed;
@@ -210,9 +216,18 @@
                if (!SwingUtilities.isLeftMouseButton(e) || e.getClickCount() != 1) {
                    return;
                }
                // 优先处理测量模式点击
                if (measurementModeActive && handleMeasurementClick(e.getPoint())) {
                    return;
                }
                if (handleMowerClick(e.getPoint())) {
                    return;
                }
                // 优先处理障碍物边界点点击（如果可见）
                if (obstaclePointsVisible && handleObstaclePointClick(e.getPoint())) {
                    return;
                }
                // 然后处理地块边界点点击
                if (boundaryPointsVisible) {
                    handleBoundaryPointClick(e.getPoint());
                }
@@ -346,14 +361,11 @@
        boolean hasPlannedPath = currentPlannedPath != null && currentPlannedPath.size() >= 2;
        boolean hasObstacles = currentObstacles != null && !currentObstacles.isEmpty();

        // 绘制地块边界（底层）
        if (hasBoundary) {
            drawCurrentBoundary(g2d);
        }

        if (hasObstacles) {
            Obstacledraw.drawObstacles(g2d, currentObstacles, scale, selectedObstacleName);
        }

        yulanzhangaiwu.renderPreview(g2d, scale);

        if (!circleSampleMarkers.isEmpty()) {
@@ -366,20 +378,37 @@

    adddikuaiyulan.drawPreview(g2d, handheldBoundaryPreview, scale, handheldBoundaryPreviewActive, boundaryPreviewMarkerScale);

        // 绘制导航路径（中层）
        if (hasPlannedPath) {
            drawCurrentPlannedPath(g2d);
        }

        if (boundaryPointsVisible && hasBoundary) {
            double markerScale = boundaryPointSizeScale * (previewSizingEnabled ? PREVIEW_BOUNDARY_MARKER_SCALE : 1.0d);
            pointandnumber.drawBoundaryPoints(
                g2d,
                currentBoundary,
                scale,
                BOUNDARY_POINT_MERGE_THRESHOLD,
                BOUNDARY_POINT_COLOR,
                markerScale
            );
        // 绘制障碍物（顶层，显示在地块和导航路径上方）
        if (hasObstacles) {
            Obstacledraw.drawObstacles(g2d, currentObstacles, scale, selectedObstacleName);
        }

        // 显示边界点（如果边界点可见，或者边界距离可见）
        if ((boundaryPointsVisible || boundaryLengthVisible) && hasBoundary) {
            // 预览模式下显示序号
            if (previewSizingEnabled) {
                drawBoundaryPointsWithNumbers(g2d, currentBoundary, scale);
            } else {
                double markerScale = boundaryPointSizeScale;
                pointandnumber.drawBoundaryPoints(
                    g2d,
                    currentBoundary,
                    scale,
                    BOUNDARY_POINT_MERGE_THRESHOLD,
                    BOUNDARY_POINT_COLOR,
                    markerScale
                );
            }
        }
        
        // 绘制障碍物坐标点（带序号）
        if (obstaclePointsVisible && hasObstacles) {
            drawObstaclePointsWithNumbers(g2d, currentObstacles, scale);
        }

        if (shouldRenderIdleTrail()) {
@@ -389,12 +418,36 @@
        if (!realtimeMowingTrack.isEmpty()) {
            drawRealtimeMowingCoverage(g2d);
        }
        
        // 绘制导航预览已割区域
        if (!navigationPreviewTrack.isEmpty()) {
            drawNavigationPreviewCoverage(g2d);
        }

        drawMower(g2d);
        
        // 绘制导航预览速度（如果正在导航预览）
        if (navigationPreviewSpeed > 0 && mower != null && mower.hasValidPosition()) {
            drawNavigationPreviewSpeed(g2d, scale);
        }
        
        // 绘制测量模式（如果激活）
        if (measurementModeActive) {
            drawMeasurementMode(g2d, scale);
        }
        
        // 保存当前变换（包含视图变换）用于坐标转换
        AffineTransform currentTransformForLength = g2d.getTransform();
        
        // 恢复原始变换
        g2d.setTransform(originalTransform);
        
        // 绘制边界长度（如果启用）- 在恢复原始变换后绘制
        if (boundaryLengthVisible && hasBoundary) {
            bianjie.BoundaryLengthDrawer.drawBoundaryLengths(g2d, currentBoundary, scale, 
                visualizationPanel.getWidth(), visualizationPanel.getHeight(), translateX, translateY);
        }
        
        // 绘制视图信息
        drawViewInfo(g2d);
    }
@@ -416,6 +469,60 @@
    private void drawMower(Graphics2D g2d) {
        mower.draw(g2d, scale);
    }
    
    /**
     * 绘制导航预览速度（在割草机图标上方）
     */
    private void drawNavigationPreviewSpeed(Graphics2D g2d, double scale) {
        if (mower == null || !mower.hasValidPosition()) {
            return;
        }
        
        Point2D.Double mowerPos = mower.getPosition();
        if (mowerPos == null) {
            return;
        }
        
        // 将速度从米/秒转换为KM/h
        double speedKmh = navigationPreviewSpeed * 3.6;
        String speedText = String.format("%.1f km/h", speedKmh);
        
        // 保存原始变换
        AffineTransform originalTransform = g2d.getTransform();
        
        // 将世界坐标转换为屏幕坐标
        Point2D.Double screenPos = worldToScreen(mowerPos);
        
        // 恢复原始变换以绘制文字（固定大小，不随缩放变化）
        g2d.setTransform(new AffineTransform());
        
        // 设置字体（与缩放文字大小一致，11号字体）
        Font labelFont = new Font("微软雅黑", Font.PLAIN, 11);
        g2d.setFont(labelFont);
        FontMetrics metrics = g2d.getFontMetrics(labelFont);
        
        // 计算文字位置（在割草机图标上方）
        int textWidth = metrics.stringWidth(speedText);
        int textHeight = metrics.getHeight();
        int textX = (int)Math.round(screenPos.x - textWidth / 2.0);
        // 在割草机图标上方，留出一定间距
        // 图标在世界坐标系中的大小约为 48 * 0.8 / scale 米
        // 转换为屏幕像素：图标高度（像素）= (48 * 0.8 / scale) * scale = 48 * 0.8 = 38.4 像素
        double iconSizePixels = 48.0 * 0.8; // 图标在屏幕上的大小（像素）
        int spacing = 8; // 间距（像素）
        int textY = (int)Math.round(screenPos.y - iconSizePixels / 2.0 - spacing - textHeight);
        
        // 绘制文字背景（半透明白色，增强可读性）
        g2d.setColor(new Color(255, 255, 255, 200));
        g2d.fillRoundRect(textX - 4, textY - metrics.getAscent() - 2, textWidth + 8, textHeight + 4, 4, 4);
        
        // 绘制文字
        g2d.setColor(new Color(46, 139, 87)); // 使用主题绿色
        g2d.drawString(speedText, textX, textY);
        
        // 恢复变换
        g2d.setTransform(originalTransform);
    }

    private void drawRealtimeMowingCoverage(Graphics2D g2d) {
        if (realtimeMowingTrack == null || realtimeMowingTrack.size() < 2) {
@@ -426,6 +533,91 @@
        double effectiveWidth = getEffectiveMowerWidthMeters();
        gecaolunjing.draw(g2d, realtimeMowingTrack, effectiveWidth, boundaryPath);
    }
    
    /**
     * 绘制导航预览已割区域
     */
    private void drawNavigationPreviewCoverage(Graphics2D g2d) {
        if (navigationPreviewTrack == null || navigationPreviewTrack.size() < 2) {
            return;
        }
        
        Path2D.Double boundaryPath = currentBoundaryPath;
        // 获取导航预览的割草宽度（从daohangyulan获取）
        double previewWidth = getNavigationPreviewWidth();
        if (previewWidth <= 0) {
            previewWidth = 0.5; // 默认50厘米
        }
        gecaolunjing.draw(g2d, navigationPreviewTrack, previewWidth, boundaryPath);
    }
    
    /**
     * 设置导航预览轨迹
     */
    public void setNavigationPreviewTrack(List<Point2D.Double> track) {
        if (track == null) {
            navigationPreviewTrack.clear();
        } else {
            navigationPreviewTrack.clear();
            navigationPreviewTrack.addAll(track);
        }
        if (visualizationPanel != null) {
            visualizationPanel.repaint();
        }
    }
    
    /**
     * 添加导航预览轨迹点
     */
    public void addNavigationPreviewTrackPoint(Point2D.Double point) {
        if (point != null && Double.isFinite(point.x) && Double.isFinite(point.y)) {
            navigationPreviewTrack.add(new Point2D.Double(point.x, point.y));
            if (visualizationPanel != null) {
                visualizationPanel.repaint();
            }
        }
    }
    
    /**
     * 清除导航预览轨迹
     */
    public void clearNavigationPreviewTrack() {
        navigationPreviewTrack.clear();
        if (visualizationPanel != null) {
            visualizationPanel.repaint();
        }
    }
    
    private double navigationPreviewWidth = 0.5; // 导航预览的割草宽度（米）
    private double navigationPreviewSpeed = 0.0; // 导航预览的割草机速度（米/秒）
    
    /**
     * 设置导航预览的割草宽度
     */
    public void setNavigationPreviewWidth(double widthMeters) {
        navigationPreviewWidth = widthMeters > 0 ? widthMeters : 0.5;
    }
    
    /**
     * 获取导航预览的割草宽度
     */
    private double getNavigationPreviewWidth() {
        return navigationPreviewWidth;
    }
    
    /**
     * 设置导航预览的割草机速度（米/秒）
     */
    public void setNavigationPreviewSpeed(double speedMetersPerSecond) {
        navigationPreviewSpeed = speedMetersPerSecond >= 0 ? speedMetersPerSecond : 0.0;
    }
    
    /**
     * 获取导航预览的割草机速度（米/秒）
     */
    private double getNavigationPreviewSpeed() {
        return navigationPreviewSpeed;
    }

    private Path2D.Double getRealtimeBoundaryPath() {
        if (realtimeTrackLandNumber == null) {
@@ -1016,6 +1208,145 @@
        double worldY = (screenPoint.y - visualizationPanel.getHeight() / 2.0) / scale - translateY;
        return new Point2D.Double(worldX, worldY);
    }
    
    /**
     * 处理测量模式点击
     */
    private boolean handleMeasurementClick(Point screenPoint) {
        if (!measurementModeActive) {
            return false;
        }
        Point2D.Double worldPoint = screenToWorld(screenPoint);
        celiangmoshi.addPoint(worldPoint);
        visualizationPanel.repaint();
        return true;
    }
    
    /**
     * 设置测量模式
     */
    public void setMeasurementMode(boolean active) {
        measurementModeActive = active;
        if (!active) {
            celiangmoshi.clear();
        }
        if (visualizationPanel != null) {
            visualizationPanel.repaint();
        }
    }
    
    /**
     * 触发地图重绘
     */
    public void repaint() {
        if (visualizationPanel != null) {
            visualizationPanel.repaint();
        }
    }
    
    /**
     * 绘制测量模式
     */
    private void drawMeasurementMode(Graphics2D g2d, double scale) {
        List<Point2D.Double> points = celiangmoshi.getPoints();
        if (points.isEmpty()) {
            return;
        }
        
        // 保存原始变换
        AffineTransform originalTransform = g2d.getTransform();
        
        // 设置测量模式颜色
        Color lineColor = new Color(255, 0, 0, 200);  // 红色半透明
        Color pointColor = new Color(255, 0, 0, 255);  // 红色
        Color textColor = new Color(33, 37, 41, 220);  // 深灰色文字
        
        // 设置线宽和点的大小（确保点和线连接）
        float lineWidth = (float)(2.0 / scale);
        // 点的大小（在世界坐标系中，米），确保点足够大以覆盖线的端点
        double pointSizeInWorld = 0.15d;  // 点的大小（米）
        double halfSize = pointSizeInWorld / 2.0;
        
        // 先绘制所有测量点（作为基础层）
        g2d.setColor(pointColor);
        for (Point2D.Double point : points) {
            // 点的中心在 point.x, point.y
            Ellipse2D.Double pointShape = new Ellipse2D.Double(
                point.x - halfSize,
                point.y - halfSize,
                pointSizeInWorld,
                pointSizeInWorld
            );
            g2d.fill(pointShape);
        }
        
        // 然后绘制连线，确保线从点的中心开始和结束，点和线连接在一起
        g2d.setColor(lineColor);
        g2d.setStroke(new BasicStroke(lineWidth, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
        
        // 绘制连线和距离文字（显示两个相邻点连线的长度）
        for (int i = 0; i < points.size() - 1; i++) {
            Point2D.Double p1 = points.get(i);
            Point2D.Double p2 = points.get(i + 1);
            
            // 绘制连线（从第一个点的中心到第二个点的中心）
            // 使用 Path2D 确保精确绘制，保持浮点精度
            Path2D.Double linePath = new Path2D.Double();
            linePath.moveTo(p1.x, p1.y);
            linePath.lineTo(p2.x, p2.y);
            g2d.draw(linePath);
            
            // 计算距离（两个相邻点连线的长度）
            double distance = celiangmoshi.calculateDistance(p1, p2);
            String distanceText = celiangmoshi.formatDistance(distance);
            
            // 计算中点位置（用于显示文字）
            double midX = (p1.x + p2.x) / 2.0;
            double midY = (p1.y + p2.y) / 2.0;
            
            // 将世界坐标转换为屏幕坐标（用于文字显示）
            Point2D.Double worldMid = new Point2D.Double(midX, midY);
            Point2D.Double screenMid = worldToScreen(worldMid);
            
            // 恢复原始变换以绘制文字（固定大小，不随缩放变化）
            g2d.setTransform(new AffineTransform());
            
            // 设置字体（与缩放文字大小一致，11号字体）
            Font labelFont = new Font("微软雅黑", Font.PLAIN, 11);
            g2d.setFont(labelFont);
            FontMetrics metrics = g2d.getFontMetrics(labelFont);
            
            // 计算文字位置（居中显示）
            int textWidth = metrics.stringWidth(distanceText);
            int textHeight = metrics.getHeight();
            int textX = (int)Math.round(screenMid.x - textWidth / 2.0);
            int textY = (int)Math.round(screenMid.y - textHeight / 2.0) + metrics.getAscent();
            
            // 绘制文字背景（可选，用于提高可读性）
            g2d.setColor(new Color(255, 255, 255, 200));
            g2d.fillRoundRect(textX - 2, textY - metrics.getAscent() - 2, textWidth + 4, textHeight + 4, 4, 4);
            
            // 绘制文字
            g2d.setColor(textColor);
            g2d.drawString(distanceText, textX, textY);
            
            // 恢复变换
            g2d.setTransform(originalTransform);
        }
        
        // 最后再次绘制测量点（在连线之上，确保点覆盖在线的端点上，点和线连接在一起）
        g2d.setColor(pointColor);
        for (Point2D.Double point : points) {
            // 点的中心在 point.x, point.y，正好是线的端点位置
            Ellipse2D.Double pointShape = new Ellipse2D.Double(
                point.x - halfSize,
                point.y - halfSize,
                pointSizeInWorld,
                pointSizeInWorld
            );
            g2d.fill(pointShape);
        }
    }

    private void drawCurrentBoundary(Graphics2D g2d) {
        bianjiedrwa.drawBoundary(g2d, currentBoundary, scale, GRASS_FILL_COLOR, GRASS_BORDER_COLOR);
@@ -1030,33 +1361,53 @@
        if (markers == null || markers.isEmpty()) {
            return;
        }
        
        // 保存原始变换
        AffineTransform originalTransform = g2d.getTransform();
        
        Shape markerShape;
        double half = CIRCLE_SAMPLE_SIZE / 2.0;
        g2d.setColor(CIRCLE_SAMPLE_COLOR);
        g2d.setStroke(new BasicStroke((float) (1.2f / scale), BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
        Font originalFont = g2d.getFont();
        float baseSize = (float) Math.max(12f / scale, 9f);
        float reducedSize = Math.max(baseSize / 3f, 3f);
        Font labelFont = originalFont.deriveFont(reducedSize);
        
        // 设置字体（与缩放文字大小一致，11号字体，不随缩放变化）
        Font labelFont = new Font("微软雅黑", Font.PLAIN, 11);
        g2d.setFont(labelFont);
        FontMetrics metrics = g2d.getFontMetrics();
        FontMetrics metrics = g2d.getFontMetrics(labelFont);
        
        for (double[] pt : markers) {
            if (pt == null || pt.length < 2 || !Double.isFinite(pt[0]) || !Double.isFinite(pt[1])) {
                continue;
            }
            double x = pt[0];
            double y = pt[1];
            
            // 绘制点（在世界坐标系中，随缩放变化）
            markerShape = new Ellipse2D.Double(x - half, y - half, CIRCLE_SAMPLE_SIZE, CIRCLE_SAMPLE_SIZE);
            g2d.fill(markerShape);
            
            // 将世界坐标转换为屏幕坐标以绘制文字（不随缩放变化）
            Point2D.Double worldPoint = new Point2D.Double(x, y);
            Point2D.Double screenPoint = new Point2D.Double();
            originalTransform.transform(worldPoint, screenPoint);
            
            // 恢复原始变换以使用屏幕坐标绘制文字
            g2d.setTransform(new AffineTransform());
            
            String label = String.format(Locale.US, "%.2f,%.2f", x, y);
            int textWidth = metrics.stringWidth(label);
            float textX = (float) (x - textWidth / 2.0);
            float textY = (float) (y - half - 0.2d) - metrics.getDescent();
            int textHeight = metrics.getHeight();
            
            // 在屏幕坐标系中绘制文字（不随缩放变化）
            int textX = (int)(screenPoint.x - textWidth / 2.0);
            int textY = (int)(screenPoint.y - half - 0.2d) - metrics.getDescent();
            g2d.setColor(new Color(33, 37, 41, 220));
            g2d.drawString(label, textX, textY);
            
            // 恢复原始变换
            g2d.setTransform(originalTransform);
            g2d.setColor(CIRCLE_SAMPLE_COLOR);
        }
        g2d.setFont(originalFont);
    }

    private void drawCircleCaptureOverlay(Graphics2D g2d, CircleCaptureOverlay overlay, double scale) {
@@ -1163,6 +1514,139 @@
        }
    }

    /**
     * 处理障碍物边界点点击
     * @param screenPoint 屏幕坐标点
     * @return 如果处理了点击返回true，否则返回false
     */
    private boolean handleObstaclePointClick(Point screenPoint) {
        if (currentObstacles == null || currentObstacles.isEmpty() || currentObstacleLandNumber == null) {
            return false;
        }

        double threshold = computeSelectionThresholdPixels();
        
        // 遍历所有障碍物，找到被点击的点
        for (Obstacledge.Obstacle obstacle : currentObstacles) {
            if (obstacle == null) {
                continue;
            }
            
            List<Obstacledge.XYCoordinate> xyCoords = obstacle.getXyCoordinates();
            if (xyCoords == null || xyCoords.isEmpty()) {
                continue;
            }
            
            // 检查每个点
            for (int i = 0; i < xyCoords.size(); i++) {
                Obstacledge.XYCoordinate coord = xyCoords.get(i);
                Point2D.Double worldPoint = new Point2D.Double(coord.getX(), coord.getY());
                Point2D.Double screenPosition = worldToScreen(worldPoint);
                
                double dx = screenPosition.x - screenPoint.x;
                double dy = screenPosition.y - screenPoint.y;
                if (Math.hypot(dx, dy) <= threshold) {
                    // 找到被点击的点
                    String obstacleName = obstacle.getObstacleName();
                    String pointLabel = (i + 1) + "";
                    String message = "确定要删除障碍物 \"" + obstacleName + "\" 的第" + pointLabel + "号边界点吗？";
                    
                    int choice = JOptionPane.showConfirmDialog(
                        visualizationPanel,
                        message,
                        "删除障碍物边界点",
                        JOptionPane.OK_CANCEL_OPTION,
                        JOptionPane.WARNING_MESSAGE
                    );
                    
                    if (choice == JOptionPane.OK_OPTION) {
                        removeObstaclePoint(obstacle, i);
                    }
                    return true;
                }
            }
        }
        
        return false;
    }

    /**
     * 删除障碍物的指定边界点
     */
    private void removeObstaclePoint(Obstacledge.Obstacle obstacle, int pointIndex) {
        if (obstacle == null || currentObstacleLandNumber == null) {
            return;
        }
        
        List<Obstacledge.XYCoordinate> xyCoords = obstacle.getXyCoordinates();
        if (xyCoords == null || pointIndex < 0 || pointIndex >= xyCoords.size()) {
            return;
        }
        
        // 检查删除后是否还有足够的点
        Obstacledge.ObstacleShape shape = obstacle.getShape();
        int minPoints = (shape == Obstacledge.ObstacleShape.CIRCLE) ? 2 : 3;
        
        if (xyCoords.size() <= minPoints) {
            JOptionPane.showMessageDialog(
                visualizationPanel,
                "障碍物至少需要" + minPoints + "个点，无法删除",
                "提示",
                JOptionPane.INFORMATION_MESSAGE
            );
            return;
        }
        
        // 创建新的坐标列表（移除指定点）
        List<Obstacledge.XYCoordinate> updatedCoords = new ArrayList<>(xyCoords);
        updatedCoords.remove(pointIndex);
        
        // 更新障碍物坐标
        obstacle.setXyCoordinates(updatedCoords);
        
        // 保存到配置文件
        try {
            File configFile = new File("Obstacledge.properties");
            Obstacledge.ConfigManager manager = new Obstacledge.ConfigManager();
            if (configFile.exists()) {
                manager.loadFromFile(configFile.getAbsolutePath());
            }
            
            Obstacledge.Plot plot = manager.getPlotById(currentObstacleLandNumber.trim());
            if (plot != null) {
                // 移除旧障碍物并添加更新后的障碍物
                plot.removeObstacleByName(obstacle.getObstacleName());
                plot.addObstacle(obstacle);
                manager.saveToFile(configFile.getAbsolutePath());
                
                // 更新地块更新时间
                Dikuai.updateField(currentObstacleLandNumber.trim(), "updateTime", 
                    new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new java.util.Date()));
                Dikuai.saveToProperties();
                
                // 重新加载障碍物数据以刷新显示
                List<Obstacledge.Obstacle> updatedObstacles = new ArrayList<>();
                for (Obstacledge.Obstacle obs : currentObstacles) {
                    if (obs.getObstacleName().equals(obstacle.getObstacleName())) {
                        updatedObstacles.add(obstacle); // 使用更新后的障碍物
                    } else {
                        updatedObstacles.add(obs); // 保持其他障碍物不变
                    }
                }
                applyObstaclesToRenderer(updatedObstacles, currentObstacleLandNumber);
                visualizationPanel.repaint();
            }
        } catch (Exception ex) {
            ex.printStackTrace();
            JOptionPane.showMessageDialog(
                visualizationPanel,
                "保存失败: " + ex.getMessage(),
                "错误",
                JOptionPane.ERROR_MESSAGE
            );
        }
    }

    private void handleBoundaryPointClick(Point screenPoint) {
        if (currentBoundary == null || currentBoundaryLandNumber == null) {
            return;
@@ -1430,6 +1914,184 @@
    /**
     * 绘制视图信息
     */
    /**
     * 绘制障碍物坐标点（带序号）
     * 序号显示在点中心，字体大小与障碍物名称一致（11号），不随缩放变化
     */
    private void drawObstaclePointsWithNumbers(Graphics2D g2d, List<Obstacledge.Obstacle> obstacles, double scale) {
        if (obstacles == null || obstacles.isEmpty()) {
            return;
        }
        
        // 保存原始变换
        AffineTransform originalTransform = g2d.getTransform();
        
        // 设置点的大小（随缩放变化）
        double scaleFactor = Math.max(0.5, scale);
        double clampedScale = boundaryPointSizeScale * (previewSizingEnabled ? PREVIEW_BOUNDARY_MARKER_SCALE : 1.0d);
        if (!Double.isFinite(clampedScale) || clampedScale <= 0.0d) {
            clampedScale = 1.0d;
        }
        double minimumDiameter = clampedScale < 1.0 ? 0.5 : 1.0;
        double markerDiameter = Math.max(minimumDiameter, (10.0 / scaleFactor) * 0.2 * clampedScale);
        double markerRadius = markerDiameter / 2.0;
        
        // 设置字体（与障碍物名称一致，不随缩放变化）
        Font labelFont = new Font("微软雅黑", Font.PLAIN, 11);
        g2d.setFont(labelFont);
        FontMetrics fontMetrics = g2d.getFontMetrics(labelFont);
        
        // 遍历所有障碍物
        for (Obstacledge.Obstacle obstacle : obstacles) {
            if (obstacle == null || !obstacle.isValid()) {
                continue;
            }
            
            List<Obstacledge.XYCoordinate> xyCoords = obstacle.getXyCoordinates();
            if (xyCoords == null || xyCoords.isEmpty()) {
                continue;
            }
            
            // 绘制每个点及其序号
            for (int i = 0; i < xyCoords.size(); i++) {
                Obstacledge.XYCoordinate coord = xyCoords.get(i);
                double x = coord.getX();
                double y = coord.getY();
                
                // 绘制点（在世界坐标系中，随缩放变化）
                g2d.setColor(OBSTACLE_POINT_COLOR);
                Ellipse2D.Double marker = new Ellipse2D.Double(
                    x - markerRadius, 
                    y - markerRadius, 
                    markerDiameter, 
                    markerDiameter
                );
                g2d.fill(marker);
                
                // 将世界坐标转换为屏幕坐标以绘制序号（不随缩放变化）
                Point2D.Double worldPoint = new Point2D.Double(x, y);
                Point2D.Double screenPoint = new Point2D.Double();
                originalTransform.transform(worldPoint, screenPoint);
                
                // 保存当前变换
                AffineTransform savedTransform = g2d.getTransform();
                
                // 重置变换为屏幕坐标系统
                g2d.setTransform(new AffineTransform());
                
                // 绘制序号（在屏幕坐标系中，不随缩放变化）
                String numberText = String.valueOf(i + 1);
                int textWidth = fontMetrics.stringWidth(numberText);
                int textHeight = fontMetrics.getHeight();
                
                // 在点中心绘制序号
                int textX = (int)(screenPoint.x - textWidth / 2.0);
                int textY = (int)(screenPoint.y + textHeight / 4.0);
                
                // 绘制序号文字（无背景）
                g2d.setColor(Color.BLACK);
                g2d.drawString(numberText, textX, textY);
                
                // 恢复变换
                g2d.setTransform(savedTransform);
            }
        }
        
        // 恢复原始变换
        g2d.setTransform(originalTransform);
    }
    
    /**
     * 绘制边界点（带序号）
     * 序号显示在点中心，字体大小与障碍物序号一致（11号），不随缩放变化
     */
    private void drawBoundaryPointsWithNumbers(Graphics2D g2d, List<Point2D.Double> boundary, double scale) {
        if (boundary == null || boundary.size() < 2) {
            return;
        }
        
        // 保存原始变换
        AffineTransform originalTransform = g2d.getTransform();
        
        int totalPoints = boundary.size();
        boolean closed = totalPoints > 2 && areBoundaryPointsClose(boundary.get(0), boundary.get(totalPoints - 1));
        int effectiveCount = closed ? totalPoints - 1 : totalPoints;
        if (effectiveCount <= 0) {
            return;
        }
        
        // 设置点的大小（边界线宽度的2倍）
        // 边界线宽度：3 / Math.max(0.5, scale)
        double scaleFactor = Math.max(0.5, scale);
        double boundaryLineWidth = 3.0 / scaleFactor;  // 边界线宽度
        double markerDiameter = boundaryLineWidth * 2.0;  // 边界点直径 = 边界线宽度的2倍
        double markerRadius = markerDiameter / 2.0;
        
        // 设置字体（与障碍物序号一致，不随缩放变化）
        Font labelFont = new Font("微软雅黑", Font.PLAIN, 11);
        g2d.setFont(labelFont);
        FontMetrics fontMetrics = g2d.getFontMetrics(labelFont);
        
        // 绘制每个点及其序号
        for (int i = 0; i < effectiveCount; i++) {
            Point2D.Double point = boundary.get(i);
            double x = point.x;
            double y = point.y;
            
            // 绘制点（在世界坐标系中，随缩放变化）
            g2d.setColor(BOUNDARY_POINT_COLOR);
            Ellipse2D.Double marker = new Ellipse2D.Double(
                x - markerRadius, 
                y - markerRadius, 
                markerDiameter, 
                markerDiameter
            );
            g2d.fill(marker);
            
            // 将世界坐标转换为屏幕坐标以绘制序号（不随缩放变化）
            Point2D.Double worldPoint = new Point2D.Double(x, y);
            Point2D.Double screenPoint = new Point2D.Double();
            originalTransform.transform(worldPoint, screenPoint);
            
            // 保存当前变换
            AffineTransform savedTransform = g2d.getTransform();
            
            // 重置变换为屏幕坐标系统
            g2d.setTransform(new AffineTransform());
            
            // 绘制序号（在屏幕坐标系中，不随缩放变化）
            String numberText = String.valueOf(i + 1);
            int textWidth = fontMetrics.stringWidth(numberText);
            int textHeight = fontMetrics.getHeight();
            
            // 在点中心绘制序号
            int textX = (int)(screenPoint.x - textWidth / 2.0);
            int textY = (int)(screenPoint.y + textHeight / 4.0);
            
            // 绘制序号文字（无背景）
            g2d.setColor(Color.BLACK);
            g2d.drawString(numberText, textX, textY);
            
            // 恢复变换
            g2d.setTransform(savedTransform);
        }
        
        // 恢复原始变换
        g2d.setTransform(originalTransform);
    }
    
    /**
     * 检查两个边界点是否接近（用于判断边界是否闭合）
     */
    private boolean areBoundaryPointsClose(Point2D.Double a, Point2D.Double b) {
        if (a == null || b == null) {
            return false;
        }
        double dx = a.x - b.x;
        double dy = a.y - b.y;
        return Math.hypot(dx, dy) <= BOUNDARY_POINT_MERGE_THRESHOLD;
    }
    
    private void drawViewInfo(Graphics2D g2d) {
        g2d.setColor(new Color(80, 80, 80));
        g2d.setFont(new Font("微软雅黑", Font.PLAIN, 11));
@@ -1743,6 +2405,7 @@
        obstacleBounds = null;
        selectedObstacleName = null;
        currentObstacleLandNumber = null;
        obstaclePointsVisible = false;
    }

    private List<Obstacledge.Obstacle> parseObstacles(String obstaclesData, String landNumber) {
@@ -2030,6 +2693,28 @@
        visualizationPanel.repaint();
    }

    public void setObstaclePointsVisible(boolean visible) {
        this.obstaclePointsVisible = visible;
        visualizationPanel.repaint();
    }
    
    /**
     * 设置是否显示边界距离
     */
    public void setBoundaryLengthVisible(boolean visible) {
        boundaryLengthVisible = visible;
        if (visualizationPanel != null) {
            visualizationPanel.repaint();
        }
    }
    
    /**
     * 获取是否显示边界距离
     */
    public boolean isBoundaryLengthVisible() {
        return boundaryLengthVisible;
    }

    public void setBoundaryPointSizeScale(double sizeScale) {
        double normalized = (Double.isFinite(sizeScale) && sizeScale > 0.0d) ? sizeScale : 1.0d;
        if (Math.abs(boundaryPointSizeScale - normalized) < 1e-6) {