新增了串口割草机拖尾和缩放比例保存功能

张世豪

8 天以前 de75ec84e295c3f952a200897aa22aa73d7d5867

 src/zhuye/MapRenderer.java

@@ -10,32 +10,41 @@
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.Deque;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Set;
import set.Setsys;
import gecaoji.Device;
import gecaoji.Gecaoji;
import gecaoji.GecaojiMeg;
import gecaoji.gecaolunjing;
import gecaoji.lujingdraw;
import dikuai.Dikuaiguanli;
import dikuai.Dikuai;
import zhangaiwu.Obstacledraw;
import zhangaiwu.Obstacledge;
import zhangaiwu.yulanzhangaiwu;
import yaokong.Control03;

/**
 * 地图渲染器 - 负责坐标系绘制、视图变换等功能
 */
public class MapRenderer {
    // 视图变换参数
    private double scale = 1.0;
    private static final double DEFAULT_SCALE = 20.0; // 默认缩放比例
    private double scale = DEFAULT_SCALE;
    private double translateX = 0.0;
    private double translateY = 0.0;
    private Point lastDragPoint;
    private Point mousePoint;
    private static final double MIN_SCALE = 0.05d;
    private static final double MAX_SCALE = 50.0d;
    private static final double SCALE_EPSILON = 1e-6d;
    private static final String MAP_SCALE_PROPERTY = "mapScale"; // 属性文件中的键名
    
    // 主题颜色
    private final Color THEME_COLOR = new Color(46, 139, 87);
@@ -43,20 +52,17 @@
    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 BOUNDARY_LABEL_COLOR = Color.BLACK;
    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;
    private static final SimpleDateFormat TIMESTAMP_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    private static final Color HANDHELD_BOUNDARY_FILL = new Color(51, 153, 255, 60);
    private static final Color HANDHELD_BOUNDARY_BORDER = new Color(51, 102, 204, 220);
    private static final Color HANDHELD_BOUNDARY_POINT = new Color(51, 102, 204);
    private static final Color HANDHELD_BOUNDARY_LABEL = new Color(22, 62, 138);
    private static final double BOUNDARY_CONTAINS_TOLERANCE = 0.05;
    private static final double PREVIEW_BOUNDARY_MARKER_SCALE = 0.25d;
    
    // 组件引用
    private JPanel visualizationPanel;
    private List<Point2D.Double> currentBoundary;
    private Rectangle2D.Double boundaryBounds;
    private Path2D.Double currentBoundaryPath;
    private List<Point2D.Double> currentPlannedPath;
    private Rectangle2D.Double plannedPathBounds;
    private List<Obstacledge.Obstacle> currentObstacles;
@@ -65,24 +71,19 @@
    private String currentObstacleLandNumber;
    private String boundaryName;
    private boolean boundaryPointsVisible;
    private double boundaryPointSizeScale = 1.0d;
    private boolean previewSizingEnabled;
    private String currentBoundaryLandNumber;
    private boolean dragInProgress;
    private final Gecaoji mower;
    private final Timer mowerUpdateTimer;
    private JDialog mowerInfoDialog;
    private Timer mowerInfoRefreshTimer;
    private JLabel mowerNumberValueLabel;
    private JLabel realtimeXValueLabel;
    private JLabel realtimeYValueLabel;
    private JLabel positioningStatusValueLabel;
    private JLabel satelliteCountValueLabel;
    private JLabel realtimeSpeedValueLabel;
    private JLabel headingValueLabel;
    private JLabel updateTimeValueLabel;
    private final GecaojiMeg mowerInfoManager;
    private CircleCaptureOverlay circleCaptureOverlay;
    private final List<double[]> circleSampleMarkers = new ArrayList<>();
    private final List<Point2D.Double> realtimeMowingTrack = new ArrayList<>();
    private final Deque<tuowei.TrailSample> idleMowerTrail = new ArrayDeque<>();
    private final List<Point2D.Double> handheldBoundaryPreview = new ArrayList<>();
    private double boundaryPreviewMarkerScale = 1.0d;
    private boolean realtimeTrackRecording;
    private String realtimeTrackLandNumber;
    private double mowerEffectiveWidthMeters;
@@ -94,15 +95,59 @@
    private long lastTrackPersistTimeMillis;
    private boolean trackDirty;
    private boolean handheldBoundaryPreviewActive;
    private boolean pendingTrackBreak = true;
    private boolean idleTrailSuppressed;
    private Path2D.Double realtimeBoundaryPathCache;
    private String realtimeBoundaryPathLand;

    private static final double TRACK_SAMPLE_MIN_DISTANCE_METERS = 0.1d;
    private static final double TRACK_SAMPLE_MIN_DISTANCE_METERS = 0.2d;
    private static final double TRACK_DUPLICATE_TOLERANCE_METERS = 1e-3d;
    private static final long TRACK_PERSIST_INTERVAL_MS = 5_000L;
    public static final int DEFAULT_IDLE_TRAIL_DURATION_SECONDS = 60;
    private static final double IDLE_TRAIL_SAMPLE_DISTANCE_METERS = 0.05d;
    private long idleTrailDurationMs = DEFAULT_IDLE_TRAIL_DURATION_SECONDS * 1_000L;
    private static final double ZOOM_STEP_FACTOR = 1.2d;
    
    public MapRenderer(JPanel visualizationPanel) {
        this.visualizationPanel = visualizationPanel;
        this.mower = new Gecaoji();
        this.mowerUpdateTimer = createMowerTimer();
        this.mowerInfoManager = new GecaojiMeg(visualizationPanel, mower);
        setupMouseListeners();
        // 从配置文件读取上次保存的缩放比例
        loadScaleFromProperties();
    }
    
    /**
     * 从配置文件读取缩放比例
     */
    private void loadScaleFromProperties() {
        String scaleValue = Setsys.getPropertyValue(MAP_SCALE_PROPERTY);
        if (scaleValue != null && !scaleValue.trim().isEmpty()) {
            try {
                double savedScale = Double.parseDouble(scaleValue.trim());
                // 验证缩放比例是否在有效范围内
                if (savedScale >= MIN_SCALE && savedScale <= MAX_SCALE) {
                    scale = savedScale;
                } else {
                    scale = DEFAULT_SCALE;
                }
            } catch (NumberFormatException e) {
                // 如果解析失败，使用默认值
                scale = DEFAULT_SCALE;
            }
        } else {
            // 如果没有保存的值，使用默认值
            scale = DEFAULT_SCALE;
        }
    }
    
