进一步优化边界管理页面功能

张世豪

9 小时以前 5b685e9066ccfbc432c29739b5524f1d42a20891

 src/zhuye/MapRenderer.java

@@ -107,6 +107,12 @@
    private boolean idleTrailSuppressed;
    private Path2D.Double realtimeBoundaryPathCache;
    private String realtimeBoundaryPathLand;
    private WangfanDraw returnPathDrawer;  // 往返路径绘制管理器
    private List<Point2D.Double> currentReturnPath; // 当前地块的往返路径（用于显示）
    private List<Point2D.Double> previewReturnPath; // 预览的往返路径
    private List<Point2D.Double> previewOriginalBoundary; // 预览的原始边界（紫色）
    private List<Point2D.Double> previewOptimizedBoundary; // 预览的优化后边界
    private boolean boundaryPreviewActive; // 是否处于边界预览模式

    private static final double TRACK_SAMPLE_MIN_DISTANCE_METERS = 0.2d;
    private static final double TRACK_DUPLICATE_TOLERANCE_METERS = 1e-3d;
@@ -241,6 +247,10 @@
                if (handleMowerClick(e.getPoint())) {
                    return;
                }
                // 优先处理优化后边界坐标点点击（边界预览模式下）
                if (boundaryPreviewActive && handleOptimizedBoundaryPointClick(e.getPoint())) {
                    return;
                }
                // 优先处理障碍物边界点点击（如果可见）
                if (obstaclePointsVisible && handleObstaclePointClick(e.getPoint())) {
                    return;
@@ -394,6 +404,11 @@
        if (hasBoundary) {
            drawCurrentBoundary(g2d);
        }
        
        // 绘制边界预览（原始边界-紫色，优化后边界）
        if (boundaryPreviewActive) {
            drawBoundaryPreview(g2d);
        }

        yulanzhangaiwu.renderPreview(g2d, scale);

@@ -413,8 +428,8 @@
        // 绘制鼠标实时位置（手动绘制边界模式时）
        manualBoundaryDrawer.drawMousePosition(g2d, scale);

        // 绘制导航路径（中层）
        if (hasPlannedPath) {
        // 绘制导航路径（中层）- 边界预览模式下不显示导航路径
        if (hasPlannedPath && !boundaryPreviewActive) {
            drawCurrentPlannedPath(g2d);
        }

@@ -459,6 +474,17 @@
            drawNavigationPreviewCoverage(g2d);
        }

        // 先画往返路径（线+点），保证割草机图标在其上方
        if (returnPathDrawer != null && returnPathDrawer.isActive()) {
            returnPathDrawer.draw(g2d, scale);
        } else if (previewReturnPath != null && !previewReturnPath.isEmpty()) {
            // 绘制预览的往返路径（铁线路图风格）
            WangfanDraw.drawRailwayPath(g2d, previewReturnPath, scale);
        } else if (currentReturnPath != null && !currentReturnPath.isEmpty()) {
            // 绘制保存的往返路径（铁线路图风格）
            WangfanDraw.drawRailwayPath(g2d, currentReturnPath, scale);
        }

        drawMower(g2d);
        
        // 绘制导航预览速度（如果正在导航预览）
@@ -962,6 +988,14 @@
            mowerEffectiveWidthMeters = defaultMowerWidthMeters;
        }

        // 加载往返路径
        String returnPathStr = dikuai != null ? dikuai.getReturnPathCoordinates() : null;
        if (returnPathStr != null && !returnPathStr.isEmpty() && !"-1".equals(returnPathStr)) {
            currentReturnPath = lujingdraw.parsePlannedPath(returnPathStr);
        } else {
            currentReturnPath = null;
        }

        loadRealtimeTrack(landNumber, dikuai != null ? dikuai.getMowingTrack() : null);
        visualizationPanel.repaint();
    }