    /**
     * 保存缩放比例到配置文件
     */
    private void saveScaleToProperties() {
        Setsys setsys = new Setsys();
        setsys.updateProperty(MAP_SCALE_PROPERTY, String.valueOf(scale));
    }
    
    /**
@@ -111,10 +156,10 @@
    private void setupMouseListeners() {
        // 鼠标滚轮缩放
        visualizationPanel.addMouseWheelListener(e -> {
            mousePoint = e.getPoint();
            Point referencePoint = e.getPoint();
            int notches = e.getWheelRotation();
            double zoomFactor = notches < 0 ? 1.2 : 1/1.2;
            zoomAtPoint(zoomFactor);
            double zoomFactor = notches < 0 ? ZOOM_STEP_FACTOR : 1 / ZOOM_STEP_FACTOR;
            zoomAtPoint(referencePoint, zoomFactor);
        });
        
        // 鼠标拖拽移动
@@ -164,18 +209,13 @@
                    visualizationPanel.repaint();
                }
            }
            
            public void mouseMoved(MouseEvent e) {
                // 更新鼠标位置用于显示坐标
                mousePoint = e.getPoint();
                visualizationPanel.repaint();
            }
        });
    }

    private Timer createMowerTimer() {
        Timer timer = new Timer(300, e -> {
            mower.refreshFromDevice();
            updateIdleMowerTrail();
            if (realtimeTrackRecording) {
                captureRealtimeTrackPoint();
            }
@@ -192,34 +232,71 @@
    /**
     * 基于鼠标位置的缩放
     */
    private void zoomAtPoint(double zoomFactor) {
        if (mousePoint == null) return;
        
        // 计算鼠标位置在世界坐标系中的坐标
        double worldX = (mousePoint.x - visualizationPanel.getWidth()/2) / scale - translateX;
        double worldY = (mousePoint.y - visualizationPanel.getHeight()/2) / scale - translateY;
    private void zoomAtPoint(Point referencePoint, double zoomFactor) {
        if (visualizationPanel == null) {
            return;
        }
        if (referencePoint == null) {
            referencePoint = new Point(visualizationPanel.getWidth() / 2, visualizationPanel.getHeight() / 2);
        }

        scale *= zoomFactor;
        scale = Math.max(0.05, Math.min(scale, 50.0)); // 限制缩放范围，允许最多缩小至原始的1/20
        
        // 计算缩放后同一鼠标位置在世界坐标系中的新坐标
        double newWorldX = (mousePoint.x - visualizationPanel.getWidth()/2) / scale - translateX;
        double newWorldY = (mousePoint.y - visualizationPanel.getHeight()/2) / scale - translateY;
        
        // 调整平移量，使鼠标指向的世界坐标保持不变
        double panelCenterX = visualizationPanel.getWidth() / 2.0;
        double panelCenterY = visualizationPanel.getHeight() / 2.0;

        double worldX = (referencePoint.x - panelCenterX) / scale - translateX;
        double worldY = (referencePoint.y - panelCenterY) / scale - translateY;

    scale *= zoomFactor;
    scale = Math.max(MIN_SCALE, Math.min(scale, MAX_SCALE)); // 限制缩放范围，允许最多缩小至原始的1/20

        double newWorldX = (referencePoint.x - panelCenterX) / scale - translateX;
        double newWorldY = (referencePoint.y - panelCenterY) / scale - translateY;

        translateX += (newWorldX - worldX);
        translateY += (newWorldY - worldY);
        

        // 保存缩放比例到配置文件
        saveScaleToProperties();
        visualizationPanel.repaint();
    }

    public void zoomInFromCenter() {
        zoomAtPoint(null, ZOOM_STEP_FACTOR);
    }

    public void zoomOutFromCenter() {
        zoomAtPoint(null, 1 / ZOOM_STEP_FACTOR);
    }
    
    public boolean canZoomIn() {
        return scale < MAX_SCALE - SCALE_EPSILON;
    }

    public boolean canZoomOut() {
        return scale > MIN_SCALE + SCALE_EPSILON;
    }

    public double getScale() {
        return scale;
    }

    public double getMaxScale() {
        return MAX_SCALE;
    }

    public double getMinScale() {
        return MIN_SCALE;
    }
    
    /**
     * 重置视图
     */
    public void resetView() {
        scale = 1.0;
        scale = DEFAULT_SCALE;
        translateX = 0.0;
        translateY = 0.0;
        // 保存缩放比例到配置文件
        saveScaleToProperties();
        visualizationPanel.repaint();
    }
    
@@ -263,25 +340,28 @@
            drawCircleCaptureOverlay(g2d, circleCaptureOverlay, scale);
        }

        if (handheldBoundaryPreviewActive) {
            drawHandheldBoundaryPreview(g2d);
        }
    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,
                BOUNDARY_LABEL_COLOR
                markerScale
            );
        }

        if (shouldRenderIdleTrail()) {
            tuowei.draw(g2d, idleMowerTrail, scale);
        }

        if (!realtimeMowingTrack.isEmpty()) {
            drawRealtimeMowingCoverage(g2d);
        }
@@ -301,7 +381,7 @@
    private void drawCoordinateSystem(Graphics2D g2d) {
        // 绘制原点 - 红色实心小圆圈
        g2d.setColor(Color.RED);
        g2d.fillOval(-1, -1, 2, 2);      
        g2d.fill(new Ellipse2D.Double(-0.5d, -0.5d, 1d, 1d));
    }
    
    
@@ -314,151 +394,232 @@
    }

    private void drawRealtimeMowingCoverage(Graphics2D g2d) {
        if (realtimeMowingTrack.size() < 2) {
        if (realtimeMowingTrack == null || realtimeMowingTrack.size() < 2) {
            return;
        }

        Path2D.Double path = new Path2D.Double();
        boolean started = false;
        for (Point2D.Double point : realtimeMowingTrack) {
            if (point == null || !Double.isFinite(point.x) || !Double.isFinite(point.y)) {
                continue;
            }
            if (!started) {
                path.moveTo(point.x, point.y);
                started = true;
            } else {
                path.lineTo(point.x, point.y);
            }
        }

        if (!started) {
            return;
        }

        Stroke originalStroke = g2d.getStroke();
        Color originalColor = g2d.getColor();

        Path2D.Double boundaryPath = getRealtimeBoundaryPath();
        double effectiveWidth = getEffectiveMowerWidthMeters();
        if (effectiveWidth > 0) {
            float coverageWidth = (float) Math.max(effectiveWidth, 0.1d);
            g2d.setStroke(new BasicStroke(coverageWidth, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
            g2d.setColor(new Color(46, 139, 87, 80));
            g2d.draw(path);
        }

        float spineWidth = (float) (effectiveWidth > 0 ? Math.max(effectiveWidth / 4.0, 0.18d) : 0.3d);
        g2d.setStroke(new BasicStroke(spineWidth, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
        g2d.setColor(new Color(34, 139, 34, 200));
        g2d.draw(path);

        g2d.setStroke(originalStroke);
        g2d.setColor(originalColor);
        gecaolunjing.draw(g2d, realtimeMowingTrack, effectiveWidth, boundaryPath);
    }

    private void drawHandheldBoundaryPreview(Graphics2D g2d) {
        if (!handheldBoundaryPreviewActive || handheldBoundaryPreview.isEmpty()) {
            return;
    private Path2D.Double getRealtimeBoundaryPath() {
        if (realtimeTrackLandNumber == null) {
            return null;
        }

        Path2D.Double path = new Path2D.Double();
        boolean started = false;
        for (Point2D.Double point : handheldBoundaryPreview) {
            if (point == null || !Double.isFinite(point.x) || !Double.isFinite(point.y)) {
                continue;
        if (currentBoundaryLandNumber != null && realtimeTrackLandNumber.equals(currentBoundaryLandNumber)) {
            if (currentBoundaryPath == null) {
                currentBoundaryPath = buildBoundaryPath(currentBoundary);
            }
            if (!started) {
                path.moveTo(point.x, point.y);
                started = true;
            } else {
                path.lineTo(point.x, point.y);
            }
            return currentBoundaryPath;
        }

        if (!started) {
            return;
        if (realtimeBoundaryPathCache != null && realtimeTrackLandNumber.equals(realtimeBoundaryPathLand)) {
            return realtimeBoundaryPathCache;
        }

        Stroke originalStroke = g2d.getStroke();
        Color originalColor = g2d.getColor();

        if (handheldBoundaryPreview.size() >= 3) {
            path.closePath();
            g2d.setColor(HANDHELD_BOUNDARY_FILL);
            g2d.fill(path);
        Dikuai dikuai = Dikuai.getDikuai(realtimeTrackLandNumber);
        if (dikuai == null) {
            realtimeBoundaryPathCache = null;
            realtimeBoundaryPathLand = null;
            return null;
        }

        float outlineWidth = (float) Math.max(1.5f / scale, 0.2f);
        g2d.setStroke(new BasicStroke(outlineWidth, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
        g2d.setColor(HANDHELD_BOUNDARY_BORDER);
        g2d.draw(path);

        double markerSize = Math.max(0.5d, 3.0d / scale);
        double markerRadius = markerSize / 2.0d;
        Font originalFont = g2d.getFont();
        float labelFontSize = (float) Math.max(6.0f, 16.0f / Math.max(scale, 0.2));
        Font labelFont = originalFont.deriveFont(Font.BOLD, labelFontSize);
        FontMetrics metrics = g2d.getFontMetrics(labelFont);

        for (Point2D.Double point : handheldBoundaryPreview) {
            if (point == null || !Double.isFinite(point.x) || !Double.isFinite(point.y)) {
                continue;
            }
            Shape marker = new Ellipse2D.Double(point.x - markerRadius, point.y - markerRadius, markerSize, markerSize);
            g2d.setColor(HANDHELD_BOUNDARY_POINT);
            g2d.fill(marker);
        String normalized = normalizeValue(dikuai.getBoundaryCoordinates());
        if (normalized == null) {
            realtimeBoundaryPathCache = null;
            realtimeBoundaryPathLand = null;
            return null;
        }

        g2d.setFont(labelFont);
        g2d.setColor(HANDHELD_BOUNDARY_LABEL);
        int index = 1;
        for (Point2D.Double point : handheldBoundaryPreview) {
            if (point == null || !Double.isFinite(point.x) || !Double.isFinite(point.y)) {
                index++;
                continue;
            }
            String label = String.valueOf(index++);
            int textWidth = metrics.stringWidth(label);
            int ascent = metrics.getAscent();
            int descent = metrics.getDescent();
            float textX = (float) (point.x - textWidth / 2.0);
            float textY = (float) (point.y + (ascent - descent) / 2.0);
            g2d.drawString(label, textX, textY);
        List<Point2D.Double> parsed = parseBoundary(normalized);
        if (parsed.size() < 3) {
            realtimeBoundaryPathCache = null;
            realtimeBoundaryPathLand = null;
            return null;
        }

        g2d.setStroke(originalStroke);
        g2d.setFont(originalFont);
        g2d.setColor(originalColor);
        realtimeBoundaryPathCache = buildBoundaryPath(parsed);
        realtimeBoundaryPathLand = realtimeTrackLandNumber;
        return realtimeBoundaryPathCache;
    }

    private boolean shouldRenderIdleTrail() {
        return !idleTrailSuppressed
            && !realtimeTrackRecording
            && !handheldBoundaryPreviewActive
            && idleMowerTrail.size() >= 2;
    }

    private void captureRealtimeTrackPoint() {
        if (!realtimeTrackRecording) {
            return;
        }
        if (realtimeTrackLandNumber == null || visualizationPanel == null) {
            pendingTrackBreak = true;
            return;
        }
        Device device = Device.getGecaoji();
        if (device == null) {
            pendingTrackBreak = true;
            return;
        }

        String fixQuality = device.getPositioningStatus();
        if (!isHighPrecisionFix(fixQuality)) {
            pendingTrackBreak = true;
            return;
        }
        Point2D.Double position = mower.getPosition();
        if (position == null || !Double.isFinite(position.x) || !Double.isFinite(position.y)) {
            pendingTrackBreak = true;
            return;
        }

        if (!isPointInsideActiveBoundary(position)) {
            pendingTrackBreak = true;
            return;
        }

        Point2D.Double candidate = new Point2D.Double(position.x, position.y);
        Point2D.Double lastPoint = realtimeMowingTrack.isEmpty() ? null : realtimeMowingTrack.get(realtimeMowingTrack.size() - 1);
        double distance = 0.0;
        double distance = Double.NaN;
        if (lastPoint != null) {
            double dx = position.x - lastPoint.x;
            double dy = position.y - lastPoint.y;
            double dx = candidate.x - lastPoint.x;
            double dy = candidate.y - lastPoint.y;
            distance = Math.hypot(dx, dy);
            if (distance <= TRACK_DUPLICATE_TOLERANCE_METERS) {
                return;
            }
            if (distance < TRACK_SAMPLE_MIN_DISTANCE_METERS) {
                return;
            }
        }

        realtimeMowingTrack.add(new Point2D.Double(position.x, position.y));
        if (distance > 0.0) {
        realtimeMowingTrack.add(candidate);
        if (!pendingTrackBreak && lastPoint != null && Double.isFinite(distance)) {
            trackLengthMeters += distance;
        }

        updateCompletionMetrics();
        trackDirty = true;
        maybePersistRealtimeTrack(false);
    pendingTrackBreak = false;
    }

    private void updateIdleMowerTrail() {
        long now = System.currentTimeMillis();
        pruneIdleMowerTrail(now);

        if (idleTrailSuppressed || realtimeTrackRecording) {
            if (!idleMowerTrail.isEmpty()) {
                clearIdleMowerTrail();
            }
            return;
        }

        Device device = Device.getGecaoji();
        if (device == null) {
            return;
        }
        // 使用更宽松的定位状态判断，允许状态1和4显示拖尾
        if (!isValidFixForTrail(device.getPositioningStatus())) {
            return;
        }

        Point2D.Double position = mower.getPosition();
        if (position == null || !Double.isFinite(position.x) || !Double.isFinite(position.y)) {
            return;
        }

        tuowei.TrailSample lastSample = idleMowerTrail.peekLast();
        if (lastSample != null) {
            Point2D.Double lastPoint = lastSample.getPoint();
            double dx = position.x - lastPoint.x;
            double dy = position.y - lastPoint.y;
            if (Math.hypot(dx, dy) < IDLE_TRAIL_SAMPLE_DISTANCE_METERS) {
                return;
            }
        }

        idleMowerTrail.addLast(new tuowei.TrailSample(now, new Point2D.Double(position.x, position.y)));
        pruneIdleMowerTrail(now);
    }
    
    /**
     * 强制更新拖尾（用于收到$GNGGA数据时立即更新）
     * 这个方法会刷新mower位置并立即添加到拖尾
     */
    public void forceUpdateIdleMowerTrail() {
        long now = System.currentTimeMillis();
        pruneIdleMowerTrail(now);

        if (idleTrailSuppressed || realtimeTrackRecording) {
            if (!idleMowerTrail.isEmpty()) {
                clearIdleMowerTrail();
            }
            return;
        }

        Device device = Device.getGecaoji();
        if (device == null) {
            return;
        }
        // 使用更宽松的定位状态判断，允许状态1和4显示拖尾
        if (!isValidFixForTrail(device.getPositioningStatus())) {
            return;
        }

        // 刷新mower位置，使用最新的Device数据
        mower.refreshFromDevice();
        Point2D.Double position = mower.getPosition();
        if (position == null || !Double.isFinite(position.x) || !Double.isFinite(position.y)) {
            return;
        }

        tuowei.TrailSample lastSample = idleMowerTrail.peekLast();
        if (lastSample != null) {
            Point2D.Double lastPoint = lastSample.getPoint();
            double dx = position.x - lastPoint.x;
            double dy = position.y - lastPoint.y;
            if (Math.hypot(dx, dy) < IDLE_TRAIL_SAMPLE_DISTANCE_METERS) {
                return;
            }
        }

        idleMowerTrail.addLast(new tuowei.TrailSample(now, new Point2D.Double(position.x, position.y)));
        pruneIdleMowerTrail(now);
        
        // 立即重绘，确保拖尾及时显示
        if (visualizationPanel != null) {
            visualizationPanel.repaint();
        }
    }

    private void pruneIdleMowerTrail(long now) {
        if (idleMowerTrail.isEmpty()) {
            return;
        }
    long cutoff = now - idleTrailDurationMs;
        boolean modified = false;
        while (!idleMowerTrail.isEmpty() && idleMowerTrail.peekFirst().getTimestamp() < cutoff) {
            idleMowerTrail.removeFirst();
            modified = true;
        }
        if (modified && visualizationPanel != null) {
            visualizationPanel.repaint();
        }
    }

    private void clearIdleMowerTrail() {
        if (idleMowerTrail.isEmpty()) {
            return;
        }
        idleMowerTrail.clear();
        if (visualizationPanel != null) {
            visualizationPanel.repaint();
        }
    }

    private void updateCompletionMetrics() {
@@ -573,18 +734,26 @@
            mowerEffectiveWidthMeters = defaultMowerWidthMeters;
        }

        idleTrailSuppressed = true;
        clearIdleMowerTrail();

        realtimeTrackLandNumber = normalizedLand;
        realtimeTrackRecording = true;
        pendingTrackBreak = true;
        captureRealtimeTrackPoint();
    }

    public void pauseRealtimeTrackRecording() {
        realtimeTrackRecording = false;
        pendingTrackBreak = true;
        idleTrailSuppressed = false;
        maybePersistRealtimeTrack(true);
    }

    public void stopRealtimeTrackRecording() {
        realtimeTrackRecording = false;
        pendingTrackBreak = true;
        idleTrailSuppressed = false;
        maybePersistRealtimeTrack(true);
    }

@@ -602,15 +771,47 @@
        completedMowingAreaSqMeters = 0.0;
        mowingCompletionRatio = 0.0;
        trackDirty = true;
        pendingTrackBreak = true;
        idleTrailSuppressed = false;
        maybePersistRealtimeTrack(true);
        visualizationPanel.repaint();
    }

    public void clearIdleTrail() {
        clearIdleMowerTrail();
    }

    public void setIdleTrailDurationSeconds(int seconds) {
        int sanitized = seconds;
        if (sanitized < 5 || sanitized > 600) {
            sanitized = DEFAULT_IDLE_TRAIL_DURATION_SECONDS;
        }
        idleTrailDurationMs = sanitized * 1_000L;
        pruneIdleMowerTrail(System.currentTimeMillis());
    }

    public int getIdleTrailDurationSeconds() {
        long seconds = idleTrailDurationMs / 1_000L;
        if (seconds <= 0L) {
            return DEFAULT_IDLE_TRAIL_DURATION_SECONDS;
        }
        if (seconds > Integer.MAX_VALUE) {
            return DEFAULT_IDLE_TRAIL_DURATION_SECONDS;
        }
        return (int) seconds;
    }

    public double getMowingCompletionRatio() {
        if (!isMowerInsideSelectedBoundary()) {
            return 0.0;
        }
        return mowingCompletionRatio;
    }

    public double getCompletedMowingAreaSqMeters() {
        if (!isMowerInsideSelectedBoundary()) {
            return 0.0;
        }
        return completedMowingAreaSqMeters;
    }

@@ -622,6 +823,14 @@
        return trackLengthMeters;
    }

    private boolean isMowerInsideSelectedBoundary() {
        Point2D.Double position = mower.getPosition();
        if (position == null) {
            return false;
        }
        return isPointInsideActiveBoundary(position);
    }

    public void flushRealtimeTrack() {
        maybePersistRealtimeTrack(true);
    }
@@ -635,6 +844,9 @@
        mowingCompletionRatio = 0.0;
        trackDirty = false;
        lastTrackPersistTimeMillis = 0L;
        pendingTrackBreak = true;
        realtimeBoundaryPathCache = null;
        realtimeBoundaryPathLand = null;

        String trimmed = normalizeValue(trackData);
        if (trimmed == null || trimmed.isEmpty()) {
@@ -643,6 +855,7 @@
        }

        String[] segments = trimmed.split(";");
        Path2D.Double boundaryPath = getRealtimeBoundaryPath();
        Point2D.Double lastPoint = null;
        for (String segment : segments) {
            if (segment == null || segment.trim().isEmpty()) {
@@ -655,11 +868,26 @@
            try {
                double x = Double.parseDouble(parts[0].trim());
                double y = Double.parseDouble(parts[1].trim());
                Point2D.Double current = new Point2D.Double(x, y);
                realtimeMowingTrack.add(current);
                if (lastPoint != null) {
                    trackLengthMeters += Math.hypot(current.x - lastPoint.x, current.y - lastPoint.y);
                if (!Double.isFinite(x) || !Double.isFinite(y)) {
                    continue;
                }
                Point2D.Double current = new Point2D.Double(x, y);
                if (boundaryPath != null && !isPointInsideBoundary(current, boundaryPath)) {
                    continue;
                }
                if (lastPoint != null) {
                    double dx = current.x - lastPoint.x;
                    double dy = current.y - lastPoint.y;
                    double distance = Math.hypot(dx, dy);
                    if (distance <= TRACK_DUPLICATE_TOLERANCE_METERS) {
                        continue;
                    }
                    if (distance < TRACK_SAMPLE_MIN_DISTANCE_METERS) {
                        continue;
                    }
                    trackLengthMeters += distance;
                }
                realtimeMowingTrack.add(current);
                lastPoint = current;
            } catch (NumberFormatException ignored) {
                // 跳过异常条目
@@ -770,7 +998,8 @@
    }

    private void drawCurrentPlannedPath(Graphics2D g2d) {
        lujingdraw.drawPlannedPath(g2d, currentPlannedPath, scale);
        double arrowScale = previewSizingEnabled ? 0.5d : 1.0d;
        lujingdraw.drawPlannedPath(g2d, currentPlannedPath, scale, arrowScale);
    }

    private void drawCircleSampleMarkers(Graphics2D g2d, List<double[]> markers, double scale) {
@@ -904,217 +1133,9 @@
        }
    }

    private void showMowerInfo() {
        Device device = Device.getGecaoji();
        if (device == null) {
            JOptionPane.showMessageDialog(
                visualizationPanel,
                "无设备数据",
                "割草机信息",
                JOptionPane.INFORMATION_MESSAGE
            );
            return;
        }

        ensureMowerInfoDialog();
        updateMowerInfoLabels();
        positionMowerDialog();
        if (!mowerInfoDialog.isVisible()) {
            mowerInfoDialog.setVisible(true);
        } else {
            mowerInfoDialog.toFront();
        }
        startMowerInfoTimer();
    }

    private void ensureMowerInfoDialog() {
        if (mowerInfoDialog != null) {
            return;
        }

        Window owner = SwingUtilities.getWindowAncestor(visualizationPanel);
        JDialog dialog = new JDialog(owner, "割草机信息", Dialog.ModalityType.MODELESS);
        dialog.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);

        JPanel content = new JPanel(new BorderLayout(0, 12));
        content.setBorder(BorderFactory.createEmptyBorder(16, 20, 16, 20));

        JPanel grid = new JPanel(new GridLayout(0, 2, 12, 8));

    grid.add(new JLabel("设备编号："));
        mowerNumberValueLabel = createValueLabel();
        grid.add(mowerNumberValueLabel);

    grid.add(new JLabel("实时X坐标："));
        realtimeXValueLabel = createValueLabel();
        grid.add(realtimeXValueLabel);

    grid.add(new JLabel("实时Y坐标："));
        realtimeYValueLabel = createValueLabel();
        grid.add(realtimeYValueLabel);

    grid.add(new JLabel("定位质量："));
        positioningStatusValueLabel = createValueLabel();
        grid.add(positioningStatusValueLabel);

    grid.add(new JLabel("卫星颗数："));
        satelliteCountValueLabel = createValueLabel();
        grid.add(satelliteCountValueLabel);

    grid.add(new JLabel("行驶速度："));
        realtimeSpeedValueLabel = createValueLabel();
        grid.add(realtimeSpeedValueLabel);

    grid.add(new JLabel("运动航向："));
        headingValueLabel = createValueLabel();
        grid.add(headingValueLabel);

    grid.add(new JLabel("更新时间："));
        updateTimeValueLabel = createValueLabel();
        grid.add(updateTimeValueLabel);

        content.add(grid, BorderLayout.CENTER);

        JButton closeButton = new JButton("关闭");
        closeButton.addActionListener(e -> dialog.dispose());
        JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
        buttonPanel.add(closeButton);
        content.add(buttonPanel, BorderLayout.SOUTH);

    dialog.setContentPane(content);
    dialog.pack();
        dialog.setResizable(false);
        dialog.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosed(WindowEvent e) {
                stopMowerInfoTimer();
                resetMowerInfoLabels();
                mowerInfoDialog = null;
            }
        });

        mowerInfoDialog = dialog;
    }

    private void positionMowerDialog() {
        if (mowerInfoDialog == null || visualizationPanel == null) {
            return;
        }
        int panelWidth = visualizationPanel.getWidth();
        int panelHeight = visualizationPanel.getHeight();
        int dialogHeight = mowerInfoDialog.getHeight();
        if (dialogHeight <= 0) {
            dialogHeight = mowerInfoDialog.getPreferredSize().height;
        }
        if (panelWidth > 0) {
            mowerInfoDialog.setSize(panelWidth, dialogHeight);
        }

        try {
            Point panelOnScreen = visualizationPanel.getLocationOnScreen();
            int dialogWidth = mowerInfoDialog.getWidth();
            int targetX = panelOnScreen.x + (panelWidth - dialogWidth) / 2;
            int targetY = panelOnScreen.y + panelHeight / 3 - dialogHeight / 2;
            mowerInfoDialog.setLocation(targetX, targetY);
        } catch (IllegalComponentStateException ex) {
            // component not yet showing; ignore positioning
        }
    }

    private JLabel createValueLabel() {
        JLabel label = new JLabel("--");
        label.setHorizontalAlignment(SwingConstants.LEFT);
        return label;
    }

    private void startMowerInfoTimer() {
        if (mowerInfoRefreshTimer == null) {
            mowerInfoRefreshTimer = new Timer(1000, e -> updateMowerInfoLabels());
            mowerInfoRefreshTimer.setRepeats(true);
        }
        if (!mowerInfoRefreshTimer.isRunning()) {
            mowerInfoRefreshTimer.start();
        }
    }

    private void stopMowerInfoTimer() {
        if (mowerInfoRefreshTimer != null) {
            mowerInfoRefreshTimer.stop();
            mowerInfoRefreshTimer = null;
        }
    }

    private void resetMowerInfoLabels() {
        mowerNumberValueLabel = null;
        realtimeXValueLabel = null;
        realtimeYValueLabel = null;
        positioningStatusValueLabel = null;
        satelliteCountValueLabel = null;
        realtimeSpeedValueLabel = null;
        headingValueLabel = null;
        updateTimeValueLabel = null;
    }

    private void updateMowerInfoLabels() {
        if (mowerNumberValueLabel == null) {
            return;
        }

        Device device = Device.getGecaoji();
        if (device == null) {
            setMowerInfoLabels("--");
            return;
        }

        mower.refreshFromDevice();

        mowerNumberValueLabel.setText(formatDeviceValue(device.getMowerNumber()));
        realtimeXValueLabel.setText(formatDeviceValue(device.getRealtimeX()));
        realtimeYValueLabel.setText(formatDeviceValue(device.getRealtimeY()));
        positioningStatusValueLabel.setText(formatDeviceValue(device.getPositioningStatus()));
        satelliteCountValueLabel.setText(formatDeviceValue(device.getSatelliteCount()));
        realtimeSpeedValueLabel.setText(formatDeviceValue(device.getRealtimeSpeed()));
        headingValueLabel.setText(formatDeviceValue(device.getHeading()));
        updateTimeValueLabel.setText(formatTimestamp(device.getGupdateTime()));
    }

    private void setMowerInfoLabels(String value) {
        if (mowerNumberValueLabel != null) mowerNumberValueLabel.setText(value);
        if (realtimeXValueLabel != null) realtimeXValueLabel.setText(value);
        if (realtimeYValueLabel != null) realtimeYValueLabel.setText(value);
        if (positioningStatusValueLabel != null) positioningStatusValueLabel.setText(value);
        if (satelliteCountValueLabel != null) satelliteCountValueLabel.setText(value);
        if (realtimeSpeedValueLabel != null) realtimeSpeedValueLabel.setText(value);
        if (headingValueLabel != null) headingValueLabel.setText(value);
        if (updateTimeValueLabel != null) updateTimeValueLabel.setText(value);
    }

    private String sanitizeDeviceValue(String value) {
        if (value == null) {
            return null;
        }
        String trimmed = value.trim();
        if (trimmed.isEmpty() || "-1".equals(trimmed)) {
            return null;
        }
        return trimmed;
    }

    private String formatDeviceValue(String value) {
        String sanitized = sanitizeDeviceValue(value);
        return sanitized == null ? "--" : sanitized;
    }

    private String formatTimestamp(String value) {
        String sanitized = sanitizeDeviceValue(value);
        if (sanitized == null) {
            return "--";
        }
        try {
            long millis = Long.parseLong(sanitized);
            return TIMESTAMP_FORMAT.format(new Date(millis));
        } catch (NumberFormatException ex) {
            return sanitized;
    public void showMowerInfo() {
        if (mowerInfoManager != null) {
            mowerInfoManager.showMowerInfo();
        }
    }

@@ -1167,7 +1188,11 @@

    private double computeSelectionThresholdPixels() {
        double scaleFactor = Math.max(0.5, scale);
        double markerDiameterWorld = Math.max(1.0, (10.0 / scaleFactor) * 0.2);
        double diameterScale = boundaryPointSizeScale * (previewSizingEnabled ? PREVIEW_BOUNDARY_MARKER_SCALE : 1.0d);
        if (!Double.isFinite(diameterScale) || diameterScale <= 0.0d) {
            diameterScale = 1.0d;
        }
        double markerDiameterWorld = Math.max(1.0, (10.0 / scaleFactor) * 0.2 * diameterScale);
        double markerDiameterPixels = markerDiameterWorld * scale;
        return Math.max(8.0, markerDiameterPixels * 1.5);
    }
@@ -1207,6 +1232,7 @@

        if (updated.size() < 2) {
            currentBoundary = null;
            currentBoundaryPath = null;
            boundaryBounds = null;
            boundaryPointsVisible = false;
            Dikuaiguanli.updateBoundaryPointVisibility(currentBoundaryLandNumber, false);
@@ -1214,10 +1240,12 @@
            adjustViewAfterBoundaryReset();
        } else {
            currentBoundary = updated;
            rebuildBoundaryPath();
            boundaryBounds = computeBounds(updated);
            Dikuaiguanli.updateBoundaryPointVisibility(currentBoundaryLandNumber, boundaryPointsVisible);
            visualizationPanel.repaint();
        }
        pendingTrackBreak = true;
    }

    private boolean persistBoundaryChanges(List<Point2D.Double> updatedBoundary) {
@@ -1279,6 +1307,100 @@
        return Math.hypot(dx, dy) <= BOUNDARY_POINT_MERGE_THRESHOLD;
    }

    private boolean isHighPrecisionFix(String fixQuality) {
        if (fixQuality == null) {
            return false;
        }
        String trimmed = fixQuality.trim();
        if (trimmed.isEmpty()) {
            return false;
        }
        if ("4".equals(trimmed)) {
            return true;
        }
        try {
            double value = Double.parseDouble(trimmed);
            return Math.abs(value - 4.0d) < 1e-6;
        } catch (NumberFormatException ex) {
            return false;
        }
    }
    
    /**
     * 判断定位状态是否有效，可用于显示拖尾
     * 接受状态1（单点定位）和4（固定解）
     */
    private boolean isValidFixForTrail(String fixQuality) {
        if (fixQuality == null) {
            return false;
        }
        String trimmed = fixQuality.trim();
        if (trimmed.isEmpty()) {
            return false;
        }
        // 接受状态1（单点定位）和4（固定解）
        if ("1".equals(trimmed) || "4".equals(trimmed)) {
            return true;
        }
        try {
            double value = Double.parseDouble(trimmed);
            // 接受1.0或4.0
            return Math.abs(value - 1.0d) < 1e-6 || Math.abs(value - 4.0d) < 1e-6;
        } catch (NumberFormatException ex) {
            return false;
        }
    }

    private boolean isPointInsideActiveBoundary(Point2D.Double point) {
        if (point == null || !Double.isFinite(point.x) || !Double.isFinite(point.y)) {
            return false;
        }
        if (realtimeTrackLandNumber == null) {
            return false;
        }
        Path2D.Double path = getRealtimeBoundaryPath();
        return isPointInsideBoundary(point, path);
    }

    private boolean isPointInsideBoundary(Point2D.Double point, Path2D.Double path) {
        if (point == null || path == null || !Double.isFinite(point.x) || !Double.isFinite(point.y)) {
            return false;
        }
        if (path.contains(point.x, point.y)) {
            return true;
        }
        double size = BOUNDARY_CONTAINS_TOLERANCE * 2.0;
        return path.intersects(point.x - BOUNDARY_CONTAINS_TOLERANCE, point.y - BOUNDARY_CONTAINS_TOLERANCE, size, size);
    }

    private void rebuildBoundaryPath() {
        currentBoundaryPath = buildBoundaryPath(currentBoundary);
    }

    private Path2D.Double buildBoundaryPath(List<Point2D.Double> boundary) {
        if (boundary == null || boundary.size() < 3) {
            return null;
        }
        Path2D.Double path = new Path2D.Double();
        boolean started = false;
        for (Point2D.Double point : boundary) {
            if (point == null || !Double.isFinite(point.x) || !Double.isFinite(point.y)) {
                continue;
            }
            if (!started) {
                path.moveTo(point.x, point.y);
                started = true;
            } else {
                path.lineTo(point.x, point.y);
            }
        }
        if (!started) {
            return null;
        }
        path.closePath();
        return path;
    }

    
    /**
     * 绘制视图信息
@@ -1286,30 +1408,34 @@
    private void drawViewInfo(Graphics2D g2d) {
        g2d.setColor(new Color(80, 80, 80));
        g2d.setFont(new Font("微软雅黑", Font.PLAIN, 11));
        
        // 只显示缩放比例，去掉平移信息
        String info = String.format("缩放: %.2fx", scale);
        g2d.drawString(info, 15, visualizationPanel.getHeight() - 15);
        
        if (mousePoint != null) {
            // 计算鼠标位置在世界坐标系中的坐标
            double worldX = (mousePoint.x - visualizationPanel.getWidth()/2) / scale - translateX;
            double worldY = (mousePoint.y - visualizationPanel.getHeight()/2) / scale - translateY;
            
            String mouseCoord = String.format("坐标: (%.1f, %.1f)m", worldX, worldY);
            g2d.drawString(mouseCoord, visualizationPanel.getWidth() - 150, visualizationPanel.getHeight() - 15);

        // 在地图顶部左侧显示遥控摇杆对应速度（若非零）
        try {
            int forward = Control03.getCurrentForwardSpeed();
            int steer = Control03.getCurrentSteeringSpeed();
            if (forward != 0 || steer != 0) {
                String speedInfo = String.format("行进:%d 转向:%d", forward, steer);
                // 背景半透明矩形增强可读性
                FontMetrics fm = g2d.getFontMetrics();
                int padding = 6;
                int w = fm.stringWidth(speedInfo) + padding * 2;
                int h = fm.getHeight() + padding;
                int x = 12;
                int y = 12;
                Color bg = new Color(255, 255, 255, 180);
                g2d.setColor(bg);
                g2d.fillRoundRect(x, y, w, h, 8, 8);
                g2d.setColor(new Color(120, 120, 120));
                g2d.drawString(speedInfo, x + padding, y + fm.getAscent() + (padding/2));
            }
        } catch (Throwable t) {
            // 不应阻塞渲染，静默处理任何异常
        }
        
        // 去掉操作提示："滚轮缩放 | 拖拽移动 | 右键重置"
        // String tips = "滚轮缩放 | 拖拽移动 | 右键重置";
        // g2d.drawString(tips, visualizationPanel.getWidth() - 200, 30);
    }
    
    /**
     * 获取当前缩放比例
     */
    public double getScale() {
        return scale;

        // 保留底部的缩放比例信息
        String info = String.format("缩放: %.2fx", scale);
        g2d.setColor(new Color(80, 80, 80));
        g2d.drawString(info, 15, visualizationPanel.getHeight() - 15);
    }
    
    /**
@@ -1330,7 +1456,15 @@
     * 设置视图变换参数（用于程序化控制）
     */
    public void setViewTransform(double scale, double translateX, double translateY) {
        this.scale = scale;
        // 限制缩放范围
        scale = Math.max(MIN_SCALE, Math.min(scale, MAX_SCALE));
        // 如果缩放比例改变了，保存到配置文件
        if (Math.abs(this.scale - scale) > SCALE_EPSILON) {
            this.scale = scale;
            saveScaleToProperties();
        } else {
            this.scale = scale;
        }
        this.translateX = translateX;
        this.translateY = translateY;
        visualizationPanel.repaint();
@@ -1339,6 +1473,8 @@
    public void setCurrentBoundary(String boundaryCoordinates, String landNumber, String landName) {
        this.boundaryName = landName;
        this.currentBoundaryLandNumber = landNumber;
        this.realtimeBoundaryPathCache = null;
        this.realtimeBoundaryPathLand = null;

        if (boundaryCoordinates == null) {
            clearBoundaryData();
@@ -1360,8 +1496,10 @@
            return;
        }

        currentBoundary = parsed;
        boundaryBounds = computeBounds(parsed);
    currentBoundary = parsed;
    rebuildBoundaryPath();
    pendingTrackBreak = true;
    boundaryBounds = computeBounds(parsed);

        Rectangle2D.Double bounds = boundaryBounds;
        SwingUtilities.invokeLater(() -> {
@@ -1372,10 +1510,14 @@

    private void clearBoundaryData() {
        currentBoundary = null;
        currentBoundaryPath = null;
        boundaryBounds = null;
        boundaryName = null;
        boundaryPointsVisible = false;
        currentBoundaryLandNumber = null;
        pendingTrackBreak = true;
        realtimeBoundaryPathCache = null;
        realtimeBoundaryPathLand = null;
    }

    public void setCurrentObstacles(String obstaclesData, String landNumber) {
@@ -1686,6 +1828,9 @@
            return coords;
        }

        // Remove wrapper characters like parentheses that are used when persisting payloads
        sanitized = sanitized.replace("(", "").replace(")", "");

        String[] pairs = sanitized.split(";");
        for (String pair : pairs) {
            if (pair == null) {
@@ -1695,6 +1840,10 @@
            if (trimmed.isEmpty()) {
                continue;
            }
            trimmed = trimmed.replace("(", "").replace(")", "");
            if (trimmed.isEmpty()) {
                continue;
            }
            String[] parts = trimmed.split(",");
            if (parts.length < 2) {
                continue;
@@ -1856,6 +2005,65 @@
        visualizationPanel.repaint();
    }

    public void setBoundaryPointSizeScale(double sizeScale) {
        double normalized = (Double.isFinite(sizeScale) && sizeScale > 0.0d) ? sizeScale : 1.0d;
        if (Math.abs(boundaryPointSizeScale - normalized) < 1e-6) {
            return;
        }
        boundaryPointSizeScale = normalized;
        if (visualizationPanel == null) {
            return;
        }
        if (SwingUtilities.isEventDispatchThread()) {
            visualizationPanel.repaint();
        } else {
            SwingUtilities.invokeLater(visualizationPanel::repaint);
        }
    }

    public void setPathPreviewSizingEnabled(boolean enabled) {
        previewSizingEnabled = enabled;
        if (visualizationPanel == null) {
            return;
        }
        if (SwingUtilities.isEventDispatchThread()) {
            visualizationPanel.repaint();
        } else {
            SwingUtilities.invokeLater(visualizationPanel::repaint);
        }
    }

    public void setBoundaryPreviewMarkerScale(double markerScale) {
        double normalized = Double.isFinite(markerScale) && markerScale > 0.0d ? markerScale : 1.0d;
        if (Math.abs(boundaryPreviewMarkerScale - normalized) < 1e-6) {
            return;
        }
        boundaryPreviewMarkerScale = normalized;
        if (visualizationPanel == null) {
            return;
        }
        if (SwingUtilities.isEventDispatchThread()) {
            visualizationPanel.repaint();
        } else {
            SwingUtilities.invokeLater(visualizationPanel::repaint);
        }
    }

    public boolean setHandheldMowerIconActive(boolean handheldActive) {
        if (mower == null) {
            return false;
        }
        boolean changed = mower.useHandheldIcon(handheldActive);
        if (changed && visualizationPanel != null) {
            if (SwingUtilities.isEventDispatchThread()) {
                visualizationPanel.repaint();
            } else {
                SwingUtilities.invokeLater(visualizationPanel::repaint);
            }
        }
        return changed;
    }

    public void beginHandheldBoundaryPreview() {
        handheldBoundaryPreviewActive = true;
        handheldBoundaryPreview.clear();
@@ -1885,6 +2093,7 @@
    public void clearHandheldBoundaryPreview() {
        handheldBoundaryPreviewActive = false;
        handheldBoundaryPreview.clear();
        boundaryPreviewMarkerScale = 1.0d;
        visualizationPanel.repaint();
    }

@@ -1940,8 +2149,10 @@
            return;
        }

        double width = Math.max(bounds.width, 1);
        double height = Math.max(bounds.height, 1);
        Rectangle2D.Double targetBounds = includeMowerInBounds(bounds);

        double width = Math.max(targetBounds.width, 1);
        double height = Math.max(targetBounds.height, 1);

        double targetWidth = width * 1.2;
        double targetHeight = height * 1.2;
@@ -1953,18 +2164,62 @@
        newScale = Math.max(0.05, Math.min(newScale, 50.0));

        this.scale = newScale;
        this.translateX = -bounds.getCenterX();
        this.translateY = -bounds.getCenterY();
        this.translateX = -targetBounds.getCenterX();
        this.translateY = -targetBounds.getCenterY();
    }

    // Keep the mower marker inside the viewport whenever the camera refits to scene bounds.
    private Rectangle2D.Double includeMowerInBounds(Rectangle2D.Double bounds) {
        Rectangle2D.Double expanded = new Rectangle2D.Double(
            bounds.x,
            bounds.y,
            Math.max(0.0, bounds.width),
            Math.max(0.0, bounds.height)
        );

        if (mower == null || !mower.hasValidPosition()) {
            return expanded;
        }

        Point2D.Double mowerPosition = mower.getPosition();
        if (mowerPosition == null
            || !Double.isFinite(mowerPosition.x)
            || !Double.isFinite(mowerPosition.y)) {
            return expanded;
        }

        double minX = Math.min(expanded.x, mowerPosition.x);
        double minY = Math.min(expanded.y, mowerPosition.y);
        double maxX = Math.max(expanded.x + expanded.width, mowerPosition.x);
        double maxY = Math.max(expanded.y + expanded.height, mowerPosition.y);

        expanded.x = minX;
        expanded.y = minY;
        expanded.width = Math.max(0.0, maxX - minX);
        expanded.height = Math.max(0.0, maxY - minY);

        return expanded;
    }

    public void dispose() {
        mowerUpdateTimer.stop();
        stopMowerInfoTimer();
        if (mowerInfoDialog != null) {
            mowerInfoDialog.dispose();
            mowerInfoDialog = null;
        }
        resetMowerInfoLabels();
        mowerInfoManager.dispose();
    }

    /**
     * 获取当前边界点列表
     * @return 当前边界点列表，如果没有边界则返回null
     */
    public List<Point2D.Double> getCurrentBoundary() {
        return currentBoundary;
    }

    /**
     * 获取割草机实例
     * @return 割草机实例
     */
    public Gecaoji getMower() {
        return mower;
    }

}