@@ -2993,5 +3027,317 @@
    public Gecaoji getMower() {
        return mower;
    }
    
    /**
     * 设置往返路径绘制管理器
     */
    public void setReturnPathDrawer(WangfanDraw drawer) {
        this.returnPathDrawer = drawer;
    }

    /**
     * 设置预览的往返路径
     */
    public void setPreviewReturnPath(List<Point2D.Double> path) {
        this.previewReturnPath = path;
        if (visualizationPanel != null) {
            visualizationPanel.repaint();
        }
    }
    
    /**
     * 开始往返路径绘制
     */
    public void startReturnPathDrawing() {
        if (returnPathDrawer != null) {
            // 禁用拖尾效果（在往返路径绘制模式下不显示实时轨迹拖尾）
            idleTrailSuppressed = true;
            clearIdleMowerTrail();
            // 清空之前的路径点（通过 WangfanDraw 管理）
            repaint();
        }
    }
    
    /**
     * 停止往返路径绘制
     */
    public void stopReturnPathDrawing() {
        // 恢复拖尾效果
        idleTrailSuppressed = false;
        repaint();
    }
    
    /**
     * 设置拖尾抑制状态
     * @param suppressed true表示抑制拖尾绘制，false表示允许拖尾绘制
     */
    public void setIdleTrailSuppressed(boolean suppressed) {
        idleTrailSuppressed = suppressed;
        if (suppressed && !idleMowerTrail.isEmpty()) {
            clearIdleMowerTrail();
        }
        if (visualizationPanel != null) {
            visualizationPanel.repaint();
        }
    }
    
    /**
     * 添加往返路径点（已废弃，路径点由 WangfanDraw 直接管理）
     */
    @Deprecated
    public void addReturnPathPoint(double x, double y) {
        // 路径点由 WangfanDraw 直接管理，这里只需要重绘
        repaint();
    }
    
    /**
     * 获取往返路径点列表的快照
     */
    public List<Point2D.Double> getReturnPathPointsSnapshot() {
        if (returnPathDrawer != null) {
            return returnPathDrawer.getPointsSnapshot();
        }
        return new ArrayList<>();
    }
    
    /**
     * 设置边界预览数据（原始边界和优化后边界）
     */
    public void setBoundaryPreview(String originalBoundaryXY, String optimizedBoundary) {
        if (originalBoundaryXY != null && !originalBoundaryXY.trim().isEmpty() && !"-1".equals(originalBoundaryXY.trim())) {
            previewOriginalBoundary = parseBoundary(originalBoundaryXY.trim());
        } else {
            previewOriginalBoundary = null;
        }
        
        if (optimizedBoundary != null && !optimizedBoundary.trim().isEmpty() && !"-1".equals(optimizedBoundary.trim())) {
            previewOptimizedBoundary = parseBoundary(optimizedBoundary.trim());
        } else {
            previewOptimizedBoundary = null;
        }
        
        boundaryPreviewActive = (previewOriginalBoundary != null && previewOriginalBoundary.size() >= 2) ||
                               (previewOptimizedBoundary != null && previewOptimizedBoundary.size() >= 2);
        
        if (boundaryPreviewActive) {
            // 计算预览边界的边界框并调整视图
            List<Point2D.Double> allPoints = new ArrayList<>();
            if (previewOriginalBoundary != null) allPoints.addAll(previewOriginalBoundary);
            if (previewOptimizedBoundary != null) allPoints.addAll(previewOptimizedBoundary);
            if (!allPoints.isEmpty()) {
                Rectangle2D.Double bounds = computeBounds(allPoints);
                SwingUtilities.invokeLater(() -> {
                    fitBoundsToView(bounds);
                    visualizationPanel.repaint();
                });
            }
        } else {
            visualizationPanel.repaint();
        }
    }
    
    /**
     * 清除边界预览
     */
    public void clearBoundaryPreview() {
        previewOriginalBoundary = null;
        previewOptimizedBoundary = null;
        boundaryPreviewActive = false;
        visualizationPanel.repaint();
    }
    
    /**
     * 绘制边界预览（原始边界-紫色，优化后边界-绿色）
     */
    private void drawBoundaryPreview(Graphics2D g2d) {
        // 绘制原始边界（紫色）
        if (previewOriginalBoundary != null && previewOriginalBoundary.size() >= 2) {
            Color purpleFill = new Color(128, 0, 128, 80); // 紫色半透明填充
            Color purpleBorder = new Color(128, 0, 128, 255); // 紫色边框
            bianjiedrwa.drawBoundary(g2d, previewOriginalBoundary, scale, purpleFill, purpleBorder);
        }
        
        // 绘制优化后边界（绿色，与正常边界颜色一致）
        if (previewOptimizedBoundary != null && previewOptimizedBoundary.size() >= 2) {
            bianjiedrwa.drawBoundary(g2d, previewOptimizedBoundary, scale, GRASS_FILL_COLOR, GRASS_BORDER_COLOR);
            
            // 绘制优化后边界坐标点（紫色实心圆圈，显示序号）
            drawOptimizedBoundaryPointsWithNumbers(g2d, previewOptimizedBoundary, scale);
        }
    }
    
    /**
     * 绘制优化后边界坐标点（紫色实心圆圈，显示序号）
     * 序号显示在点中心，字体大小11号，不随缩放变化
     */
    private void drawOptimizedBoundaryPointsWithNumbers(Graphics2D g2d, List<Point2D.Double> boundary, double scale) {
        if (boundary == null || boundary.isEmpty()) {
            return;
        }
        
        // 保存原始变换
        AffineTransform originalTransform = g2d.getTransform();
        
        // 设置点的大小（实心圆圈，直径约0.3米）
        double scaleFactor = Math.max(0.5, scale);
        double markerDiameter = 0.3; // 圆圈直径（米）
        double markerRadius = markerDiameter / 2.0;
        
        // 设置字体（11号，不随缩放变化）
        Font labelFont = new Font("微软雅黑", Font.PLAIN, 11);
        g2d.setFont(labelFont);
        FontMetrics fontMetrics = g2d.getFontMetrics(labelFont);
        
        // 紫色实心圆圈颜色
        Color purpleColor = new Color(128, 0, 128, 255); // 紫色
        
        // 绘制每个点及其序号
        for (int i = 0; i < boundary.size(); i++) {
            Point2D.Double point = boundary.get(i);
            double x = point.x;
            double y = point.y;
            
            // 绘制紫色实心圆圈（在世界坐标系中，随缩放变化）
            g2d.setColor(purpleColor);
            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);
    }
    
    /**
     * 处理优化后边界坐标点点击
     * @param screenPoint 屏幕坐标点
     * @return 是否处理了点击
     */
    private boolean handleOptimizedBoundaryPointClick(Point screenPoint) {
        if (previewOptimizedBoundary == null || previewOptimizedBoundary.isEmpty()) {
            return false;
        }
        
        // 计算选择阈值（像素）
        double threshold = computeOptimizedBoundaryPointSelectionThreshold();
        
        // 查找被点击的点
        int hitIndex = -1;
        for (int i = 0; i < previewOptimizedBoundary.size(); i++) {
            Point2D.Double worldPoint = previewOptimizedBoundary.get(i);
            Point2D.Double screenPosition = worldToScreen(worldPoint);
            double dx = screenPosition.x - screenPoint.x;
            double dy = screenPosition.y - screenPoint.y;
            if (Math.hypot(dx, dy) <= threshold) {
                hitIndex = i;
                break;
            }
        }
        
        if (hitIndex < 0) {
            return false;
        }
        
        // 弹出确认对话框
        String pointLabel = String.valueOf(hitIndex + 1);
        int choice = JOptionPane.showConfirmDialog(
            visualizationPanel,
            "确定要删除第" + pointLabel + "号优化后边界坐标点吗？",
            "删除边界坐标点",
            JOptionPane.OK_CANCEL_OPTION,
            JOptionPane.WARNING_MESSAGE
        );
        
        if (choice == JOptionPane.OK_OPTION) {
            // 删除坐标点
            List<Point2D.Double> updated = new ArrayList<>(previewOptimizedBoundary);
            updated.remove(hitIndex);
            
            // 更新预览边界
            previewOptimizedBoundary = updated;
            
            // 转换为字符串格式并保存
            String updatedBoundaryString = convertBoundaryToString(updated);
            
            // 通知 Shouye 保存更新后的边界坐标
            if (boundaryPreviewUpdateCallback != null) {
                boundaryPreviewUpdateCallback.accept(updatedBoundaryString);
            }
            
            // 刷新显示
            visualizationPanel.repaint();
        }
        
        return true;
    }
    
    /**
     * 计算优化后边界坐标点的选择阈值（像素）
     */
    private double computeOptimizedBoundaryPointSelectionThreshold() {
        double scaleFactor = Math.max(0.5, scale);
        double markerDiameterWorld = 0.3; // 圆圈直径（米）
        double markerDiameterPixels = markerDiameterWorld * scale;
        return Math.max(8.0, markerDiameterPixels * 1.5);
    }
    
    /**
     * 将边界点列表转换为字符串格式
     */
    private String convertBoundaryToString(List<Point2D.Double> boundary) {
        if (boundary == null || boundary.isEmpty()) {
            return "";
        }
        
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < boundary.size(); i++) {
            Point2D.Double point = boundary.get(i);
            sb.append(String.format(Locale.US, "%.2f,%.2f", point.x, point.y));
            if (i < boundary.size() - 1) {
                sb.append(";");
            }
        }
        return sb.toString();
    }
    
    /**
     * 设置边界预览更新回调
     */
    private java.util.function.Consumer<String> boundaryPreviewUpdateCallback;
    
    public void setBoundaryPreviewUpdateCallback(java.util.function.Consumer<String> callback) {
        this.boundaryPreviewUpdateCallback = callback;
    }

}