DTM Pro New.py

# -*- coding: utf-8 -*-
# DTM Pro 2025 Final (Integraded Edition)
# 包含 实验二、三、四、五、七、八 的功能整合

import sys
import os
import re
import copy
import math  # 导入数学库，用于新功能
import numpy as np
import pandas as pd
from datetime import datetime
from scipy.spatial import Delaunay
from matplotlib.tri import LinearTriInterpolator, Triangulation
from docx import Document
from docx.shared import Inches, Pt, Cm, RGBColor
from docx.enum.text import WD_ALIGN_PARAGRAPH
import requests
import io
import rasterio
from rasterio.transform import from_origin
import rasterstats

from PyQt5.QtWidgets import (
    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, QGridLayout,
    QPushButton, QLabel, QFileDialog, QMessageBox, QSplitter, QGroupBox, QComboBox,
    QDialog, QLineEdit, QScrollArea, QSizePolicy, QTextEdit,
    QInputDialog  # --- NEW --- 导入 QInputDialog
)
from PyQt5.QtCore import Qt, QObject, QThread, pyqtSignal, pyqtSlot, QPointF, QRectF, QSize,QTimer
from PyQt5.QtGui import (
    QDoubleValidator, QPainter, QPen, QColor, QBrush, QFont, QPolygonF, QPixmap, QGuiApplication, QIcon
)

from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT
from matplotlib.figure import Figure
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import matplotlib # For colormap access
import geopandas as gpd # --- 新增：GIS 矢量数据处理 ---
# 应用元信息
APP_NAME = "DTM Pro — Terrain Analysis Suite (Integrated)"
APP_NAME_CN = "地形大师 (集成版)"
APP_VERSION = "1.2.1" # 更新版本号（修正土方量输入 & cmap 警告）

# -------------------- 全局样式 --------------------
plt.rcParams['font.sans-serif'] = ['SimHei', 'Microsoft YaHei', 'Arial']
plt.rcParams['axes.unicode_minus'] = False
plt.style.use('dark_background')

MODERN_STYLESHEET = """
QWidget {
    background-color: #2E2E2E;
    color: #F0F0F0;
    font-family: 'Segoe UI', 'SimHei';
    font-size: 10pt;
}
QPushButton {
    background-color: #555555;
    color: #FFFFFF;
    border: 1px solid #666666;
    border-radius: 4px;
    padding: 6px 10px;
}
QPushButton:hover { background-color: #6a6a6a; }
QPushButton:pressed { background-color: #4CAF50; }
QGroupBox {
    font-weight: bold;
    border: 1px solid #4A4A4A;
    border-radius: 6px;
    margin-top: 16px;
}
QGroupBox::title {
    subcontrol-origin: margin;
    subcontrol-position: top center;
    padding: 3px 8px;
    margin-top: 4px;
    background-color: transparent;
}
QSplitter::handle { background-color: #4A4A4A; }
QSplitter::handle:hover { background-color: #6a6a6a; }
QScrollArea { border: none; }
QLineEdit {
    background-color: #3C3C3C;
    border: 1px solid #555;
    border-radius: 3px;
    padding: 4px;
}
QTextEdit {
    background-color: #252525;
    border: 1px solid #555;
    border-radius: 3px;
    color: #E0E0E0;
}
QComboBox {
    background-color: #3C3C3C;
    border: 1px solid #555;
    border-radius: 3px;
    padding: 4px;
}
QLabel {
    background-color: transparent;
}
"""

CAD_CLASSIC_STYLESHEET = """
QMainWindow, QWidget {
    background-color: #D2D2D2;
    color: #111111;
    font-family: '%s', 'Microsoft YaHei', 'SimHei', 'Segoe UI';
    font-size: 10pt;
}
QGroupBox {
    font-weight: bold;
    border: 1px solid #8A8A8A;
    border-radius: 2px;
    margin-top: 16px;
}
QGroupBox::title {
    subcontrol-origin: margin;
    subcontrol-position: top left;
    padding: 2px 6px;
    margin-top: 4px;
    background-color: #D2D2D2;
}
QPushButton {
    background-color: #E6E6E6;
    color: #111111;
    border: 1px solid #8A8A8A;
    border-radius: 2px;
    padding: 6px 10px;
}
QPushButton:hover { background-color: #F2F2F2; }
QPushButton:pressed { background-color: #CFCFCF; }
QLineEdit, QComboBox, QTextEdit {
    background-color: #F7F7F7;
    color: #111111;
    border: 1px solid #8A8A8A;
    border-radius: 2px;
    padding: 4px;
}
QSplitter::handle { background-color: #9A9A9A; height: 3px; }
QSplitter::handle:hover { background-color: #B0B0B0; }
QLabel { background-color: transparent; color: #111111; }
QScrollArea { border: none; }
QToolTip {
    background-color: #F7F7F7;
    color: #111111;
    border: 1px solid #8A8A8A;
}
"""

CAD_2024_STYLESHEET = """
QMainWindow, QWidget {
    background-color: #1E1F22;
    color: #E6E6E6;
    font-family: '%s', 'Microsoft YaHei', 'SimHei', 'Segoe UI';
    font-size: 10pt;
}
QGroupBox {
    font-weight: bold;
    border: 1px solid #3B3D40;
    border-radius: 2px;
    margin-top: 16px;
}
QGroupBox::title {
    subcontrol-origin: margin;
    subcontrol-position: top left;
    padding: 2px 6px;
    margin-top: 4px;
    background-color: #1E1F22;
    color: #E6E6E6;
}
QPushButton {
    background-color: #2B2D31;
    color: #E6E6E6;
    border: 1px solid #3B3D40;
    border-radius: 2px;
    padding: 6px 10px;
}
QPushButton:hover { background-color: #3A3D43; }
QPushButton:pressed { background-color: #1F2328; }
QLineEdit, QComboBox, QTextEdit {
    background-color: #2B2D31;
    color: #E6E6E6;
    border: 1px solid #3B3D40;
    border-radius: 2px;
    padding: 4px;
}
QSplitter::handle { background-color: #3D4045; height: 3px; }
QSplitter::handle:hover { background-color: #4A4E55; }
QLabel { background-color: transparent; color: #E6E6E6; }
QScrollArea { border: none; }
QToolTip {
    background-color: #2B2D31;
    color: #E6E6E6;
    border: 1px solid #3B3D40;
}
"""

def build_cad_stylesheet(theme_name, font_family):
    font_name = font_family.strip() if font_family else "Microsoft YaHei"
    if theme_name == 'cad_classic':
        return CAD_CLASSIC_STYLESHEET % font_name
    return CAD_2024_STYLESHEET % font_name

# -------------------- 自定义工具栏（中文友好） --------------------
class ChineseNavigationToolbar(NavigationToolbar2QT):
    toolitems = [
        ('Home', 'Reset original view', 'home', 'home'),
        ('Back', 'Go back', 'back', 'back'),
        ('Forward', 'Go forward', 'forward', 'forward'),
        (None, None, None, None),
        ('Pan', 'Pan/Zoom', 'move', 'pan'),
        ('Zoom', 'Zoom to rect', 'zoom_to_rect', 'zoom'),
        (None, None, None, None),
        ('Subplots', 'Configure subplots', 'subplots', 'configure_subplots'),
        ('Save', 'Save figure', 'filesave', 'save_figure'),
    ]

    def _init_toolbar(self):
        self.actions = {}
        from PyQt5.QtWidgets import QSizePolicy
        for text, tooltip_text, image_file, callback in self.toolitems:
            if text is None:
                self.addSeparator()
                continue
            icon = self.get_icon(image_file)
            a = self.addAction(icon, text, getattr(self, callback))
            self.actions[callback] = a
            if text in ['Pan', 'Zoom']:
                a.setCheckable(True)
            a.setToolTip(tooltip_text)
        self.addSeparator()
        self.locLabel = QLabel("", self)
        self.locLabel.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
        self.locLabel.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
        self.addWidget(self.locLabel)

# -------------------- Matplotlib 画布 --------------------
class MplCanvas(FigureCanvas):
    def __init__(self, parent=None, is_3d=False):
        fig = Figure() # 移除 facecolor='#2E2E2E'
        self.figure = fig
        self.is_3d = is_3d
        self.colorbar_axes = None
        if is_3d:
            self.axes = fig.add_subplot(111, projection='3d') # 移除 facecolor
            self.axes.azim = -70
            self.axes.elev = 35
            self.default_azim = self.axes.azim
            self.default_elev = self.axes.elev
            self.cbar_position_rect = [0.80, 0.25, 0.03, 0.50]
            fig.subplots_adjust(left=0.0, right=0.75, bottom=0.0, top=1.0)
        else:
            self.axes = fig.add_subplot(111) # 移除 facecolor
            fig.tight_layout(pad=3.0)
        
        # 默认设置为深色主题
        self.set_theme('dark') 
        
        super().__init__(fig)

    def set_theme(self, theme_name):
        """为画布设置深色或玻璃主题。"""
        if theme_name == 'glass':
            fig_color = 'none' # 透明
            ax_color = 'none'  # 透明
            tick_color = 'white' # 刻度设为白色
        elif theme_name == 'light':
            fig_color = '#EDEDED'
            ax_color = '#F7F7F7'
            tick_color = '#1A1A1A'
        else: # 默认 'dark'
            fig_color = '#2E2E2E'
            ax_color = '#2E2E2E'
            tick_color = 'white'
            
        try:
            self.figure.set_facecolor(fig_color)
            self.axes.set_facecolor(ax_color)
            
            # 更新刻度和标签颜色
            self.axes.tick_params(colors=tick_color, labelcolor=tick_color)
            for spine in self.axes.spines.values():
                if theme_name == 'glass':
                    spine.set_color(tick_color)
                elif theme_name == 'light':
                    spine.set_color('#888888')
                else:
                    spine.set_color('#888888') # 深色主题用中性边框

            # 3D 画布有 Z 轴
            if self.is_3d:
                try:
                    self.axes.w_xaxis.line.set_color(tick_color)
                    self.axes.w_yaxis.line.set_color(tick_color)
                    self.axes.w_zaxis.line.set_color(tick_color)
                except:
                    pass
            
            # 更新已有的色条（如果存在）
            if self.colorbar_axes and hasattr(self.colorbar_axes, 'ax'):
                cbar = self.colorbar_axes.ax.figure.colorbar
                if cbar:
                    cbar.ax.yaxis.set_tick_params(color=tick_color, labelcolor=tick_color)
                    cbar.ax.spines['right'].set_color(tick_color)
                    cbar.ax.spines['left'].set_color(tick_color)
                    cbar.ax.spines['top'].set_color(tick_color)
                    cbar.ax.spines['bottom'].set_color(tick_color)

            self.draw_idle()
        except Exception as e:
            print(f"Error setting canvas theme: {e}")

    def wheelEvent(self, event):
        """把 Qt 的 wheel 事件转成程序期望的 scroll_event 调用，优先调用父窗口的 on_scroll。"""
        try:
            delta = 0
            try:
                ad = event.angleDelta()
                delta = ad.y() if hasattr(ad, 'y') else int(ad)
            except Exception:
                try:
                    delta = event.delta()
                except Exception:
                    delta = 0

            class _FakeEvent:
                pass

            fe = _FakeEvent()
            fe.inaxes = getattr(self, 'axes', None)
            fe.guiEvent = event
            fe.step = 1 if delta > 0 else -1
            # Let parent handle it if possible
            parent = self.parent()
            if parent is not None and hasattr(parent, 'on_scroll'):
                try:
                    parent.on_scroll(fe)
                    event.accept()
                    return
                except Exception:
                    pass
        except Exception:
            pass
        # fallback to default
        super().wheelEvent(event)

class _ViewshedWorker(QObject):
    """
    在后台线程中计算视域分析
    """
    finished = pyqtSignal(object)  # (visibility_grid)
    progress = pyqtSignal(int)
    error = pyqtSignal(str)

    def __init__(self, obs_pos, grid_x, grid_y, grid_z, spacing, parent=None):
        super().__init__(parent)
        self.obs_x, self.obs_y, self.obs_z = obs_pos
        self.grid_x = grid_x
        self.grid_y = grid_y
        self.grid_z = grid_z
        self.spacing = max(spacing, 1e-6) # 避免除零
        self._cancel = False

    def cancel(self):
        self._cancel = True

    @pyqtSlot()
    def run(self):
        try:
            ny, nx = self.grid_z.shape
            visibility_grid = np.zeros((ny, nx), dtype=bool)
            
            # 找到观察者在格网中的索引
            obs_ix = np.clip(np.round((self.obs_x - self.grid_x[0]) / self.spacing), 0, nx - 1).astype(int)
            obs_iy = np.clip(np.round((self.obs_y - self.grid_y[0]) / self.spacing), 0, ny - 1).astype(int)
            
            # 遍历所有目标单元格
            for iy in range(ny):
                if self._cancel:
                    self.error.emit('cancelled')
                    return
                    
                for ix in range(nx):
                    if ix == obs_ix and iy == obs_iy:
                        visibility_grid[iy, ix] = True # 观察点自身总是可见的
                        continue
                    
                    target_x = self.grid_x[ix]
                    target_y = self.grid_y[iy]
                    target_z = self.grid_z[iy, ix]
                    
                    if np.isnan(target_z):
                        visibility_grid[iy, ix] = False
                        continue
                        
                    # 检查视线
                    is_visible = self.check_line_of_sight(target_x, target_y, target_z)
                    visibility_grid[iy, ix] = is_visible
                
                # 更新进度
                pct = int(100 * (iy + 1) / ny)
                self.progress.emit(pct)
                
            self.finished.emit(visibility_grid)
            
        except Exception as e:
            self.error.emit(str(e))

    def check_line_of_sight(self, target_x, target_y, target_z):
        """
        检查从 (obs_pos) 到 (target_pos) 的视线是否被地形阻挡
        """
        # 1. 计算视线向量
        dx = target_x - self.obs_x
        dy = target_y - self.obs_y
        dz = target_z - self.obs_z
        
        # 2. 确定采样步数 (基于最长的 X 或 Y 轴格网距离)
        num_steps = int(max(abs(dx), abs(dy)) / self.spacing) + 2
        
        # 3. 沿 2D 视线生成采样点 (不包括起点和终点)
        t = np.linspace(0, 1, num_steps)[1:-1] # 截取中间点
        
        if t.size == 0:
            return True # 两个点是相邻的，没有中间点
            
        x_line = self.obs_x + dx * t
        y_line = self.obs_y + dy * t
        
        # 4. 计算这些点上的“视线高度”
        z_line_of_sight = self.obs_z + dz * t
        
        # 5. 计算这些点下方的“地形高度”
        
        # 将采样点的真实坐标转换为格网索引
        x_indices = np.clip(np.round((x_line - self.grid_x[0]) / self.spacing), 0, len(self.grid_x) - 1).astype(int)
        y_indices = np.clip(np.round((y_line - self.grid_y[0]) / self.spacing), 0, len(self.grid_y) - 1).astype(int)
        
        # 从格网中提取地形高度
        terrain_z_under_line = self.grid_z[y_indices, x_indices]
        
        # 6. 检查遮挡
        # 检查是否有任何地形高度 (terrain_z) 高于视线高度 (z_line_of_sight)
        # 增加一个小的容差 (e.g., 0.1m) 以避免浮点错误
        obstruction = terrain_z_under_line > (z_line_of_sight + 0.1)
        
        if np.any(obstruction):
            return False # 被遮挡
        else:
            return True # 可见

# -------------------- 断面对话框 --------------------
class ProfileDialog(QDialog):
    def __init__(self, distances, elevations, parent=None):
        super().__init__(parent)
        self.setWindowTitle("断面分析结果")
        self.setGeometry(200, 200, 800, 520)
        layout = QVBoxLayout(self)
        self.canvas = MplCanvas(self)
        layout.addWidget(self.canvas)
        self.plot(distances, elevations)

    def plot(self, distances, elevations):
        self.canvas.axes.clear()
        self.canvas.axes.plot(distances, elevations, color='#00AEEF')
        self.canvas.axes.fill_between(distances, elevations, elevations.min(), color='#00AEEF', alpha=0.3)
        self.canvas.axes.set_title("地形断面图", color='white')
        self.canvas.axes.set_xlabel("距离 (m)", color='white')
        self.canvas.axes.set_ylabel("高程 (m)", color='white')
        self.canvas.axes.grid(True, linestyle='--', alpha=0.5)
        self.canvas.draw()


class ProjectNameDialog(QDialog):
    @staticmethod
    def get_project_name(parent=None):
        dlg = QDialog(parent)
        dlg.setWindowTitle("设置项目名称")
        layout = QVBoxLayout(dlg)
        le = QLineEdit()
        le.setPlaceholderText("在此输入项目名称")
        btns = QHBoxLayout()
        ok = QPushButton("确定"); cancel = QPushButton("取消")
        btns.addWidget(ok); btns.addWidget(cancel)
        layout.addWidget(QLabel("项目名称:")); layout.addWidget(le); layout.addLayout(btns)

        def do_ok():
            dlg.accept()
        def do_cancel():
            dlg.reject()
        ok.clicked.connect(do_ok); cancel.clicked.connect(do_cancel)
        if dlg.exec_() == QDialog.Accepted:
            return le.text().strip()
        return None


class APISettingsDialog(QDialog):
    @staticmethod
    def get_settings(parent=None):
        dlg = QDialog(parent)
        dlg.setWindowTitle("设置")
        layout = QVBoxLayout(dlg)

        api_group = QGroupBox("API 设置")
        api_layout = QVBoxLayout(api_group)
        le_url = QLineEdit(os.environ.get('AI_API_URL', ''))
        le_key = QLineEdit(os.environ.get('DEEP_AI_API_KEY', ''))
        le_model = QLineEdit(os.environ.get('AI_MODEL_NAME', ''))
        api_layout.addWidget(QLabel('API URL:')); api_layout.addWidget(le_url)
        api_layout.addWidget(QLabel('API Key:')); api_layout.addWidget(le_key)
        api_layout.addWidget(QLabel('模型名称:')); api_layout.addWidget(le_model)

        ui_group = QGroupBox("UI 设置")
        ui_layout = QGridLayout(ui_group)
        theme_combo = QComboBox()
        theme_combo.addItems(["CAD 经典 (浅色)", "CAD 2024 (深色)"])
        current_theme = os.environ.get('CAD_UI_THEME', 'cad_2024')
        theme_combo.setCurrentIndex(0 if current_theme == 'cad_classic' else 1)

        le_font = QLineEdit(os.environ.get('CAD_UI_FONT', ''))
        le_font.setPlaceholderText("例如：Microsoft YaHei / SimSun / Consolas")
        ui_layout.addWidget(QLabel("CAD 主题:"), 0, 0)
        ui_layout.addWidget(theme_combo, 0, 1)
        ui_layout.addWidget(QLabel("字体偏好:"), 1, 0)
        ui_layout.addWidget(le_font, 1, 1)

        layout.addWidget(api_group)
        layout.addWidget(ui_group)

        btns = QHBoxLayout(); ok = QPushButton('确定'); cancel = QPushButton('取消')
        btns.addWidget(ok); btns.addWidget(cancel); layout.addLayout(btns)

        def do_ok(): dlg.accept()
        def do_cancel(): dlg.reject()
        ok.clicked.connect(do_ok); cancel.clicked.connect(do_cancel)
        if dlg.exec_() == QDialog.Accepted:
            theme_value = 'cad_classic' if theme_combo.currentIndex() == 0 else 'cad_2024'
            return {
                'url': le_url.text().strip(),
                'key': le_key.text().strip(),
                'model': le_model.text().strip(),
                'ui_theme': theme_value,
                'ui_font': le_font.text().strip()
            }
        return None


class ColumnMappingDialog(QDialog):
    @staticmethod
    def get_mapping(columns, parent=None):
        dlg = QDialog(parent)
        dlg.setWindowTitle('列映射')
        layout = QVBoxLayout(dlg)
        layout.addWidget(QLabel('请选择 X, Y, Z 列对应'))
        combo_x = QComboBox(); combo_y = QComboBox(); combo_z = QComboBox()
        combo_x.addItems(columns); combo_y.addItems(columns); combo_z.addItems(columns)
        layout.addWidget(QLabel('X 列:')); layout.addWidget(combo_x)
        layout.addWidget(QLabel('Y 列:')); layout.addWidget(combo_y)
        layout.addWidget(QLabel('Z 列:')); layout.addWidget(combo_z)
        btns = QHBoxLayout(); ok = QPushButton('确定'); cancel = QPushButton('取消')
        btns.addWidget(ok); btns.addWidget(cancel); layout.addLayout(btns)
        ok.clicked.connect(dlg.accept); cancel.clicked.connect(dlg.reject)
        if dlg.exec_() == QDialog.Accepted:
            return (combo_x.currentText(), combo_y.currentText(), combo_z.currentText())
        return None

    def closeEvent(self, event):
        try:
            self.canvas.figure.clf()
            plt.close(self.canvas.figure)
        except:
            pass
        super().closeEvent(event)

class MainWindow(QMainWindow):
    def __init__(self, parent=None):
        super().__init__(parent)

        # 设置窗体标题为应用名与版本
        try:
            self.setWindowTitle(f"{APP_NAME} {APP_VERSION} — {APP_NAME_CN}")
        except:
            pass

        # 数据与状态
        self.file_path = None
        self.raw_data = None
        self.data = None
        self.triangulation = None
        self.interpolator = None
        self.grid_x = None
        self.grid_y = None
        self.grid_z = None
        self.slope_data = None
        self.aspect_data = None
        self.surface_area = 0.0
        self.planar_area = 0.0
        self.profile_points = []
        self.is_profiling = False
        self.data_compare = None
        self.triangulation_compare = None
        self.interpolator_compare = None
        self.vector_layers = []
        self.is_querying = False
        self.is_adding_point = False
        self.is_deleting_point = False
        self.show_data_points = False
        # 多段断面相关
        self.multi_profiles = []            # list of segments, each is list of (x,y)
        self.multi_profile_mode = False     # whether multi-profile drawing mode is active
        self._current_profile_segment = []  # points for current segment being drawn
        # last single-profile line (for display persistence)
        self.last_profile_line = None  # ((x1,x2),(y1,y2])
        self.stats_slope_min = 0.0
        self.stats_slope_max = 0.0
        self.stats_slope_avg = 0.0
        self.grid_spacing = 1.0
        self.current_3d_mode = "TIN_Mesh"
        self.current_analysis_mode = "TIN_Contour"

        # 2D 画布中键平移状态
        self._canvas2d_pan = {'active': False, 'xpix0': None, 'ypix0': None, 'orig_xlim': None, 'orig_ylim': None}

        # 新增：项目名称（由用户在导出前设置）
        self.project_name = None
        self.last_volume_results = None

        # --- 新增：视域分析 (Viewshed) ---
        self.is_setting_viewshed = False
        self.viewshed_obs_height = 1.8 # 默认观察高度 (m)
        self.viewshed_data = None      # 存储 (bool) 可视性格网
        self.viewshed_observer_pos = None # 存储 (x, y) 观察点
        # --- 结束新增 ---
        
        # --- 新增：通视分析 (Line-of-Sight) ---
        self.is_checking_los = False       # 是否处于通视分析模式
        self.los_points = []             # 存储点击的 [p1, p2]
        self.last_los_result = None      # 存储 (p1, p2, is_visible)
        self.los_obs_height = 1.8      # 观察点高度
        self.los_tgt_height = 1.8      # 目标点高度

        # --- 新增：主题和背景管理 ---
        self.current_theme = 'dark' # 'dark' 或 'glass'
        self.ui_theme = os.environ.get('CAD_UI_THEME', 'cad_2024')
        self.ui_font = os.environ.get('CAD_UI_FONT', '')
        self.background_files = []
        self.current_background_index = 0
        self._load_background_file_list() # 启动时加载文件列表
        
        # 定义新的玻璃样式表 (CSS)
        self.GLASS_STYLESHEET = """
            /* 主窗口 - 应用背景图 */
            QMainWindow {
                border-image: url(%s); 
                background-origin: content;
            }
            /* 所有透明背景的 QWidget */
            QWidget, QScrollArea {
                background-color: transparent;
                color: #F0F0F0;
                font-family: 'Segoe UI', 'SimHei';
                font-size: 10pt;
            }
            /* 半透明卡片样式 */
            QGroupBox, QScrollArea > QWidget { /* QScrollArea > QWidget 针对顶部工具栏 */
                background-color: rgba(30, 30, 40, 0.7); /* 液态玻璃深色底 */
                border: 1px solid rgba(255, 255, 255, 0.3);
                border-radius: 10px;
                margin-top: 16px;
                backdrop-filter: blur(10px);
            }
            QGroupBox::title {
                subcontrol-origin: margin;
                subcontrol-position: top center;
                padding: 3px 8px;
                margin-top: 4px;
                background-color: transparent;
                color: white;
            }
            /* 半透明控件 */
            QPushButton {
                background-color: rgba(85, 85, 85, 0.8);
                color: #FFFFFF;
                border: 1px solid rgba(255, 255, 255, 0.4);
                border-radius: 4px;
                padding: 6px 10px;
            }
            QPushButton:hover { background-color: rgba(100, 100, 100, 0.9); }
            QPushButton:pressed { background-color: rgba(76, 175, 80, 0.9); }
            
            QLineEdit, QComboBox, QTextEdit {
                background-color: rgba(60, 60, 60, 0.7);
                border: 1px solid rgba(255, 255, 255, 0.4);
                border-radius: 3px;
                padding: 4px;
                color: #E0E0E0;
            }
            /* 分割线 */
            QSplitter::handle { 
                background-color: rgba(74, 74, 74, 0.5); 
                height: 4px; /* 使其更像一条线 */
            }
            QSplitter::handle:hover { background-color: rgba(100, 100, 100, 0.8); }
            /* 标签 */
            QLabel {
                background-color: transparent;
                color: #F0F0F0;
            }
        """

        self.initUI()
        self.apply_ui_preferences(persist=False)
        self.update_ui_state(enabled=False)
    # ...existing code...

    def initUI(self):
        main_widget = QWidget()
        self.setCentralWidget(main_widget)
        main_layout = QVBoxLayout(main_widget)
        main_layout.setContentsMargins(0, 0, 0, 0)

        # 顶部控制面板（横向滚动 + 自动高度）
        control_widget = self.create_control_panel_content()
        scroll_area = QScrollArea()
        scroll_area.setWidget(control_widget)
        scroll_area.setWidgetResizable(True)
        scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
        scroll_area.setFrameShape(QScrollArea.NoFrame)
        try:
            # 计算 control_widget 的推荐高度
            required_height = control_widget.sizeHint().height()
            # 增加一点缓冲区，防止意外截断
            required_height += 55
            scroll_area.setFixedHeight(required_height)
        except Exception as e:
            print(f"Warning: Could not set fixed height for scroll area: {e}")
            # Fallback: 如果计算失败，恢复之前的策略
            scroll_area.setSizeAdjustPolicy(QScrollArea.AdjustToContents)
            scroll_area.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
        main_layout.addWidget(scroll_area)

        # 下部：2D / 3D 可拖拽
        plots_splitter = QSplitter(Qt.Horizontal)
        main_layout.addWidget(plots_splitter, stretch=1)

        # 2D 区域（方案三）
        plot_2d_widget = QWidget()
        plot_2d_layout = QVBoxLayout(plot_2d_widget)
        plot_2d_layout.setContentsMargins(5, 5, 5, 5)
        plot_2d_layout.setSpacing(6)
        label_2d = QLabel("2D 模型区域")
        self.label_2d = label_2d
        self._apply_section_label_style(label_2d)
        plot_2d_layout.addWidget(label_2d)
        self.canvas_2d = MplCanvas(self)
        plot_2d_layout.addWidget(self.canvas_2d, stretch=1)
        self.btn_popout_2d = QPushButton("2D 独立查看器")
        plot_2d_layout.addWidget(self.btn_popout_2d)
        plot_2d_layout.setStretch(0, 0)
        plot_2d_layout.setStretch(1, 1)
        plot_2d_layout.setStretch(2, 0)
        plots_splitter.addWidget(plot_2d_widget)

        # 3D 区域（方案三）
        plot_3d_widget = QWidget()
        plot_3d_layout = QVBoxLayout(plot_3d_widget)
        plot_3d_layout.setContentsMargins(5, 5, 5, 5)
        plot_3d_layout.setSpacing(6)
        label_3d = QLabel("3D 模型区域")
        self.label_3d = label_3d
        self._apply_section_label_style(label_3d)
        plot_3d_layout.addWidget(label_3d)

        # --- MODIFICATION START: Overlay Reset Button ---
        # 1. Create a container widget that will hold both the canvas and the button
        canvas_3d_container = QWidget()
        # 2. Use a layout that allows placing widgets on top of each other, like QGridLayout
        container_layout = QGridLayout(canvas_3d_container)
        container_layout.setContentsMargins(0, 0, 0, 0)

        # 3. Add the canvas to the layout, occupying the entire cell (0,0)
        self.canvas_3d = MplCanvas(self, is_3d=True)
        container_layout.addWidget(self.canvas_3d, 0, 0)

        # 4. Create the reset button (moved from create_control_panel_content)
        self.btn_reset_view = QPushButton("复位")
        # --- MODIFICATION: Set button size as requested by user ---
        self.btn_reset_view.setFixedSize(80, 50) # Give it a specific size
        self.btn_reset_view.setStyleSheet("margin: 4px;") # Add a small margin from the corner

        # 5. Add the button to the same cell (0,0), but align it to the top-right corner
        container_layout.addWidget(self.btn_reset_view, 0, 0, Qt.AlignTop | Qt.AlignRight)

        # 6. Add the container to the main 3D layout instead of the canvas directly
        plot_3d_layout.addWidget(canvas_3d_container, stretch=1)
        # --- MODIFICATION END ---

        self.btn_popout_3d = QPushButton("3D 独立查看器")
        plot_3d_layout.addWidget(self.btn_popout_3d)
        plot_3d_layout.setStretch(0, 0)
        plot_3d_layout.setStretch(1, 1)
        plot_3d_layout.setStretch(2, 0)
        plots_splitter.addWidget(plot_3d_widget)

        plots_splitter.setSizes([900, 900])
        self.showMaximized()

        # 连接信号
        self.connect_signals()
        self._apply_cad_icons()

    def create_control_panel_content(self):
        panel = QWidget()
        layout = QHBoxLayout(panel)
        layout.setSpacing(20) # 调整回稍小的间距
        layout.setContentsMargins(12, 10, 12, 10)
        layout.setAlignment(Qt.AlignTop)

        # -------------------- 1. 文件操作 --------------------
        file_group = QGroupBox("文件操作")
        file_layout = QVBoxLayout()
        self.btn_load = QPushButton("加载数据文件") # Simplified text
        self.btn_clear = QPushButton("清除显示")
        self.btn_process_rtk = QPushButton("RTK 转换加载") # Simplified text
        self.btn_load_compare = QPushButton("加载对比 DTM") # Simplified text
        self.btn_load_vector = QPushButton("加载矢量图层") # Simplified text
        self.lbl_file = QLabel("未加载文件")
        # Icons will be applied with CAD style after all buttons are created.
        file_layout.addWidget(self.btn_load)
        file_layout.addWidget(self.btn_clear)
        file_layout.addWidget(self.btn_process_rtk)
        file_layout.addWidget(self.btn_load_compare)
        file_layout.addWidget(self.btn_load_vector)
        file_layout.addWidget(self.lbl_file)
        file_group.setLayout(file_layout)

        # -------------------- 2. 数据控制 --------------------
        data_control_group = QGroupBox("数据控制")
        data_control_layout = QVBoxLayout()
        # Z 过滤
        z_filter_group = QGroupBox("Z 过滤")
        z_filter_layout = QGridLayout()
        self.line_min_z = QLineEdit(); self.line_max_z = QLineEdit()
        validator = QDoubleValidator(); self.line_min_z.setValidator(validator); self.line_max_z.setValidator(validator)
        self.btn_apply_z_filter = QPushButton("应用过滤"); self.btn_reset_z_filter = QPushButton("重置")
        z_filter_layout.addWidget(QLabel("Min Z:"), 0, 0); z_filter_layout.addWidget(self.line_min_z, 0, 1)
        z_filter_layout.addWidget(QLabel("Max Z:"), 1, 0); z_filter_layout.addWidget(self.line_max_z, 1, 1)
        z_filter_btn_h = QHBoxLayout(); z_filter_btn_h.addWidget(self.btn_reset_z_filter); z_filter_btn_h.addWidget(self.btn_apply_z_filter)
        z_filter_layout.addLayout(z_filter_btn_h, 2, 0, 1, 2)
        z_filter_group.setLayout(z_filter_layout)
        data_control_layout.addWidget(z_filter_group)
        # 数据编辑
        self.btn_add_point = QPushButton("添加数据点"); self.btn_add_point.setCheckable(True)
        self.btn_delete_point = QPushButton("删除数据点"); self.btn_delete_point.setCheckable(True)
        data_control_layout.addWidget(self.btn_add_point)
        data_control_layout.addWidget(self.btn_delete_point)
        data_control_group.setLayout(data_control_layout)


        # -------------------- 3. 渲染设置 --------------------
        display_group = QGroupBox("模型渲染设置")
        display_layout = QVBoxLayout()
        self.combo_3d_mode = QComboBox(); self.combo_3d_mode.addItems(["TIN Mesh (原始网格)", "Smoothed Grid (平滑曲面)"])
        self.combo_colormap = QComboBox(); self.colormaps = ['terrain', 'plasma', 'inferno', 'magma', 'viridis', 'coolwarm', 'hsv']; self.combo_colormap.addItems(self.colormaps)
        grid_h = QHBoxLayout(); self.line_grid_spacing = QLineEdit("1.0"); self.line_grid_spacing.setValidator(QDoubleValidator(0.1, 1000.0, 2))
        grid_h.addWidget(QLabel("格网间距(m):")); grid_h.addWidget(self.line_grid_spacing)
        display_layout.addWidget(QLabel("3D 渲染:")); display_layout.addWidget(self.combo_3d_mode)
        display_layout.addWidget(QLabel("配色方案:")); display_layout.addWidget(self.combo_colormap)
        display_layout.addLayout(grid_h)
        self.btn_toggle_points = QPushButton("显示数据点"); self.btn_toggle_points.setCheckable(True); self.btn_toggle_points.setChecked(self.show_data_points)
        display_layout.addWidget(self.btn_toggle_points)
        display_group.setLayout(display_layout)

        # -------------------- 4. 分析设置 (简化) --------------------
        analysis_group = QGroupBox("分析设置") # 标题简化
        analysis_layout = QVBoxLayout()
        # 2D 模式选择
        analysis_layout.addWidget(QLabel("2D 显示模式:"))
        self.combo_2d_mode = QComboBox()
        self.combo_2d_mode.addItems(["等高线图 (Contour)", "坡度图 (Slope)", "坡向图 (Aspect)",
                                     "差值图 (Difference Map)", "视域分析 (Viewshed)"])
        analysis_layout.addWidget(self.combo_2d_mode)
        # 等高线设置
        contour_group = QGroupBox("等高线设置")
        cont_layout = QGridLayout()
        self.line_major_interval = QLineEdit("5.0"); self.line_minor_interval = QLineEdit("1.0"); self.line_base_elevation = QLineEdit("0.0")
        validator_cont = QDoubleValidator(0.01, 10000.0, 2); validator_base = QDoubleValidator(-10000.0, 10000.0, 2)
        self.line_major_interval.setValidator(validator_cont); self.line_minor_interval.setValidator(validator_cont); self.line_base_elevation.setValidator(validator_base)
        cont_layout.addWidget(QLabel("主线:"), 0, 0); cont_layout.addWidget(self.line_major_interval, 0, 1)
        cont_layout.addWidget(QLabel("次线:"), 1, 0); cont_layout.addWidget(self.line_minor_interval, 1, 1)
        cont_layout.addWidget(QLabel("基准高程:"), 2, 0); cont_layout.addWidget(self.line_base_elevation, 2, 1)
        contour_group.setLayout(cont_layout)
        analysis_layout.addWidget(contour_group)
        # --- 定量分析和土方量按钮已移出 ---
        analysis_group.setLayout(analysis_layout)

        # -------------------- 5. 定量分析 (恢复独立) --------------------
        terrain_stats_group = QGroupBox("地形定量分析")
        terrain_stats_layout = QVBoxLayout()
        self.lbl_area_planar = QLabel("平面面积：-- m²")
        self.lbl_area_surface = QLabel("表面面积：-- m²")
        self.lbl_z_range = QLabel("高程范围：-- ~ -- m")
        self.lbl_slope_range = QLabel("坡度范围：--° ~ --°")
        self.lbl_slope_avg = QLabel("平均坡度：--°")
        for lbl in [self.lbl_area_planar, self.lbl_area_surface, self.lbl_z_range, self.lbl_slope_range, self.lbl_slope_avg]:
            lbl.setStyleSheet("color: #DDDDDD; font-size: 10.5pt; padding: 2px;")
            terrain_stats_layout.addWidget(lbl)
        self.btn_update_stats = QPushButton("刷新定量分析")
        self.btn_update_stats.setToolTip("根据当前数据重新计算地形指标")
        terrain_stats_layout.addWidget(self.btn_update_stats)
        self.btn_calc_volume = QPushButton("土方量计算")
        self.btn_calc_volume.setToolTip("基于当前格网与基准面或对比DTM计算挖填方")
        terrain_stats_layout.addWidget(self.btn_calc_volume)
        terrain_stats_group.setLayout(terrain_stats_layout)

        # -------------------- 6. 交互工具 --------------------
        interactive_group = QGroupBox("交互工具")
        interactive_layout = QVBoxLayout()
        self.btn_profile = QPushButton("启用断面分析"); self.btn_multi_profile = QPushButton("多段断面模式")
        self.btn_run_viewshed = QPushButton("运行视域分析"); self.btn_run_viewshed.setCheckable(True)
        self.btn_check_los = QPushButton("两点通视分析"); self.btn_check_los.setCheckable(True)
        self.btn_query_tool = QPushButton("属性查询"); self.btn_query_tool.setCheckable(True)
        interactive_layout.addWidget(self.btn_profile); interactive_layout.addWidget(self.btn_multi_profile)
        interactive_layout.addWidget(self.btn_run_viewshed); interactive_layout.addWidget(self.btn_check_los)
        interactive_layout.addWidget(self.btn_query_tool)
        interactive_group.setLayout(interactive_layout)

        # -------------------- 7. 测量与GIS工具 --------------------
        tools_group = QGroupBox("测量与GIS工具")
        tools_layout = QVBoxLayout()
        self.btn_tool_coord = QPushButton("坐标转换"); self.btn_tool_distance = QPushButton("距离计算")
        self.btn_tool_intersect = QPushButton("前方交会"); self.btn_tool_mapnum = QPushButton("地形图编号")
        self.btn_tool_leveling = QPushButton("水准闭合差")
        tools_layout.addWidget(self.btn_tool_coord); tools_layout.addWidget(self.btn_tool_distance)
        tools_layout.addWidget(self.btn_tool_intersect); tools_layout.addWidget(self.btn_tool_mapnum)
        tools_layout.addWidget(self.btn_tool_leveling)
        self.btn_zonal_stats = QPushButton("分区统计 (Zonal Stats)")
        tools_layout.addWidget(self.btn_zonal_stats)
        tools_group.setLayout(tools_layout)

        # -------------------- 8. 导出与设置 --------------------
        export_settings_group = QGroupBox("导出与设置")
        export_settings_layout = QGridLayout()
        self.btn_export_2d = QPushButton("导出 2D 图像"); self.btn_export_3d = QPushButton("导出 3D 图像")
        self.btn_export_grid = QPushButton("导出 DGM 格网"); self.btn_export_report = QPushButton("导出报告 (.docx)")
        self.btn_export_profiles = QPushButton("导出断面汇总")
        self.btn_set_api = QPushButton("设置 (API/界面)"); self.btn_set_project = QPushButton("项目名称")
        self.btn_toggle_theme = QPushButton("切换主题 (Glass)")
        # 布局
        export_settings_layout.addWidget(self.btn_export_2d, 0, 0); export_settings_layout.addWidget(self.btn_set_api, 0, 1)
        export_settings_layout.addWidget(self.btn_export_3d, 1, 0); export_settings_layout.addWidget(self.btn_set_project, 1, 1)
        export_settings_layout.addWidget(self.btn_export_grid, 2, 0); export_settings_layout.addWidget(self.btn_toggle_theme, 2, 1)
        export_settings_layout.addWidget(self.btn_export_profiles, 3, 0)
        export_settings_layout.addWidget(self.btn_export_report, 4, 0)
        self.btn_export_modified_data = QPushButton("导出修改后数据 (.csv)")
        export_settings_layout.addWidget(self.btn_export_modified_data, 5, 0)
        export_settings_group.setLayout(export_settings_layout)

        # -------------------- 添加所有 GroupBox 到主布局 --------------------
        groups_list = [
            file_group,
            data_control_group,
            display_group,
            analysis_group, # 简化后的分析设置
            terrain_stats_group, # 恢复的定量分析
            interactive_group,
            tools_group,
            export_settings_group
        ]
        min_width = 220 # 统一最小宽度
        for g in groups_list:
            g.setMinimumWidth(min_width)
            layout.addWidget(g)

        layout.addStretch()

        # 根据新的组数和间距调整面板最小宽度
        panel_min_width = sum(min_width for g in groups_list) + \
                          (len(groups_list) - 1) * layout.spacing() + \
                          layout.contentsMargins().left() + layout.contentsMargins().right()
        panel.setMinimumWidth(panel_min_width)
        return panel


    def connect_signals(self):
        # 文件与过滤
        self.btn_load.clicked.connect(self.load_data)
        self.btn_clear.clicked.connect(self.clear_display)
        self.btn_apply_z_filter.clicked.connect(self.apply_z_filter)
        self.btn_reset_z_filter.clicked.connect(self.reset_z_filter)

        # 显示与分析
        self.combo_3d_mode.currentTextChanged.connect(self.on_3d_mode_changed)
        self.combo_2d_mode.currentTextChanged.connect(self.on_2d_mode_changed)
        self.combo_colormap.currentTextChanged.connect(self.on_colormap_changed)
        self.line_grid_spacing.editingFinished.connect(self.on_grid_spacing_changed)
        self.btn_toggle_points.clicked.connect(self.toggle_data_points_visibility)
        self.line_major_interval.editingFinished.connect(self.recalculate_contours)
        self.line_minor_interval.editingFinished.connect(self.recalculate_contours)
        self.line_base_elevation.editingFinished.connect(self.recalculate_contours)

        # 弹窗查看器
        self.btn_popout_2d.clicked.connect(lambda: self.popout_viewer(self.canvas_2d.figure, "2D 独立查看器"))
        self.btn_popout_3d.clicked.connect(lambda: self.popout_viewer(self.canvas_3d.figure, "3D 独立查看器"))

        # RTK 转换并加载
        try:
            self.btn_process_rtk.clicked.connect(self.process_rtk_and_load)
        except Exception:
            pass

        try:
            self.btn_load_compare.clicked.connect(self.load_comparison_data)
        except Exception:
            pass

        try:
            self.btn_load_vector.clicked.connect(self.load_vector_layer)
        except Exception:
            pass

        # 鼠标滚轮缩放（2D / 3D）
        try:
            self.canvas_2d.mpl_connect('scroll_event', self.on_scroll)
            self.canvas_3d.mpl_connect('scroll_event', self.on_scroll)
        except Exception:
            pass

        # 交互
        self.canvas_2d.mpl_connect('button_press_event', self.on_map_click)
        # 主界面 2D 中键平移支持
        try:
            self.canvas_2d.mpl_connect('button_press_event', self.on_canvas2d_button_press)
            self.canvas_2d.mpl_connect('button_release_event', self.on_canvas2d_button_release)
            self.canvas_2d.mpl_connect('motion_notify_event', self.on_canvas2d_motion)
        except Exception:
            pass
        self.btn_profile.clicked.connect(self.toggle_profiling_mode)

        # 多段断面信号
        try:
            self.btn_multi_profile.clicked.connect(self.toggle_multi_profile_mode)
            self.btn_export_profiles.clicked.connect(self.export_profiles)
        except Exception:
            pass

        # 连接交互式工具按钮
        try:
            self.btn_query_tool.clicked.connect(self.toggle_query_mode)
            self.btn_add_point.clicked.connect(self.toggle_add_point_mode)
            self.btn_delete_point.clicked.connect(self.toggle_delete_point_mode)
            self.btn_run_viewshed.clicked.connect(self.toggle_viewshed_mode)
            self.btn_check_los.clicked.connect(self.toggle_los_mode)
        except Exception as e:
            print(f"Error connecting interactive tools: {e}")
        
        try:
            self.btn_toggle_theme.clicked.connect(self._toggle_theme)
        except Exception as e:
            print(f"Error connecting theme toggle: {e}")

        # 导出
        self.btn_export_2d.clicked.connect(lambda: self.export_plot(self.canvas_2d))
        self.btn_export_3d.clicked.connect(lambda: self.export_plot(self.canvas_3d))
        self.btn_export_grid.clicked.connect(self.export_esri_grid)
        self.btn_export_report.clicked.connect(self.export_report)
        self.btn_export_modified_data.clicked.connect(self.export_modified_data)

        # --- MODIFICATION: Connect Reset Button, Remove Others ---
        # The reset button is now created in initUI and connected here
        self.btn_reset_view.clicked.connect(self.reset_3d_view)
        # Connections for rotate buttons are removed as the buttons are gone

        # 定量分析刷新
        try:
            self.btn_update_stats.clicked.connect(self.update_terrain_stats)
        except Exception:
            pass

        # --- NEW --- 连接土方量计算按钮
        try:
            self.btn_calc_volume.clicked.connect(self.calculate_volume)
        except Exception:
            pass
        # --- END NEW ---

        # 新增信号连接
        self.btn_set_api.clicked.connect(self.set_api_settings)
        self.btn_set_project.clicked.connect(self.set_project_name)

        # =======================================================
        # 新增：工具按钮信号
        # =======================================================
        try:
            self.btn_tool_coord.clicked.connect(self.open_coord_tool)
            self.btn_tool_distance.clicked.connect(self.open_distance_tool)
            self.btn_tool_intersect.clicked.connect(self.open_intersect_tool)
            self.btn_tool_mapnum.clicked.connect(self.open_mapnum_tool)
            self.btn_tool_leveling.clicked.connect(self.open_leveling_tool)
            self.btn_zonal_stats.clicked.connect(self.run_zonal_statistics)
        except Exception as e:
            print(f"Error connecting tool signals: {e}") # for debugging


    # ------------------ 运行时设置方法 ------------------
    def set_api_settings(self):
        """弹窗设置 API 地址/Key/模型，运行期保存到环境变量并保存在实例中"""
        settings = APISettingsDialog.get_settings(self)
        if settings:
            if settings.get('url'):
                os.environ["AI_API_URL"] = settings['url']
                self.api_url = settings['url']
            if settings.get('key'):
                os.environ["DEEP_AI_API_KEY"] = settings['key']
                self.api_key = settings['key']
            if settings.get('model'):
                os.environ["AI_MODEL_NAME"] = settings['model']
                self.api_model = settings['model']
            ui_theme = settings.get('ui_theme')
            ui_font = settings.get('ui_font')
            if ui_theme is not None or ui_font is not None:
                self.apply_ui_preferences(ui_theme, ui_font)

            QMessageBox.information(self, "设置成功", "设置已更新（仅当前运行有效）。")

    def set_project_name(self):
        """弹窗填写项目名称并保存到实例（供导出使用）"""
        name = ProjectNameDialog.get_project_name(self)
        if name:
            self.project_name = name
            QMessageBox.information(self, "设置成功", f"项目名称已设置为：{name}")

    def export_report(self):
        """
        导出综合报告 (超详细版)：包含所有数据、图表和分析。
        """
        if self.data is None:
            QMessageBox.warning(self, "请先加载数据", "请先加载并分析数据后再导出报告。")
            return

        # 1. 准备项目名称和文件路径
        if not getattr(self, 'project_name', None):
            name = ProjectNameDialog.get_project_name(self)
            if not name: return
            self.project_name = name

        default_name = f"{self.project_name}_综合地形分析报告_{datetime.now().strftime('%Y-%m-%d')}.docx"
        fp, _ = QFileDialog.getSaveFileName(self, "导出综合报告", default_name, "Word 文件 (*.docx)")
        if not fp: return

        QApplication.setOverrideCursor(Qt.WaitCursor)
        try:
            doc = Document()
            doc.styles['Normal'].font.name = 'SimHei' # 宋体或黑体
            doc.styles['Normal'].font.size = Pt(10.5)

            # --- 页眉 ---
            section = doc.sections[0]; header = section.header; header_para = header.paragraphs[0]
            header_para.text = f"{self.project_name}    导出日期: {datetime.now().strftime('%Y-%m-%d')}"
            header_para.alignment = WD_ALIGN_PARAGRAPH.RIGHT
            try: run = header_para.runs[0]; run.font.name = 'SimHei'; run.font.size = Pt(9); run.font.color.rgb = RGBColor(89, 89, 89)
            except: pass

            doc.add_heading(f'{self.project_name} - 综合地形分析报告', 0).alignment = WD_ALIGN_PARAGRAPH.CENTER

            # --- Section 1: 数据摘要 ---
            doc.add_heading('1. 数据摘要', level=1)
            p = doc.add_paragraph()
            p.add_run('数据来源: ').bold = True
            p.add_run(f"{self.file_path or '（内存数据）'}\n")
            p.add_run('原始点数: ').bold = True
            p.add_run(f"{len(self.raw_data) if self.raw_data is not None else 'N/A'}\t")
            p.add_run('有效点数 (过滤后): ').bold = True
            p.add_run(f"{len(self.data)}\n")
            
            x=self.data['X']; y=self.data['Y']
            p.add_run('坐标范围 (X): ').bold = True
            p.add_run(f"[{x.min():.3f}, {x.max():.3f}] m\t")
            p.add_run('坐标范围 (Y): ').bold = True
            p.add_run(f"[{y.min():.3f}, {y.max():.3f}] m\n")

            if self.triangulation:
                p.add_run('TIN 三角面数量: ').bold = True
                p.add_run(f"{len(self.triangulation.triangles)}\n")
            
            if self.grid_z is not None:
                p.add_run('格网间距: ').bold = True
                p.add_run(f"{self.grid_spacing:.2f} m\t")
                p.add_run('格网维度 (行×列): ').bold = True
                p.add_run(f"{self.grid_z.shape[0]} × {self.grid_z.shape[1]}\n")
                
            if self.vector_layers:
                p.add_run('加载的矢量图层: ').bold = True
                p.add_run(f"{len(self.vector_layers)} 个\n")
                # 可选：列出图层名称
                # for i, gdf in enumerate(self.vector_layers):
                #     lname = getattr(gdf, 'filename', f"图层 {i+1}"); lname = os.path.basename(lname) if lname else f"图层 {i+1}"
                #     p.add_run(f"  - {lname}\n")

            # --- Section 2: 地形统计 ---
            doc.add_heading('2. 地形统计分析', level=1)
            
            # 2.1 基础指标
            doc.add_heading('2.1 基础指标', level=2)
            if self.planar_area == 0.0 or self.surface_area == 0.0: self.calculate_areas()
            p = doc.add_paragraph()
            p.add_run('平面面积: ').bold = True; p.add_run(f"{self.planar_area:,.3f} m²\n")
            p.add_run('表面面积: ').bold = True; p.add_run(f"{self.surface_area:,.3f} m²")
            
            # 2.2 高程分析
            doc.add_heading('2.2 高程分析', level=2)
            img_z_hist, z_stats = self._render_z_histogram() # 重新生成以确保最新
            if z_stats:
                table_z = doc.add_table(rows=1, cols=6); table_z.style = 'Table Grid'
                hdr = table_z.rows[0].cells
                hdr[0].text = 'Min (m)'; hdr[1].text = 'Max (m)'; hdr[2].text = 'Mean (m)'
                hdr[3].text = 'Median (m)'; hdr[4].text = 'Std Dev (m)'; hdr[5].text = 'IQR (P25-P75 m)'
                row = table_z.add_row().cells
                row[0].text=f"{z_stats['min']:.3f}"; row[1].text=f"{z_stats['max']:.3f}"; row[2].text=f"{z_stats['mean']:.3f}"
                row[3].text=f"{z_stats['median']:.3f}"; row[4].text=f"{z_stats['std']:.3f}"
                row[5].text=f"[{z_stats['p25']:.3f}, {z_stats['p75']:.3f}]"
            else: doc.add_paragraph("高程统计数据不可用。")
            if img_z_hist:
                doc.add_picture(img_z_hist, width=Inches(6.0))
            
            # 2.3 坡度分析
            doc.add_heading('2.3 坡度分析', level=2)
            img_slope_hist, slope_stats = self._render_slope_histogram() # 重新生成
            if slope_stats:
                doc.add_paragraph(f"加权平均坡度: {slope_stats.get('avg', 'N/A')}")
                table_s = doc.add_table(rows=1, cols=len(slope_stats)-1); table_s.style = 'Table Grid'
                hdr = table_s.rows[0].cells; i = 0
                keys = [k for k in slope_stats if k != 'avg']
                for k in keys: hdr[i].text = k; i += 1
                row = table_s.add_row().cells; i = 0
                for k in keys: row[i].text = slope_stats[k]; i += 1
            else: doc.add_paragraph("坡度统计数据不可用。")
            if img_slope_hist:
                doc.add_picture(img_slope_hist, width=Inches(6.0))
                
            # 2.4 坡向分析
            doc.add_heading('2.4 坡向分析', level=2)
            img_aspect_hist, aspect_stats = self._render_aspect_histogram() # 重新生成
            if aspect_stats:
                table_a = doc.add_table(rows=1, cols=len(aspect_stats)); table_a.style = 'Table Grid'
                hdr = table_a.rows[0].cells; i = 0
                keys = list(aspect_stats.keys())
                for k in keys: hdr[i].text = k; i += 1
                row = table_a.add_row().cells; i = 0
                for k in keys: row[i].text = aspect_stats[k]; i += 1
            else: doc.add_paragraph("坡向统计数据不可用。")
            if img_aspect_hist:
                doc.add_picture(img_aspect_hist, width=Inches(5.0)) # 玫瑰图通常是方的

            doc.add_page_break()

            # --- Section 3: 可视化地图 ---
            doc.add_heading('3. 可视化地图', level=1)
            
            img_contour = self._render_map_image('contour')
            if img_contour: doc.add_heading('3.1 等高线图', level=2); doc.add_picture(img_contour, width=Inches(6.0))
            
            img_slope = self._render_map_image('slope')
            if img_slope: doc.add_heading('3.2 坡度图', level=2); doc.add_picture(img_slope, width=Inches(6.0))
            
            img_aspect = self._render_map_image('aspect')
            if img_aspect: doc.add_heading('3.3 坡向图', level=2); doc.add_picture(img_aspect, width=Inches(6.0))

            img_3d = self._render_3d_image()
            if img_3d: doc.add_heading('3.4 3D 模型图', level=2); doc.add_picture(img_3d, width=Inches(6.0))
            
            # --- 可选地图 ---
            doc.add_page_break()
            has_optional_maps = False
            
            if self.data_compare is not None: # 检查是否有对比数据
                img_diff = self._render_map_image('difference')
                if img_diff:
                    doc.add_heading('3.5 差值图', level=2); doc.add_picture(img_diff, width=Inches(6.0))
                    has_optional_maps = True
                    
            if self.viewshed_data is not None: # 检查是否有视域结果
                img_viewshed = self._render_map_image('viewshed')
                if img_viewshed:
                    doc.add_heading('3.6 视域分析图', level=2)
                    doc.add_paragraph(f"观察点位置: {self.viewshed_observer_pos}, 观察高度: {self.viewshed_obs_height} m")
                    doc.add_picture(img_viewshed, width=Inches(6.0))
                    has_optional_maps = True
                    
            if not has_optional_maps:
                # 如果没有可选地图，移除上一页的分页符
                p = doc.paragraphs[-1]
                if p.text == '': # 寻找由 add_page_break() 添加的空段落
                     p_element = p._element
                     p_element.getparent().remove(p_element)

            # --- Section 4: 专项分析 ---
            doc.add_heading('4. 专项分析', level=1)
            
            # 4.1 土方量
            if self.last_volume_results:
                doc.add_heading('4.1 土方量计算', level=2)
                # 使用 preformatted text style (可选，需要先定义或修改默认)
                # style = doc.styles.add_style('Preformatted', WD_STYLE_TYPE.PARAGRAPH)
                # style.font.name = 'Consolas'; style.font.size = Pt(9)
                p = doc.add_paragraph(self.last_volume_results)
                # p.style = 'Preformatted'
                
            # 4.2 通视分析
            if self.last_los_result:
                doc.add_heading('4.2 两点通视分析 (LoS)', level=2)
                p1, p2, is_visible = self.last_los_result
                p = doc.add_paragraph()
                p.add_run('观察点 (P1): ').bold = True; p.add_run(f"({p1[0]:.3f}, {p1[1]:.3f}), 高度 {self.los_obs_height:.1f} m\n")
                p.add_run('目标点 (P2): ').bold = True; p.add_run(f"({p2[0]:.3f}, {p2[1]:.3f}), 高度 {self.los_tgt_height:.1f} m\n")
                p.add_run('分析结果: ').bold = True; p.add_run(f"{'✅ 通视' if is_visible else '❌ 遮挡'}\n")
                
                img_los = self._render_los_map_image()
                if img_los: doc.add_picture(img_los, width=Inches(6.0))
                
            # 4.3 断面分析
            if self.multi_profiles:
                doc.add_heading('4.3 断面分析', level=2)
                doc.add_paragraph(f"共生成 {len(self.multi_profiles)} 条多段断面。")
                doc.add_page_break() # 断面内容较多，新起一页
                
                profile_stats_list = []
                for idx, seg in enumerate(self.multi_profiles, start=1):
                    doc.add_heading(f'断面 {idx}', level=3)
                    try:
                        img_buf, stats = self.generate_profile_for_segment(seg, num=200)
                        profile_stats_list.append(stats) # 收集统计数据
                        p = doc.add_paragraph()
                        p.add_run('长度: ').bold=True; p.add_run(f"{stats['length_m']:.2f} m | ")
                        p.add_run('最大坡度: ').bold=True; p.add_run(f"{stats['max_slope_deg']:.2f}° | ")
                        p.add_run('平均坡度: ').bold=True; p.add_run(f"{stats['avg_slope_deg']:.2f}° | ")
                        p.add_run('截面积(估): ').bold=True; p.add_run(f"{stats['area_m2']:.2f} m²")
                        
                        try: doc.add_picture(img_buf, width=Inches(6.0))
                        except Exception as pic_err: doc.add_paragraph(f"(插入断面图失败: {pic_err})")
                            
                    except Exception as seg_err:
                        doc.add_paragraph(f"(生成断面 {idx} 失败: {seg_err})")
                        profile_stats_list.append(None) # 添加占位符
                
                # 可选：在所有断面后添加一个汇总统计表 (需要额外处理)
                
            # --- Section 5: AI 结论 ---
            doc.add_heading('', level=1) # 占位符
            try:
                conclusion_text, remote_ai_used = self.generate_ai_conclusion(
                    x.min(), x.max(), y.min(), y.max(), 
                    z_stats=z_stats, slope_stats=slope_stats, aspect_stats=aspect_stats
                )
            except Exception as e: conclusion_text = f"无法生成结论: {e}"; remote_ai_used = False

            heading = doc.paragraphs[-1] # 获取占位符
            heading.text = '5. AI 自动结论' if remote_ai_used else '5. 自动结论'
            
            if remote_ai_used:
                p_disclaimer = doc.add_paragraph(); p_disclaimer.alignment = WD_ALIGN_PARAGRAPH.CENTER
                run = p_disclaimer.add_run('AI总结未必正确无误，请仔细核查'); run.font.size=Pt(9); run.font.color.rgb=RGBColor(128,128,128); run.italic=True
            
            lines = [re.sub(r'^\s*#+\s*|^\s*[-*]\s*|[`_>]+', '', line).rstrip() for line in conclusion_text.splitlines()]
            cleaned = re.sub(r'\n{3,}', '\n\n', "\n".join(lines)).strip()
            
            if cleaned:
                for paragraph in cleaned.split("\n\n"):
                    p = doc.add_paragraph(paragraph.strip()); p.paragraph_format.first_line_indent = Cm(0.8); p.paragraph_format.space_after = Cm(0.2)
            else: doc.add_paragraph("未能生成结论。")

            # --- 保存 ---
            doc.save(fp)
            QApplication.restoreOverrideCursor()
            QMessageBox.information(self, "导出完成", f"综合报告已保存: {fp}")
            
        except Exception as e:
            QApplication.restoreOverrideCursor()
            QMessageBox.critical(self, "导出失败", f"导出综合报告时发生错误:\n{e}")

    # ------------------ 清除 / 重置 ------------------
    def clear_display(self):
        """清除显示与数据"""
        try:
            self.canvas_2d.axes.clear(); self.canvas_3d.axes.clear()
            self.canvas_2d.axes.set_title("2D 模型区域 (已清空)", color='white')
            self.canvas_3d.axes.set_title("3D 模型区域 (已清空)", color='white')
            self.canvas_2d.draw(); self.canvas_3d.draw()
        except:
            pass
        self.file_path = None; self.raw_data = None; self.data = None
        self.triangulation = None; self.interpolator = None; self.grid_x = self.grid_y = self.grid_z = None
        self.slope_data = self.aspect_data = None
        self.surface_area = 0.0; self.planar_area = 0.0
        # clear drawn profiles
        self.multi_profiles = []
        self._current_profile_segment = []
        self.last_profile_line = None
        self.data_compare = None
        self.triangulation_compare = None
        self.interpolator_compare = None
        self.vector_layers = []
        self.is_querying = False
        self.is_adding_point = False
        self.is_deleting_point = False
        self.show_data_points = False
        try:
            self.btn_query_tool.setChecked(False)
            self.btn_add_point.setChecked(False)
            self.btn_delete_point.setChecked(False)
        except: pass
        self.show_data_points = False
        try:
            self.btn_toggle_points.setChecked(False)
            self.btn_toggle_points.setText("显示数据点")
        except: pass
        self.last_volume_results = None
        self.viewshed_data = None
        self.viewshed_observer_pos = None
        self.is_setting_viewshed = False
        try:
            self.btn_run_viewshed.setChecked(False)
        except: pass
        self.is_checking_los = False
        self.los_points = []
        self.last_los_result = None
        try:
            self.btn_check_los.setChecked(False)
        except: pass
        self.update_ui_state(enabled=False)
        try:
            self.lbl_file.setText("未加载文件")
        except:
            pass

    def reset_z_filter(self):
        """重置 Z 过滤，恢复 raw_data"""
        if self.raw_data is None:
            QMessageBox.warning(self, "提示", "尚未加载任何数据")
            return
        self.line_min_z.clear(); self.line_max_z.clear()
        self.data = self.raw_data.copy()
        self.triangulation = None; self.interpolator = None; self.grid_x = self.grid_y = self.grid_z = None
        self.slope_data = self.aspect_data = None; self.surface_area = 0.0; self.planar_area = 0.0
        self.update_plots()
        QMessageBox.information(self, "重置完成", "Z 过滤已重置为原始数据范围。")

    # ------------------ 加载 / 过滤 / 网格 / 计算 / 绘图 ------------------
    def load_data(self):
        path, _ = QFileDialog.getOpenFileName(self, "选择数据文件", "", "CSV (*.csv);;DAT (*.dat);;TXT (*.txt)")
        if not path:
            return
        self.file_path = path
        try:
            self.lbl_file.setText(os.path.basename(path))
        except:
            pass
        try:
            ext = path.lower().split('.')[-1]
            if ext == 'csv':
                df = pd.read_csv(path)
                if set(['X', 'Y', 'Z']).issubset(df.columns):
                    df = df[['X', 'Y', 'Z']].copy()
                else:
                    mapping = ColumnMappingDialog.get_mapping(df.columns.tolist(), self)
                    if mapping is None:
                        return
                    df = df[[mapping[0], mapping[1], mapping[2]]].rename(columns={mapping[0]:'X', mapping[1]:'Y', mapping[2]:'Z'})
            else:
                with open(path, 'r') as f:
                    lines = f.readlines()
                parsed = []
                for ln in lines:
                    ln = ln.strip()
                    if not ln or ln.startswith('#'):
                        continue
                    parts = re.split(r'[\s,]+', ln)
                    if len(parts) >= 3:
                        try:
                            x, y, z = map(float, parts[:3])
                            parsed.append((x, y, z))
                        except:
                            continue
                df = pd.DataFrame(parsed, columns=['X','Y','Z'])
            if df is None or len(df) < 3:
                raise ValueError("数据点不足，无法分析。")
            df.dropna(subset=['X','Y','Z'], inplace=True)
            df.drop_duplicates(subset=['X','Y'], inplace=True)
            self.raw_data = df.reset_index(drop=True)
            self.apply_z_filter()
            self.update_ui_state(enabled=True)
        except Exception as e:
            QMessageBox.critical(self, "加载失败", str(e))
            self.update_ui_state(enabled=False)

    # ------------------ RTK 文件处理并加载 ------------------
    def process_rtk_file(self, input_path: str, output_path: str):
        """
        简单复刻 process_xyz.py 的行为：读取文件，无表头，保留第 3/4/5 列（索引 2:5），写出为 CSV，无表头。
        """
        try:
            import pandas as _pd
            df = _pd.read_csv(input_path, header=None, encoding='utf-8', encoding_errors='ignore')
            xyz = df.iloc[:, 2:5]
            xyz.to_csv(output_path, index=False, header=False)
            return True, output_path
        except Exception as e:
            return False, str(e)

    def process_rtk_and_load(self):
        """选择 RTK 导出文件，转换并自动加载结果（临时输出到同目录，文件名 _xyz_only.dat）。"""
        path, _ = QFileDialog.getOpenFileName(self, "选择 RTK 导出文件", "", "All Files (*)")
        if not path:
            return
        in_path = path
        base = os.path.splitext(os.path.basename(in_path))[0]
        out_path = os.path.join(os.path.dirname(in_path), base + "_xyz_only.dat")
        ok, res = self.process_rtk_file(in_path, out_path)
        if not ok:
            QMessageBox.critical(self, "转换失败", f"RTK 文件转换失败：{res}")
            return
        # 成功写出，接着用 load_data_from_path 读取并加载
        try:
            self.load_data_from_path(out_path)
            QMessageBox.information(self, "完成", f"已转换并加载: {out_path}")
        except Exception as e:
            QMessageBox.critical(self, "加载失败", str(e))

    def load_data_from_path(self, path: str):
        """直接从已知路径读取 XYZ（CSV 或 空白分隔），并把数据设置到 self.data 并触发 update_plots()."""
        if not path:
            raise ValueError("路径为空")
        try:
            ext = path.lower().split('.')[-1]
            if ext in ('csv','dat','txt'):
                # 先尝试带表头的 CSV，再回退为无表头无列名的纯数值
                try:
                    df = pd.read_csv(path)
                    if set(['X','Y','Z']).issubset(df.columns):
                        df = df[['X','Y','Z']].copy()
                    else:
                        # 如果读出来有 >=3 列但无列名，尝试取前三列
                        if df.shape[1] >= 3:
                            df = df.iloc[:, :3].copy()
                            df.columns = ['X','Y','Z']
                        else:
                            raise ValueError('文件列数不足')
                except Exception:
                    # 作为回退，按任意空白或逗号分隔读取，无表头
                    with open(path, 'r', encoding='utf-8', errors='ignore') as f:
                        lines = f.readlines()
                    parsed = []
                    for ln in lines:
                        ln = ln.strip()
                        if not ln or ln.startswith('#'):
                            continue
                        parts = re.split(r'[\s,]+', ln)
                        if len(parts) >= 3:
                            try:
                                x, y, z = map(float, parts[:3])
                                parsed.append((x, y, z))
                            except:
                                continue
                    df = pd.DataFrame(parsed, columns=['X','Y','Z'])
            else:
                raise ValueError('不支持的文件类型')
            if df is None or len(df) < 3:
                raise ValueError('数据点不足')
            df.dropna(subset=['X','Y','Z'], inplace=True)
            df.drop_duplicates(subset=['X','Y'], inplace=True)
            self.file_path = path
            self.lbl_file.setText(os.path.basename(path))
            self.raw_data = df.reset_index(drop=True)
            self.apply_z_filter()
            self.update_ui_state(enabled=True)
        except Exception as e:
            raise

    def apply_z_filter(self):
        if self.raw_data is None:
            return
        try:
            min_z_text = self.line_min_z.text().strip()
            max_z_text = self.line_max_z.text().strip()
            min_z = float(min_z_text) if min_z_text else self.raw_data['Z'].min()
            max_z = float(max_z_text) if max_z_text else self.raw_data['Z'].max()
            if min_z > max_z:
                raise ValueError("Min Z 不能大于 Max Z")
            self.data = self.raw_data[(self.raw_data['Z'] >= min_z) & (self.raw_data['Z'] <= max_z)].copy()
            if len(self.data) < 3:
                raise ValueError("过滤后点数不足。")
            self.triangulation = None
            self.interpolator = None
            self.grid_x = self.grid_y = self.grid_z = None
            self.slope_data = self.aspect_data = None
            self.surface_area = self.planar_area = 0.0
            zmin, zmax = self.data['Z'].min(), self.data['Z'].max()
            zr = zmax - zmin
            if zr > 0:
                minor = max(0.1, round(zr/50,1))
                major = max(1.0, round(minor*5,1))
                base = round(zmin/minor)*minor
                self.line_minor_interval.setText(f"{minor:.1f}")
                self.line_major_interval.setText(f"{major:.1f}")
                self.line_base_elevation.setText(f"{base:.1f}")
            self.update_plots()
            # 自动刷新地形定量分析
            try:
                self.update_terrain_stats()
            except:
                pass
            QMessageBox.information(self, "过滤完成", f"有效点数：{len(self.data)}")
        except Exception as e:
            QMessageBox.warning(self, "过滤错误", str(e))

    def recalculate_contours(self):
        try:
            float(self.line_major_interval.text())
            float(self.line_minor_interval.text())
            float(self.line_base_elevation.text())
            if self.current_analysis_mode == "TIN_Contour":
                self.update_plots()
        except:
            QMessageBox.warning(self, "输入错误", "等高线参数无效。")

    def generate_grid_data(self):
        if self.interpolator is None:
            return
        try:
            spacing = float(self.line_grid_spacing.text())
        except:
            spacing = self.grid_spacing
        x = self.data['X'].values; y = self.data['Y'].values
        min_x, max_x = x.min(), x.max(); min_y, max_y = y.min(), y.max()
        self.grid_x = np.arange(min_x, max_x+spacing, spacing)
        self.grid_y = np.arange(min_y, max_y+spacing, spacing)
        Xg, Yg = np.meshgrid(self.grid_x, self.grid_y)
        vals = self.interpolator(Xg.ravel(), Yg.ravel())
        self.grid_z = vals.reshape(Xg.shape)
        QMessageBox.information(self, "完成", f"生成格网：{self.grid_z.shape}")

    def calculate_slope_aspect(self):
        x = self.data['X'].values; y = self.data['Y'].values; z = self.data['Z'].values
        triangles = self.triangulation.triangles
        p1 = np.vstack((x[triangles[:,0]], y[triangles[:,0]], z[triangles[:,0]])).T
        p2 = np.vstack((x[triangles[:,1]], y[triangles[:,1]], z[triangles[:,1]])).T
        p3 = np.vstack((x[triangles[:,2]], y[triangles[:,2]], z[triangles[:,2]])).T
        V12 = p2 - p1; V13 = p3 - p1
        A = V12[:,1]*V13[:,2] - V12[:,2]*V13[:,1]
        B = V12[:,2]*V13[:,0] - V12[:,0]*V13[:,2]
        C = V12[:,0]*V13[:,1] - V12[:,1]*V13[:,0]
        horiz = np.sqrt(A**2 + B**2)
        S_rad = np.arctan2(horiz, np.abs(C))
        self.slope_data = 90 - np.degrees(S_rad)
        angle_from_east = np.degrees(np.arctan2(-B, -A))
        aspect_deg = 90 - angle_from_east
        aspect = np.where(aspect_deg < 0, 360 + aspect_deg, aspect_deg)
        aspect = np.where(aspect >= 360, aspect - 360, aspect)
        flat_mask = self.slope_data < 0.001
        aspect[flat_mask] = -1.0
        self.aspect_data = aspect
        self.stats_slope_max = np.max(self.slope_data) if len(self.slope_data)>0 else 0.0
        self.stats_slope_min = np.min(self.slope_data) if len(self.slope_data)>0 else 0.0
        self.stats_slope_avg = np.mean(self.slope_data) if len(self.slope_data)>0 else 0.0

    def calculate_areas(self):
        x = self.data['X'].values; y = self.data['Y'].values; z = self.data['Z'].values
        triangles = self.triangulation.triangles
        p1 = np.vstack((x[triangles[:,0]], y[triangles[:,0]], z[triangles[:,0]])).T
        p2 = np.vstack((x[triangles[:,1]], y[triangles[:,1]], z[triangles[:,1]])).T
        p3 = np.vstack((x[triangles[:,2]], y[triangles[:,2]], z[triangles[:,2]])).T
        V12 = p2 - p1; V13 = p3 - p1
        cross = np.cross(V12, V13)
        areas = 0.5 * np.sqrt(np.sum(cross**2, axis=1))
        self.surface_area = np.sum(areas)
        min_x, max_x = x.min(), x.max(); min_y, max_y = y.min(), y.max()
        self.planar_area = (max_x - min_x) * (max_y - min_y)

    # --- NEW --- 土方量计算方法 (支持双曲面差分)
    def calculate_volume(self):
        """
        计算土方量。
        - 如果 "对比 DTM" 已加载，则计算两个曲面之间的差值 (新功能)。
        - 否则，基于 "平滑格网" 和用户输入的 "基准高程" 计算 (原始功能)。
        """
        
        # 1. 检查是否使用 "对比 DTM" (双曲面) 模式
        if self.data_compare is not None and self.interpolator_compare is not None:
            # --- 双曲面土方量计算 ---
            
            # a. 检查原始 DTM 和格网是否准备好
            if self.grid_z is None or self.grid_spacing <= 0:
                QMessageBox.warning(self, "操作受限",
                                    "请先在“模型渲染设置”中选择“Smoothed Grid (平滑曲面)”以生成格网数据，\n"
                                    "然后再执行双曲面土方量计算。")
                return
            
            if self.interpolator is None:
                QMessageBox.warning(self, "操作受限", "原始 DTM 插值器尚未准备好。")
                return
                
            try:
                # b. 采样两个 DTM
                # self.grid_z 已经是原始 DTM (self.interpolator) 的采样结果
                grid_z_original = self.grid_z
                
                # 在相同格网点采样 "对比 DTM"
                Xg, Yg = np.meshgrid(self.grid_x, self.grid_y)
                grid_z_compare = self.interpolator_compare(Xg, Yg)
                
                # c. 计算差值
                # 差值 = 对比曲面高程 - 原始曲面高程
                diff_grid = grid_z_compare - grid_z_original
                
                # d. 计算挖方和填方
                cell_area = self.grid_spacing ** 2
                
                # 填方 (Fill): 对比曲面 > 原始曲面 (diff > 0)
                # (即 原始地面 低于 对比地面)
                fill_diff = diff_grid[diff_grid > 0]
                fill_vol = np.nansum(fill_diff) * cell_area
                
                # 挖方 (Cut): 对比曲面 < 原始曲面 (diff < 0)
                # (即 原始地面 高于 对比地面)
                cut_diff = diff_grid[diff_grid < 0]
                cut_vol = np.abs(np.nansum(cut_diff)) * cell_area # 取绝对值

                # 净方量 (Net): 填方 - 挖方
                net_vol = fill_vol - cut_vol
                
                # e. 显示结果
                result_text = (
                    f"--- 双曲面土方量计算 ---\n"
                    f"格网间距: {self.grid_spacing:.2f} m (格网单元面积: {cell_area:.2f} m²)\n\n"
                    f"挖方 (Cut): {cut_vol:,.2f} m³\n"
                    f"  (原始地面 高于 对比地面)\n\n"
                    f"填方 (Fill): {fill_vol:,.2f} m³\n"
                    f"  (原始地面 低于 对比地面)\n\n"
                    f"----------------------------------\n"
                    f"净方量 (Net): {net_vol:,.2f} m³"
                )
                self.last_volume_results = result_text
                QMessageBox.information(self, "土方量计算结果", result_text)

            except Exception as e:
                QMessageBox.critical(self, "计算失败", f"双曲面土方量计算时发生错误: {e}")

        else:
            # --- 单曲面与基准面土方量计算 (原始功能) ---
            
            # 1. 检查格网数据是否已生成
            if self.grid_z is None or self.grid_spacing <= 0:
                QMessageBox.warning(self, "操作受限",
                                    "请先在“模型渲染设置”中选择“Smoothed Grid (平滑曲面)”以生成格网数据，\n"
                                    "然后再执行土方量计算。\n"
                                    "(如需计算双曲面差值，请先 '加载对比 DTM')")
                return

            z_min = np.nanmin(self.grid_z)
            z_max = np.nanmax(self.grid_z)

            # 2. 弹窗获取用户输入的基准高程
            base_z, ok = QInputDialog.getDouble(self, "土方量计算 (单曲面)",
                                                f"请输入基准高程 (m):\n(当前地形高程范围: {z_min:.2f} ~ {z_max:.2f})",
                                                value=(z_min + z_max) / 2.0,
                                                min=z_min - 1000.0,
                                                max=z_max + 1000.0,
                                                decimals=2)

            if not ok:
                return # 用户点击了取消

            try:
                # 3. 计算
                cell_area = self.grid_spacing ** 2

                # 计算每个格网单元的高程差
                diff_grid = self.grid_z - base_z

                # 挖方 (Cut): 地形高于基准面 (diff > 0)
                cut_diff = diff_grid[diff_grid > 0]
                cut_vol = np.nansum(cut_diff) * cell_area

                # 填方 (Fill): 地形低于基准面 (diff < 0)
                fill_diff = diff_grid[diff_grid < 0]
                fill_vol = np.abs(np.nansum(fill_diff)) * cell_area # 取绝对值

                # 净方量 (Net): 挖方 - 填方
                net_vol = cut_vol - fill_vol

                # 4. 显示结果
                result_text = (
                    f"--- 单曲面与基准面计算 ---\n"
                    f"基准高程: {base_z:.2f} m\n"
                    f"格网间距: {self.grid_spacing:.2f} m (格网单元面积: {cell_area:.2f} m²)\n\n"
                    f"挖方 (Cut): {cut_vol:,.2f} m³\n"
                    f"填方 (Fill): {fill_vol:,.2f} m³\n"
                    f"----------------------------------\n"
                    f"净方量 (Net): {net_vol:,.2f} m³"
                )
                self.last_volume_results = result_text
                QMessageBox.information(self, "土方量计算结果", result_text)

            except Exception as e:
                QMessageBox.critical(self, "计算失败", f"土方量计算时发生错误: {e}")
    # --- END 替换 ---

    def update_plots(self):
        if self.data is None or len(self.data) < 3:
            return
        x = self.data['X'].values; y = self.data['Y'].values; z = self.data['Z'].values

        def rng(vals):
            mn, mx = vals.min(), vals.max()
            r = mx - mn
            buf = r*0.1 if r>0 else 1.0
            return mn-buf, mx+buf

        if self.triangulation is None:
            # Use background thread to perform Delaunay and interpolation
            try:
                self.start_compute_worker(x, y, z)
                # show non-blocking info
                QMessageBox.information(self, "正在计算", "三角剖分与相关计算正在后台进行，完成后会自动更新界面。")
                return
            except Exception as e:
                QMessageBox.critical(self, "错误", f"启动后台计算失败: {e}")
                return

        if self.current_3d_mode == "Smoothed_Grid" and self.grid_x is None:
            self.generate_grid_data()

        # ---- 2D 绘制 ----
        self.canvas_2d.axes.clear()
        if self.canvas_2d.colorbar_axes:
            try:
                self.canvas_2d.figure.delaxes(self.canvas_2d.colorbar_axes)
                self.canvas_2d.colorbar_axes = None
            except:
                pass
        self.canvas_2d.figure.subplots_adjust(right=0.95)

        # --- MODIFICATION: Use matplotlib.colormaps ---
        cmap_name = self.combo_colormap.currentText()
        try:
            cmap = matplotlib.colormaps[cmap_name]
        except KeyError:
            cmap = plt.get_cmap(cmap_name) # Fallback for older versions or custom maps
        # --- END MODIFICATION ---

        if self.current_analysis_mode == "TIN_Contour":
            try:
                minor = float(self.line_minor_interval.text())
                major = float(self.line_major_interval.text())
                base = float(self.line_base_elevation.text())
                if minor <= 0: minor = 1.0
                if major < minor: major = minor*5
                zmin = z.min(); zmax = z.max()
                start = np.floor((zmin-base)/minor)*minor + base
                minor_lvls = np.arange(start, zmax+minor, minor)
                minor_lvls = minor_lvls[minor_lvls>=zmin]
                major_lvls = [lv for lv in minor_lvls if np.isclose((lv-base)%major, 0, atol=1e-6)]
                self.canvas_2d.axes.tricontourf(self.triangulation, z, levels=minor_lvls, cmap=cmap) # Use updated cmap
                minor_lines = self.canvas_2d.axes.tricontour(self.triangulation, z, levels=minor_lvls, colors='#CCCCCC', linewidths=0.5)
                self.canvas_2d.axes.clabel(minor_lines, inline=True, fontsize=8, fmt='%.1f')
                if len(major_lvls) > 0:
                    major_lines = self.canvas_2d.axes.tricontour(self.triangulation, z, levels=major_lvls, colors='#222222', linewidths=1.5)
                    self.canvas_2d.axes.clabel(major_lines, inline=True, fontsize=10, fmt='%.1f', colors='white')
                self.canvas_2d.axes.set_title(f"2D 等高线图 (主线 {major}m)", color='white', fontsize=12)
            except Exception:
                self.canvas_2d.axes.tricontourf(self.triangulation, z, levels=15, cmap=cmap) # Use updated cmap
                self.canvas_2d.axes.set_title("2D 等高线 (默认)", color='white')
        elif self.current_analysis_mode == "Slope":
            tri_plot = self.canvas_2d.axes.tripcolor(self.triangulation, self.slope_data, cmap=cmap, edgecolors='none') # Use updated cmap
            self.canvas_2d.colorbar_axes = self.canvas_2d.figure.add_axes([0.85, 0.15, 0.03, 0.7])
            cbar = self.canvas_2d.figure.colorbar(tri_plot, cax=self.canvas_2d.colorbar_axes)
            cbar.ax.set_ylabel('坡度 (°)', color='white')
            cbar.ax.yaxis.set_tick_params(color='white', labelcolor='white')
            self.canvas_2d.figure.subplots_adjust(right=0.78)
        elif self.current_analysis_mode == "Aspect":
            # --- MODIFICATION: Use matplotlib.colormaps for hsv ---
            try:
                cmap_hsv = matplotlib.colormaps['hsv']
            except KeyError:
                cmap_hsv = plt.get_cmap('hsv')
            # --- END MODIFICATION ---
            tri_plot = self.canvas_2d.axes.tripcolor(self.triangulation, self.aspect_data, cmap=cmap_hsv, edgecolors='none', vmin=0, vmax=360)
            self.canvas_2d.colorbar_axes = self.canvas_2d.figure.add_axes([0.85, 0.15, 0.03, 0.7])
            cbar = self.canvas_2d.figure.colorbar(tri_plot, cax=self.canvas_2d.colorbar_axes, ticks=[0,90,180,270,360])
            cbar.ax.set_yticklabels(['北','东','南','西','北'])
            cbar.ax.set_ylabel('坡向', color='white')
            self.canvas_2d.figure.subplots_adjust(right=0.75)
        
        # --- 新增：差值图逻辑 ---
        elif self.current_analysis_mode == "Difference":
            # 必须同时具有对比 DTM 和已生成的格网
            if self.data_compare is not None and self.interpolator_compare is not None and self.grid_z is not None:
                try:
                    # 计算 diff_grid (对比 - 原始)
                    grid_z_original = self.grid_z
                    Xg, Yg = np.meshgrid(self.grid_x, self.grid_y)
                    grid_z_compare = self.interpolator_compare(Xg, Yg)
                    diff_grid = grid_z_compare - grid_z_original
                    
                    # 使用 'coolwarm' (红/蓝) 发散色图
                    max_abs_diff = np.nanmax(np.abs(diff_grid))
                    if max_abs_diff == 0: max_abs_diff = 1.0
                    
                    try:
                        cmap_diff = matplotlib.colormaps['coolwarm']
                    except KeyError:
                        cmap_diff = plt.get_cmap('coolwarm')
                    
                    # 使用 imshow 绘制格网数据
                    im = self.canvas_2d.axes.imshow(diff_grid, 
                                                    extent=(self.grid_x.min(), self.grid_x.max(), self.grid_y.min(), self.grid_y.max()),
                                                    origin='lower', 
                                                    cmap=cmap_diff, 
                                                    vmin=-max_abs_diff, 
                                                    vmax=max_abs_diff,
                                                    interpolation='bilinear')
                    
                    # 添加色条
                    self.canvas_2d.colorbar_axes = self.canvas_2d.figure.add_axes([0.85, 0.15, 0.03, 0.7])
                    cbar = self.canvas_2d.figure.colorbar(im, cax=self.canvas_2d.colorbar_axes)
                    cbar.ax.set_ylabel('高程差 (m) [对比 - 原始]', color='white')
                    cbar.ax.yaxis.set_tick_params(color='white', labelcolor='white')
                    self.canvas_2d.figure.subplots_adjust(right=0.78)
                    self.canvas_2d.axes.set_title("2D 差值图 (挖: 蓝 / 填: 红)", color='white', fontsize=12)

                except Exception as e:
                    self.canvas_2d.axes.set_title(f"差值图绘制失败: {e}", color='red')
            else:
                # 如果条件不满足，显示提示信息
                self.canvas_2d.axes.set_title("请先加载[对比 DTM]并生成[格网]", color='yellow')
                self.canvas_2d.axes.tricontourf(self.triangulation, z, levels=15, cmap=cmap) # 回退到等高线
        # --- 结束新增 ---

        elif self.current_analysis_mode == "Viewshed":
            ax = self.canvas_2d.axes
            # 1. 检查是否有数据
            if self.viewshed_data is None:
                ax.set_title("请先运行[视域分析]", color='yellow')
                ax.tricontourf(self.triangulation, z, levels=15, cmap=cmap) # 回退到等高线
            else:
                # 2. 绘制基础底图 (灰色TIN)
                try:
                    cmap_gray = matplotlib.colormaps['gray']
                except KeyError:
                    cmap_gray = plt.get_cmap('gray')
                
                ax.tricontourf(self.triangulation, z, levels=15, cmap=cmap_gray, alpha=0.6)
                
                # 3. 准备可视区域数据 (不可见区域设为 NaN)
                visible_data = self.viewshed_data.astype(float)
                visible_data[visible_data == 0] = np.nan
                
                # 4. 准备色图 (仅绿色)
                try:
                    cmap_green = matplotlib.colors.ListedColormap(['#00FF00'])
                except:
                    cmap_green = 'Greens' # Fallback
                
                # 5. 叠加可视区域 (使用 imshow)
                ax.imshow(visible_data, 
                          extent=(self.grid_x.min(), self.grid_x.max(), self.grid_y.min(), self.grid_y.max()),
                          origin='lower', 
                          cmap=cmap_green, 
                          alpha=0.5, # 半透明
                          interpolation='none')
                
                # 6. 标记观察点
                if self.viewshed_observer_pos:
                    obs_x, obs_y = self.viewshed_observer_pos
                    ax.plot(obs_x, obs_y, 'r*', markersize=15, label="观察点")
                    ax.legend(facecolor='#555', edgecolor='white')
                
                ax.set_title("视域分析结果 (绿色=可见)", color='white', fontsize=12)

        # --- 新增：绘制通视分析 (LoS) 线条 ---
        if self.last_los_result:
            try:
                p1, p2, is_visible = self.last_los_result
                color = '#00FF00' if is_visible else '#FF0000' # 绿色/红色
                
                # 绘制连接线
                self.canvas_2d.axes.plot([p1[0], p2[0]], [p1[1], p2[1]], 
                                         color=color, linestyle='--', linewidth=2, 
                                         label="通视线 (LoS)")
                # 绘制端点
                self.canvas_2d.axes.plot([p1[0], p2[0]], [p1[1], p2[1]], 
                                         'X', color=color, markersize=10, markeredgewidth=2)
            except Exception as e:
                print(f"Error drawing 2D LoS line: {e}")

        # 根据状态绘制数据点
        if self.show_data_points and self.data is not None:
            try:
                # 使用较小的、半透明的、亮色的点
                self.canvas_2d.axes.plot(self.data['X'], self.data['Y'], 
                                         '.',               # 点样式
                                         color='#FF00FF',    # 亮洋红色
                                         markersize=5.0,    # <--- 修改后的值
                                         alpha=0.6)        # 半透明
            except Exception as e:
                print(f"警告: 绘制数据点失败: {e}")

        try:
            if self.vector_layers:
                for layer_gdf in self.vector_layers:
                    # Geopandas 可以直接在现有的 matplotlib ax 上绘图
                    layer_gdf.plot(ax=self.canvas_2d.axes,
                                   edgecolor='cyan',    # 线条颜色
                                   facecolor='none',  # 不填充面
                                   linewidth=1.2,
                                   label=layer_gdf.get('name', None)) # 简单标签
        except Exception as e:
            # 绘图失败不应中断整个刷新
            print(f"警告: 绘制矢量图层失败: {e}")
        self.canvas_2d.axes.set_xlabel("X", color='white')
        self.canvas_2d.axes.set_ylabel("Y", color='white')
        try:
            self.canvas_2d.axes.set_aspect('equal', adjustable='box')
        except:
            pass
        # overlay persisted profile polylines and last single profile line
        try:
            for seg in getattr(self, 'multi_profiles', []):
                if seg and len(seg) >= 2:
                    xs = [pt[0] for pt in seg]
                    ys = [pt[1] for pt in seg]
                    self.canvas_2d.axes.plot(xs, ys, color='yellow', linewidth=1.2, linestyle='-')
            lp = getattr(self, 'last_profile_line', None)
            if lp:
                try:
                    self.canvas_2d.axes.plot([lp[0][0], lp[0][1]], [lp[1][0], lp[1][1]], color='red', linewidth=1.5, linestyle='--')
                except:
                    pass
        except Exception:
            pass
        self.canvas_2d.draw()

        # ---- 3D 绘制 ----
        self.canvas_3d.axes.clear()
        if self.canvas_3d.colorbar_axes:
            try:
                self.canvas_3d.figure.delaxes(self.canvas_3d.colorbar_axes)
                self.canvas_3d.colorbar_axes = None
            except:
                pass
        self.canvas_3d.colorbar_axes = self.canvas_3d.figure.add_axes(self.canvas_3d.cbar_position_rect)

        # --- MODIFICATION: Use matplotlib.colormaps ---
        # cmap is already updated above
        # --- END MODIFICATION ---

        if self.current_3d_mode == "TIN_Mesh" or self.grid_z is None:
            surf = self.canvas_3d.axes.plot_trisurf(x, y, z, triangles=self.triangulation.triangles, cmap=cmap, edgecolor='none', alpha=0.9)
            self.canvas_3d.axes.set_title("3D TIN Mesh", color='white')
        else:
            Xg, Yg = np.meshgrid(self.grid_x, self.grid_y)
            surf = self.canvas_3d.axes.plot_surface(Xg, Yg, self.grid_z, cmap=cmap, edgecolor='none', alpha=0.9)
            self.canvas_3d.axes.set_title("3D Smoothed Grid", color='white')

        cbar = self.canvas_3d.figure.colorbar(surf, cax=self.canvas_3d.colorbar_axes, label='Z (m)')
        cbar.ax.yaxis.set_tick_params(color='white', labelcolor='white')
        # --- 新增：绘制通视分析 (LoS) 3D 线条 ---
        if self.last_los_result and self.interpolator:
            try:
                p1, p2, is_visible = self.last_los_result
                color = '#00FF00' if is_visible else '#FF0000'
                
                # 获取两点的地面高程
                z1_ground = self.interpolator(p1[0], p1[1])
                z2_ground = self.interpolator(p2[0], p2[1])
                
                # 计算视线的 3D 坐标 (在指定高度)
                z1_eye = z1_ground + self.los_obs_height
                z2_eye = z2_ground + self.los_tgt_height
                
                if not np.isnan(z1_eye) and not np.isnan(z2_eye):
                    # --- 优化 3D LoS 显示 ---
                    # 增加一点垂直偏移量，使其浮在表面之上
                    vertical_offset = max(1.0, (z1_eye + z2_eye) / 2 * 0.005) # 地面越高，偏移越大，至少1米
                    
                    # 绘制 3D 视线（更粗，使用 '^' 标记）
                    self.canvas_3d.axes.plot([p1[0], p2[0]], [p1[1], p2[1]], 
                                             [z1_eye + vertical_offset, z2_eye + vertical_offset],
                                             color=color, linestyle='-', linewidth=4, # 更粗
                                             marker='^', markersize=8,              # 使用三角标记
                                             label="通视线 (LoS)")
            except Exception as e:
                print(f"Error drawing 3D LoS line: {e}")
        try:
            self._draw_vector_layers_3d(self.canvas_3d.axes)
        except Exception as e:
            print(f"Error calling _draw_vector_layers_3d: {e}")
        self.canvas_3d.axes.set_xlabel("X", color='white')
        self.canvas_3d.axes.set_ylabel("Y", color='white')
        try:
            self.canvas_3d.axes.set_zlabel("Z", color='white')
        except:
            pass
        self.canvas_3d.draw()

    # ------------------ 弹出查看器（QMainWindow，默认最大化） ------------------
    def popout_viewer(self, figure_or_canvas, title):
        """
        弹出独立查看器：为避免把主界面的 QWidget（FigureCanvas）移动导致消失，
        这里创建一个新的 MplCanvas（独立 widget）并在其中重绘当前数据。
        这样关闭弹窗不会影响主界面。
        支持 2D / 3D（根据 title 或传入对象判断）。
        """
        try:
            from PyQt5.QtWidgets import QMainWindow
            viewer = QMainWindow(self)
            viewer.setWindowTitle(title)
            viewer.setWindowFlags(Qt.Window | Qt.WindowMinMaxButtonsHint | Qt.WindowCloseButtonHint)
            central = QWidget()
            layout = QVBoxLayout(central)

            # 判断 3D / 2D（优先依据传入对象的属性，其次依据标题）
            is_3d = False
            try:
                if hasattr(figure_or_canvas, 'is_3d') and getattr(figure_or_canvas, 'is_3d'):
                    is_3d = True
                elif isinstance(figure_or_canvas, Figure) and getattr(self, 'canvas_3d', None) is not None and figure_or_canvas is self.canvas_3d.figure:
                    is_3d = True
                elif "3D" in (title or ""):
                    is_3d = True
            except:
                is_3d = "3D" in (title or "")

            # 新建独立画布（独立 widget，不复用主界面 canvas）
            new_canvas = MplCanvas(parent=self, is_3d=is_3d)

            # 复制当前图形内容到新画布（只读式重绘，不改变主画布）
            try:
                if self.data is not None and self.triangulation is not None:
                    x = self.data['X'].values; y = self.data['Y'].values; z = self.data['Z'].values
                    # --- MODIFICATION: Use matplotlib.colormaps ---
                    cmap_name = self.combo_colormap.currentText()
                    try:
                        cmap = matplotlib.colormaps[cmap_name]
                    except KeyError:
                        cmap = plt.get_cmap(cmap_name)
                    # --- END MODIFICATION ---

                    if not is_3d:
                        ax = new_canvas.axes
                        ax.clear()
                        if self.current_analysis_mode == "TIN_Contour":
                            try:
                                minor = float(self.line_minor_interval.text()); major = float(self.line_major_interval.text()); base = float(self.line_base_elevation.text())
                                if minor <= 0: minor = 1.0
                                zmin = z.min(); zmax = z.max()
                                start = np.floor((zmin-base)/minor)*minor + base
                                minor_lvls = np.arange(start, zmax+minor, minor)
                                minor_lvls = minor_lvls[minor_lvls>=zmin]
                                ax.tricontourf(self.triangulation, z, levels=minor_lvls, cmap=cmap) # Use updated cmap
                                minor_lines = ax.tricontour(self.triangulation, z, levels=minor_lvls, colors='#CCCCCC', linewidths=0.5)
                                ax.clabel(minor_lines, inline=True, fontsize=8, fmt='%.1f')
                                major_lvls = [lv for lv in minor_lvls if np.isclose((lv-base)%major, 0, atol=1e-6)]
                                if len(major_lvls) > 0:
                                    major_lines = ax.tricontour(self.triangulation, z, levels=major_lvls, colors='#222222', linewidths=1.2)
                                    ax.clabel(major_lines, inline=True, fontsize=9, fmt='%.1f', colors='white')
                                ax.set_title("2D 等高线", color='white')
                            except Exception:
                                ax.tricontourf(self.triangulation, z, levels=15, cmap=cmap) # Use updated cmap
                                ax.set_title("2D 等高线 (默认)", color='white')
                        elif self.current_analysis_mode == "Slope":
                            if self.slope_data is None:
                                self.calculate_slope_aspect()
                            pcm = ax.tripcolor(self.triangulation, self.slope_data, cmap=cmap, edgecolors='none') # Use updated cmap
                            cbar = new_canvas.figure.colorbar(pcm, ax=ax, fraction=0.03, pad=0.04)
                            cbar.ax.set_ylabel('坡度 (°)', color='white')
                            cbar.ax.yaxis.set_tick_params(color='white', labelcolor='white')
                            ax.set_title("坡度图", color='white')
                        elif self.current_analysis_mode == "Aspect":
                            if self.aspect_data is None:
                                self.calculate_slope_aspect()
                            # --- MODIFICATION: Use matplotlib.colormaps for hsv ---
                            try:
                                cmap_hsv = matplotlib.colormaps['hsv']
                            except KeyError:
                                cmap_hsv = plt.get_cmap('hsv')
                            # --- END MODIFICATION ---
                            pcm = ax.tripcolor(self.triangulation, self.aspect_data, cmap=cmap_hsv, edgecolors='none', vmin=0, vmax=360)
                            cbar = new_canvas.figure.colorbar(pcm, ax=ax, fraction=0.03, pad=0.04, ticks=[0,90,180,270,360])
                            cbar.ax.set_yticklabels(['北','东','南','西','北'])
                            cbar.ax.set_ylabel('坡向', color='white')
                            ax.set_title("坡向图", color='white')
                        elif self.current_analysis_mode == "Viewshed":
                            if self.viewshed_data is None:
                                ax.set_title("请先运行[视域分析]", color='yellow')
                                ax.tricontourf(self.triangulation, z, levels=15, cmap=cmap)
                            else:
                                try: cmap_gray = matplotlib.colormaps['gray']
                                except KeyError: cmap_gray = plt.get_cmap('gray')
                                ax.tricontourf(self.triangulation, z, levels=15, cmap=cmap_gray, alpha=0.6)
                                
                                visible_data = self.viewshed_data.astype(float)
                                visible_data[visible_data == 0] = np.nan
                                try: cmap_green = matplotlib.colors.ListedColormap(['#00FF00'])
                                except: cmap_green = 'Greens'
                                
                                ax.imshow(visible_data, 
                                          extent=(self.grid_x.min(), self.grid_x.max(), self.grid_y.min(), self.grid_y.max()),
                                          origin='lower', cmap=cmap_green, alpha=0.5, interpolation='none')
                                
                                if self.viewshed_observer_pos:
                                    obs_x, obs_y = self.viewshed_observer_pos
                                    ax.plot(obs_x, obs_y, 'r*', markersize=15, label="观察点")
                                    ax.legend(facecolor='#555', edgecolor='white')
                                ax.set_title("视域分析结果 (绿色=可见)", color='white')
                        if self.show_data_points and self.data is not None:
                            try:
                                # 注意：这里我们使用 ax (新画布的轴)
                                ax.plot(self.data['X'], self.data['Y'], 
                                        '.',               # 点样式
                                        color='#FF00FF',    # 亮洋红色
                                        markersize=3.0,    # (使用您上次修改的 3.0)
                                        alpha=0.6)        # 半透明
                            except Exception as e:
                                print(f"警告: 弹窗查看器绘制数据点失败: {e}")
                        try:
                            if self.vector_layers:
                                for layer_gdf in self.vector_layers:
                                    # Geopandas 可以直接在现有的 matplotlib ax 上绘图
                                    # 注意：这里我们使用 ax (新画布的轴)，而不是 self.canvas_2d.axes
                                    layer_gdf.plot(ax=ax,
                                                   edgecolor='cyan',    # 线条颜色
                                                   facecolor='none',  # 不填充面
                                                   linewidth=1.2,
                                                   label=layer_gdf.get('name', None))
                        except Exception as e:
                            # 绘图失败不应中断整个刷新
                            print(f"警告: 弹窗查看器绘制矢量图层失败: {e}")
                        if self.last_los_result:
                            try:
                                p1, p2, is_visible = self.last_los_result
                                color = '#00FF00' if is_visible else '#FF0000'
                                ax.plot([p1[0], p2[0]], [p1[1], p2[1]],
                                        color=color, linestyle='--', linewidth=2, label="通视线 (LoS)")
                                ax.plot([p1[0], p2[0]], [p1[1], p2[1]],
                                        'X', color=color, markersize=10, markeredgewidth=2)
                            except Exception as e:
                                print(f"Error drawing popout 2D LoS line: {e}")
                        ax.set_xlabel("X", color='white'); ax.set_ylabel("Y", color='white')
                        ax.tick_params(colors='white', labelcolor='white')
                        if self.last_los_result and self.interpolator:
                            try:
                                p1, p2, is_visible = self.last_los_result
                                color = '#00FF00' if is_visible else '#FF0000'
                                z1_ground = self.interpolator(p1[0], p1[1])
                                z2_ground = self.interpolator(p2[0], p2[1])
                                z1_eye = z1_ground + self.los_obs_height
                                z2_eye = z2_ground + self.los_tgt_height
                                
                                if not np.isnan(z1_eye) and not np.isnan(z2_eye):
                                    vertical_offset = max(1.0, (z1_eye + z2_eye) / 2 * 0.005)
                                    ax.plot([p1[0], p2[0]], [p1[1], p2[1]],
                                            [z1_eye + vertical_offset, z2_eye + vertical_offset],
                                            color=color, linestyle='-', linewidth=4,
                                            marker='^', markersize=8,
                                            label="通视线 (LoS)")
                            except Exception as e:
                                print(f"Error drawing popout 3D LoS line: {e}")
                        try:
                            self._draw_vector_layers_3d(ax) # 使用 new_canvas 的轴 ax
                        except Exception as e:
                            print(f"Error calling _draw_vector_layers_3d in popout: {e}")
                        try: ax.set_aspect('equal', adjustable='box')
                        except: pass
                        new_canvas.draw()
                        # ------------------ 在独立查看器中添加交互：滚轮缩放（支持 Ctrl/Shift 细/粗）与中键平移 ------------------
                        try:
                            pan_state = {'active': False, 'x0': None, 'y0': None, 'orig_xlim': None, 'orig_ylim': None}

                            def _on_scroll(event):
                                # 更稳健地识别修饰键
                                key = (getattr(event, 'key', '') or '')
                                if isinstance(key, str):
                                    key = key.lower()
                                # 判断滚轮方向：先尝试 event.step（数值），再尝试 event.button 或 event.button 字符
                                # 优先使用 Qt 原始事件的 delta（event.guiEvent）
                                direction_up = None
                                gui = getattr(event, 'guiEvent', None)
                                if gui is not None:
                                    delta = getattr(gui, 'delta', None) or getattr(gui, 'pixelDelta', None)
                                    try:
                                        if delta is not None:
                                            # Qt 的 delta 通常为整数，正值为向上
                                            direction_up = (int(delta) > 0)
                                    except Exception:
                                        pass
                                if direction_up is None:
                                    step = getattr(event, 'step', None)
                                    if step is not None:
                                        direction_up = (step > 0)
                                    else:
                                        btn = getattr(event, 'button', None)
                                        if isinstance(btn, str):
                                            direction_up = (btn == 'up')
                                        else:
                                            # 无法判断时默认向下（缩小）
                                            direction_up = False

                                # 缩放速率
                                if 'control' in key:
                                    sf = 1.05
                                elif 'shift' in key:
                                    sf = 1.4
                                else:
                                    sf = 1.2

                                try:
                                    if getattr(new_canvas, 'is_3d', False):
                                        ax = new_canvas.axes
                                        # Try to read a stronger Qt wheel delta first (angleDelta), fallback to other fields
                                        gui = getattr(event, 'guiEvent', None)
                                        delta_val = None
                                        try:
                                            if gui is not None and hasattr(gui, 'angleDelta'):
                                                ad = gui.angleDelta()
                                                # angleDelta returns a QPoint; prefer Y component
                                                delta_val = ad.y() if hasattr(ad, 'y') else int(ad)
                                            else:
                                                delta_val = getattr(gui, 'delta', None) or getattr(gui, 'pixelDelta', None)
                                        except Exception:
                                            delta_val = getattr(event, 'step', None)

                                        # Determine direction: positive -> zoom in
                                        if delta_val is None:
                                            direction_up_local = direction_up
                                        else:
                                            try:
                                                direction_up_local = (int(delta_val) > 0)
                                            except Exception:
                                                direction_up_local = direction_up

                                        # Use camera distance for 3D zoom when available (Axes3D.dist)
                                        try:
                                            cur_dist = getattr(ax, 'dist', None)
                                            if cur_dist is not None:
                                                factor = (1.0/sf) if direction_up_local else sf
                                                # clamp reasonable bounds to avoid inversion
                                                new_dist = max(0.1, min(10000.0, cur_dist * factor))
                                                ax.dist = new_dist
                                                new_canvas.draw_idle()
                                            else:
                                                # Fallback: scale axis ranges around center (older mpl)
                                                cur_xlim = ax.get_xlim(); cur_ylim = ax.get_ylim(); cur_zlim = ax.get_zlim()
                                                scale = (1.0/sf) if direction_up_local else sf
                                                cx = 0.5 * (cur_xlim[0] + cur_xlim[1])
                                                cy = 0.5 * (cur_ylim[0] + cur_ylim[1])
                                                cz = 0.5 * (cur_zlim[0] + cur_zlim[1])
                                                new_xw = max((cur_xlim[1]-cur_xlim[0]) * scale, 1e-6)
                                                new_yw = max((cur_ylim[1]-cur_ylim[0]) * scale, 1e-6)
                                                new_zw = max((cur_zlim[1]-cur_zlim[0]) * scale, 1e-6)
                                                new_xlim = (cx - new_xw*0.5, cx + new_xw*0.5)
                                                new_ylim = (cy - new_yw*0.5, cy + new_yw*0.5)
                                                new_zlim = (cz - new_zw*0.5, cz + new_zw*0.5)
                                                if new_xlim[0] < new_xlim[1] and new_ylim[0] < new_ylim[1] and new_zlim[0] < new_zlim[1]:
                                                    ax.set_xlim(new_xlim); ax.set_ylim(new_ylim); ax.set_zlim(new_zlim)
                                                    try: ax.autoscale(enable=False)
                                                    except: pass
                                                    new_canvas.draw_idle()
                                        except Exception:
                                            pass
                                    else:
                                        ax = new_canvas.axes
                                        xdata = event.xdata if event.xdata is not None else 0.5*(ax.get_xlim()[0]+ax.get_xlim()[1])
                                        ydata = event.ydata if event.ydata is not None else 0.5*(ax.get_ylim()[0]+ax.get_ylim()[1])
                                        cur_xlim = ax.get_xlim(); cur_ylim = ax.get_ylim()
                                        scale = (1.0/sf) if direction_up else sf
                                        new_width = (cur_xlim[1] - cur_xlim[0]) * scale
                                        new_height = (cur_ylim[1] - cur_ylim[0]) * scale
                                        ax.set_xlim([xdata - new_width*( (xdata - cur_xlim[0])/(cur_xlim[1]-cur_xlim[0]) if cur_xlim[1]!=cur_xlim[0] else 0.5 ),
                                                     xdata + new_width*( (cur_xlim[1]-xdata)/(cur_xlim[1]-cur_xlim[0]) if cur_xlim[1]!=cur_xlim[0] else 0.5 )])
                                        ax.set_ylim([ydata - new_height*( (ydata - cur_ylim[0])/(cur_ylim[1]-cur_ylim[0]) if cur_ylim[1]!=cur_ylim[0] else 0.5 ),
                                                     ydata + new_height*( (cur_ylim[1]-ydata)/(cur_ylim[1]-cur_ylim[0]) if cur_ylim[1]!=cur_ylim[0] else 0.5 )])
                                        new_canvas.draw_idle()
                                except Exception:
                                    pass

                            def _on_button_press(event):
                                # 中键（button == 2）开始平移
                                try:
                                    if getattr(event, 'button', None) == 2:
                                        ax = new_canvas.axes
                                        pan_state['active'] = True
                                        # 记录像素坐标与当前轴范围
                                        pan_state['xpix0'] = getattr(event, 'x', None)
                                        pan_state['ypix0'] = getattr(event, 'y', None)
                                        pan_state['orig_xlim'] = ax.get_xlim(); pan_state['orig_ylim'] = ax.get_ylim()
                                except Exception:
                                    pass

                            def _on_button_release(event):
                                try:
                                    if getattr(event, 'button', None) == 2:
                                        pan_state['active'] = False
                                        pan_state['x0'] = pan_state['y0'] = None
                                        pan_state['orig_xlim'] = pan_state['orig_ylim'] = None
                                except Exception:
                                    pass

                            def _on_motion(event):
                                try:
                                    if not pan_state['active']:
                                        return
                                    ax = new_canvas.axes
                                    if getattr(event, 'x', None) is None or getattr(event, 'y', None) is None:
                                        return
                                    xpix = event.x; ypix = event.y
                                    dxpix = xpix - pan_state.get('xpix0', xpix)
                                    dypix = ypix - pan_state.get('ypix0', ypix)
                                    # 将像素位移转换为数据坐标位移
                                    bbox = ax.get_window_extent().transformed(new_canvas.figure.dpi_scale_trans.inverted())
                                    width_px = bbox.width * new_canvas.figure.dpi
                                    height_px = bbox.height * new_canvas.figure.dpi
                                    ox0, ox1 = pan_state['orig_xlim']
                                    oy0, oy1 = pan_state['orig_ylim']
                                    dxdata = dxpix * (ox1 - ox0) / max(width_px, 1)
                                    # 垂直像素向下为正，因此转换为数据坐标时 dy 应为正向移动（上移为负像素）
                                    dydata = dypix * (oy1 - oy0) / max(height_px, 1)
                                    ax.set_xlim(ox0 - dxdata, ox1 - dxdata)
                                    ax.set_ylim(oy0 - dydata, oy1 - dydata)
                                    new_canvas.draw_idle()
                                except Exception:
                                    pass

                            # 连接事件
                            new_canvas.mpl_connect('scroll_event', _on_scroll)
                            new_canvas.mpl_connect('button_press_event', _on_button_press)
                            new_canvas.mpl_connect('button_release_event', _on_button_release)
                            new_canvas.mpl_connect('motion_notify_event', _on_motion)
                        except Exception:
                            pass
                    else:
                        ax = new_canvas.axes
                        ax.clear()
                        if self.current_3d_mode == "TIN_Mesh" or self.grid_z is None:
                            surf = ax.plot_trisurf(x, y, z, triangles=self.triangulation.triangles, cmap=cmap, edgecolor='none', alpha=0.9)
                            ax.set_title("3D TIN Mesh", color='white')
                        else:
                            Xg, Yg = np.meshgrid(self.grid_x, self.grid_y)
                            surf = ax.plot_surface(Xg, Yg, self.grid_z, cmap=cmap, edgecolor='none', alpha=0.9)
                            ax.set_title("3D Smoothed Grid", color='white')
                        # colorbar
                        try:
                            cbar = new_canvas.figure.colorbar(surf, ax=ax, fraction=0.03, pad=0.04)
                            cbar.ax.yaxis.set_tick_params(color='white', labelcolor='white')
                            cbar.set_label('Z (m)', color='white')
                        except:
                            pass
                        ax.set_xlabel("X", color='white'); ax.set_ylabel("Y", color='white')
                        try: ax.set_zlabel("Z", color='white')
                        except: pass
                        # 保持与主界面初始视角一致（如可用）
                        try:
                            ax.azim = getattr(self.canvas_3d.axes, 'azim', ax.azim)
                            ax.elev = getattr(self.canvas_3d.axes, 'elev', ax.elev)
                            ax.view_init(elev=ax.elev, azim=ax.azim)
                        except:
                            pass
                        new_canvas.draw()
                        # 为 3D 弹出查看器添加滚轮缩放支持
                        try:
                            def _popup_3d_scroll(event):
                                try:
                                    gui = getattr(event, 'guiEvent', None)
                                    direction_up = None
                                    if gui is not None:
                                        # 尝试 Qt angleDelta / delta
                                        try:
                                            if hasattr(gui, 'angleDelta'):
                                                ad = gui.angleDelta()
                                                direction_up = True if (ad.y() if hasattr(ad, 'y') else int(ad)) > 0 else False
                                            else:
                                                delta = getattr(gui, 'delta', None) or getattr(gui, 'pixelDelta', None)
                                                if delta is not None:
                                                    direction_up = int(delta) > 0
                                        except Exception:
                                            pass
                                    if direction_up is None:
                                        step = getattr(event, 'step', None)
                                        if step is not None:
                                            direction_up = (step > 0)
                                        else:
                                            btn = getattr(event, 'button', None)
                                            direction_up = (btn == 'up') if isinstance(btn, str) else False

                                    key = (getattr(event, 'key', '') or '')
                                    if isinstance(key, str):
                                        key = key.lower()
                                    if 'control' in key:
                                        sf = 1.05
                                    elif 'shift' in key:
                                        sf = 1.4
                                    else:
                                        sf = 1.15

                                    ax = new_canvas.axes
                                    # 优先通过 ax.dist（若可用）改变视距
                                    try:
                                        cur_dist = getattr(ax, 'dist', None)
                                        if cur_dist is not None:
                                            factor = (1.0/sf) if direction_up else sf
                                            new_dist = max(0.1, min(10000.0, cur_dist * factor))
                                            ax.dist = new_dist
                                            new_canvas.draw_idle()
                                            return
                                    except Exception:
                                        pass

                                    # 否则回退为缩放 axes 范围
                                    try:
                                        cur_xlim = ax.get_xlim(); cur_ylim = ax.get_ylim(); cur_zlim = ax.get_zlim()
                                        scale = (1.0/sf) if direction_up else sf
                                        cx = 0.5 * (cur_xlim[0] + cur_xlim[1])
                                        cy = 0.5 * (cur_ylim[0] + cur_ylim[1])
                                        cz = 0.5 * (cur_zlim[0] + cur_zlim[1])
                                        new_xw = max((cur_xlim[1] - cur_xlim[0]) * scale, 1e-6)
                                        new_yw = max((cur_ylim[1] - cur_ylim[0]) * scale, 1e-6)
                                        new_zw = max((cur_zlim[1] - cur_zlim[0]) * scale, 1e-6)
                                        new_xlim = (cx - new_xw*0.5, cx + new_xw*0.5)
                                        new_ylim = (cy - new_yw*0.5, cy + new_yw*0.5)
                                        new_zlim = (cz - new_zw*0.5, cz + new_zw*0.5)
                                        if new_xlim[0] < new_xlim[1] and new_ylim[0] < new_ylim[1] and new_zlim[0] < new_zlim[1]:
                                            ax.set_xlim(new_xlim); ax.set_ylim(new_ylim); ax.set_zlim(new_zlim)
                                            try: ax.autoscale(enable=False)
                                            except: pass
                                            new_canvas.draw_idle()
                                    except Exception:
                                        pass
                                except Exception:
                                    pass

                            new_canvas.mpl_connect('scroll_event', _popup_3d_scroll)
                        except Exception:
                            pass
            except Exception:
                # 若重绘失败，则显示空白画布（不会影响主界面）
                pass

            toolbar = ChineseNavigationToolbar(new_canvas, viewer)
            layout.addWidget(toolbar)
            layout.addWidget(new_canvas)
            viewer.setCentralWidget(central)
            viewer.showMaximized()
        except Exception as e:
            QMessageBox.warning(self, "错误", f"弹出查看器失败: {e}")

    # ------------------ 断面、导出相关 ------------------
    def toggle_profiling_mode(self):
        self.is_profiling = not self.is_profiling
        if self.is_profiling:
            # --- 新增：关闭其他模式 ---
            self.btn_query_tool.setChecked(False); self.is_querying = False
            self.btn_add_point.setChecked(False); self.is_adding_point = False
            self.btn_delete_point.setChecked(False); self.is_deleting_point = False
            self.btn_multi_profile.setChecked(False); self.multi_profile_mode = False
            self.btn_profile.setText("取消断面分析")
        else:
            self.btn_profile.setText("启用断面分析")
            self.profile_points = []

    def on_map_click(self, event):
        """
        统一的地图点击事件处理器。
        按优先级处理不同的交互模式。
        """
        # 1. 检查点击是否有效
        if event.inaxes != self.canvas_2d.axes:
            return
        if event.xdata is None or event.ydata is None:
            return
            
        x, y = event.xdata, event.ydata
        
        # 2. 模式优先级判断
        
        # 模式 1: 单段断面分析
        if self.is_profiling:
            self.profile_points.append((x, y))
            self.canvas_2d.axes.plot(x, y, 'r+', markersize=10)
            self.canvas_2d.draw()
            if len(self.profile_points) == 2:
                self.generate_profile()
                self.profile_points = []
                self.is_profiling = False
                self.btn_profile.setText("启用断面分析")
            return

        # 模式 2: 多段断面分析
        if self.multi_profile_mode:
            btn = getattr(event, 'button', None)
            if btn in (1, 'left'):
                self._current_profile_segment.append((x, y))
                self.canvas_2d.axes.plot(x, y, 'y.', markersize=6)
                self.canvas_2d.draw()
            elif btn in (3, 'right'):
                if len(self._current_profile_segment) >= 2:
                    seg = list(self._current_profile_segment)
                    self.multi_profiles.append(seg)
                    try:
                        xs = [pt[0] for pt in seg]
                        ys = [pt[1] for pt in seg]
                        self.canvas_2d.axes.plot(xs, ys, color='yellow', linewidth=1.4, linestyle='-')
                        self.canvas_2d.draw()
                    except Exception:
                        pass
                self._current_profile_segment = []
                try:
                    self.lbl_file.setText(f"已保存段: {len(self.multi_profiles)}")
                except:
                    pass
            return
        
        if self.is_checking_los:
            self.handle_los_click(x, y)
            return
        
        if self.is_setting_viewshed:
            self.handle_viewshed_click(x, y)
            return
            
        # 模式 3: 添加数据点 (新功能)
        if self.is_adding_point:
            self.handle_add_point_click(x, y)
            return

        # 模式 4: 删除数据点 (新功能)
        if self.is_deleting_point:
            self.handle_delete_point_click(x, y)
            return

        # 模式 5: 属性查询 (新功能)
        if self.is_querying:
            self.handle_query_click(x, y)
            return

        # (如果没有任何模式激活，则点击无效)

    def generate_profile(self):
        p1, p2 = self.profile_points
        num = 100
        xs = np.linspace(p1[0], p2[0], num)
        ys = np.linspace(p1[1], p2[1], num)
        zs = self.interpolator(xs, ys)
        dist = np.sqrt((xs-p1[0])**2 + (ys-p1[1])**2)
        dlg = ProfileDialog(dist, zs, self)
        dlg.exec_()
        # store last profile line for persistent display and draw it
        try:
            self.last_profile_line = ((p1[0], p2[0]), (p1[1], p2[1]))
            try:
                self.canvas_2d.axes.plot([p1[0], p2[0]], [p1[1], p2[1]], color='red', linewidth=1.5, linestyle='--')
                self.canvas_2d.draw()
            except Exception:
                pass
        except Exception:
            self.last_profile_line = None
        self.update_plots()

    # ------------------ 多段断面相关方法 ------------------
    def toggle_multi_profile_mode(self):
        """切换多段断面绘制模式：左键添加点，右键结束当前段并保存；再次点击退出模式。"""
        self.multi_profile_mode = not self.multi_profile_mode
        if self.multi_profile_mode:
            self.btn_query_tool.setChecked(False); self.is_querying = False
            self.btn_add_point.setChecked(False); self.is_adding_point = False
            self.btn_delete_point.setChecked(False); self.is_deleting_point = False
            self.btn_profile.setChecked(False); self.is_profiling = False
            self._current_profile_segment = []
            self.multi_profiles = []
            self.btn_multi_profile.setText("退出多段模式")
            QMessageBox.information(self, "多段断面", "已进入多段断面模式：左键添加点，右键完成当前段，完成后点击“导出断面汇总”。")
        else:
            self.btn_multi_profile.setText("多段断面模式")
            QMessageBox.information(self, "多段断面", f"已退出多段断面模式，已保存段数：{len(self.multi_profiles)}")

    def generate_profile_for_segment(self, segment_points, num=200):
        """为一段点列表（多点折线）按线段等距采样并返回 (img_buf, stats_dict).
        stats: length, max_slope_deg, avg_slope_deg, area_under_profile (截面积估计)
        返回 BytesIO png 图像和统计字典。
        """
        if self.interpolator is None:
            raise RuntimeError("未准备好插值器（请先计算三角网）")
        # Build polyline samples by concatenating segment subsegments
        pts = segment_points
        # compute cumulative lengths
        seg_x = []
        seg_y = []
        for i in range(len(pts)-1):
            x0,y0 = pts[i]; x1,y1 = pts[i+1]
            t = np.linspace(0,1, max(2, int(np.hypot(x1-x0, y1-y0) / (np.hypot(self.grid_spacing or 1.0, self.grid_spacing or 1.0) / 10) ) ))
            xs = x0 + (x1-x0)*t; ys = y0 + (y1-y0)*t
            seg_x.extend(xs.tolist()); seg_y.extend(ys.tolist())
        xs = np.array(seg_x)
        ys = np.array(seg_y)
        if len(xs) < 2:
            raise ValueError("段长度太短")
        # resample to fixed num points along cumulative distance
        dists = np.sqrt(np.diff(xs)**2 + np.diff(ys)**2)
        cum = np.concatenate(([0.0], np.cumsum(dists)))
        total = cum[-1]
        if total == 0:
            raise ValueError("段总长度为零")
        sample_ds = np.linspace(0, total, num)
        sx = np.interp(sample_ds, cum, xs)
        sy = np.interp(sample_ds, cum, ys)
        sz = self.interpolator(sx, sy)

        # compute slopes between sampled points (deg)
        dz = np.diff(sz)
        dd = np.diff(sample_ds)
        slopes = np.degrees(np.arctan2(np.abs(dz), dd))
        max_slope = float(np.nanmax(slopes)) if slopes.size>0 else 0.0
        avg_slope = float(np.nanmean(slopes)) if slopes.size>0 else 0.0

        # approximate area under profile relative to min z (截面积)
        zmin = np.nanmin(sz)
        area = np.nansum((sz - zmin) * np.concatenate(([0.0], dd)))

        # render plot to BytesIO
        buf = io.BytesIO()
        fig = Figure(figsize=(8,3), facecolor='#2E2E2E')
        ax = fig.add_subplot(111)
        dist = sample_ds
        ax.plot(dist, sz, color='#00AEEF')
        ax.fill_between(dist, sz, zmin, color='#00AEEF', alpha=0.25)
        ax.set_xlabel('距离 (m)', color='white')
        ax.set_ylabel('高程 (m)', color='white')
        ax.set_title('断面图', color='white')
        ax.grid(True, linestyle='--', alpha=0.4)
        ax.tick_params(colors='white')
        fig.savefig(buf, dpi=200, bbox_inches='tight', facecolor=fig.get_facecolor())
        buf.seek(0)
        try:
            plt.close(fig)
        except:
            pass

        stats = {'length_m': float(total), 'max_slope_deg': max_slope, 'avg_slope_deg': avg_slope, 'area_m2': float(area)}
        return buf, stats

    def export_profiles(self):
        """导出当前已保存的多段断面为 Word 报告，包含每段断面图片和统计表。"""
        if not self.multi_profiles:
            QMessageBox.warning(self, '提示', '尚未绘制任何段（右键完成每个段）')
            return
        # ensure interpolator ready
        if self.interpolator is None:
            QMessageBox.warning(self, '提示', '三角剖分/插值尚未完成，请先等待后台计算完成后再导出。')
            return
        fp, _ = QFileDialog.getSaveFileName(self, '保存断面汇总报告', f'断面汇总_{datetime.now().strftime("%Y%m%d_%H%M%S")}.docx', 'Word 文件 (*.docx)')
        if not fp:
            return
        try:
            doc = Document()
            doc.add_heading('多段断面汇总报告', 0)
            for idx, seg in enumerate(self.multi_profiles, start=1):
                try:
                    img_buf, stats = self.generate_profile_for_segment(seg, num=200)
                    doc.add_heading(f'断面 {idx}', level=2)
                    p = doc.add_paragraph(f"长度: {stats['length_m']:.2f} m; 最大坡度: {stats['max_slope_deg']:.2f}°; 平均坡度: {stats['avg_slope_deg']:.2f}°; 截面积(估算): {stats['area_m2']:.2f} m²")
                    # insert picture from buffer
                    try:
                        doc.add_picture(img_buf, width=Inches(6.0))
                    except Exception:
                        # fallback: save temp file and insert
                        tmp_path = os.path.join(os.path.dirname(fp), f'_tmp_profile_{idx}.png')
                        with open(tmp_path, 'wb') as tf:
                            tf.write(img_buf.getbuffer())
                        doc.add_picture(tmp_path, width=Inches(6.0))
                        try:
                            os.remove(tmp_path)
                        except:
                            pass
                except Exception as e:
                    doc.add_paragraph(f'断面 {idx} 生成失败: {e}')
            doc.save(fp)
            QMessageBox.information(self, '完成', f'断面汇总已保存: {fp}')
        except Exception as e:
            QMessageBox.critical(self, '导出失败', str(e))

    def export_plot(self, canvas):
        """
        只导出传入的 canvas 对应图像（2D 或 3D），不再由该函数导出报告里的其他图片。
        """
        fp, _ = QFileDialog.getSaveFileName(self, "保存图像", "", "PNG (*.png);;JPG (*.jpg)")
        if not fp:
            return
        try:
            # 强制保存当前 canvas 的完整图（包含 colorbar / labels）
            canvas.figure.savefig(fp, dpi=300, facecolor=canvas.figure.get_facecolor(), bbox_inches='tight')
            QMessageBox.information(self, "保存成功", f"已保存: {fp}")
        except Exception as e:
            QMessageBox.critical(self, "保存失败", str(e))

    def export_esri_grid(self):
        if self.grid_z is None:
            QMessageBox.warning(self, "请先生成格网", "请先生成平滑格网（Smoothed Grid）")
            return
        fp, _ = QFileDialog.getSaveFileName(self, "导出 ASCII Grid", "", "ASCII Grid (*.asc)")
        if not fp:
            return
        try:
            rows, cols = self.grid_z.shape
            spacing = float(self.line_grid_spacing.text())
            xll = self.grid_x.min(); yll = self.grid_y.min()
            header = f"NCOLS {cols}\nNROWS {rows}\nXLLCORNER {xll:.2f}\nYLLCORNER {yll:.2f}\nCELLSIZE {spacing:.2f}\nNODATA_VALUE -9999\n"
            with open(fp, 'w') as f:
                f.write(header)
                for row in np.flipud(self.grid_z):
                    line = ' '.join([f"{val:.3f}" if not np.isnan(val) else "-9999" for val in row])
                    f.write(line + '\n')
            QMessageBox.information(self, "导出成功", f"已保存: {fp}")
        except Exception as e:
            QMessageBox.critical(self, "错误", str(e))

    # ------------------ 调用 AI 生成结论 ------------------
    def generate_ai_conclusion(self, x_min, x_max, y_min, y_max, z_stats=None, slope_stats=None, aspect_stats=None):
        """
        生成更详细、专业的地形分析结论 (新版)。
        优先使用外部 AI，若失败则使用本地规则。
        """
        api_key = os.environ.get("DEEP_AI_API_KEY")
        api_url = os.environ.get("AI_API_URL")
        model_name = os.environ.get("AI_MODEL_NAME")

        # --- 新增：格式化详细统计数据 ---
        z_stats_str = "未计算"
        if z_stats:
            z_stats_str = (
                f"Z范围: {z_stats['min']:.2f} ~ {z_stats['max']:.2f} m (高差: {z_stats['max']-z_stats['min']:.2f} m)\n"
                f"  均值: {z_stats['mean']:.2f} m (标准差: {z_stats['std']:.2f} m)\n"
                f"  中位数 (P50): {z_stats['median']:.2f} m\n"
                f"  四分位距 (P25-P75): {z_stats['p25']:.2f} m ~ {z_stats['p75']:.2f} m"
            )

        slope_stats_str = "未计算"
        if slope_stats:
            slope_stats_str = "\n".join([f"  - {k}: {v}" for k, v in slope_stats.items() if k != 'avg'])
            slope_stats_str += f"\n  加权平均坡度: {slope_stats.get('avg', 'N/A')}"

        aspect_stats_str = "未计算"
        if aspect_stats:
            aspect_stats_str = "\n".join([f"  - {k}: {v}" for k, v in aspect_stats.items()])
        # --- 结束新增 ---

        # 构建更详尽的 prompt（供远程模型使用）
        prompt = (
            "请基于下面提供的详细地形统计数据，用中文生成一份专业、结构化的地形分析结论：\n"
            "要求分节输出（每节 2-4 句）：\n"
            "1) 概要（总结地形地貌类型、主要特征和整体高差）。\n"
            "2) 高程分析（基于高程范围、均值和中位数，评估地形起伏和高程分布特征）。\n"
            "3) 坡度分析（*重点*：基于详细的坡度分级面积占比，详细分析平坦区、缓坡区和陡坡区的分布情况，评估其对土地利用、工程施工和水土流失的意义）。\n"
            "4) 坡向分析（*重点*：基于坡向玫瑰图的面积占比，分析是否存在优势坡向，评估其对日照、小气候和植被生长的影响）。\n"
            "5) 潜在地质/土工风险（结合坡度和高差，评估潜在的滑坡、崩塌、侵蚀风险区域）。\n"
            "6) 工程与土地利用建议（基于高程、坡度和坡向，对不同区域的开发适宜性提出具体建议，如建筑布局、道路走向、排水系统设计等）。\n"
            "7) 数据质量与不确定性说明（基于测点密度、TIN形态等，评估模型可靠性，提出勘测建议）。\n"
            "请只输出纯文本中文结论，不要包含 Markdown、代码或多余标记。\n\n"
            f"--- 详细数据 ---\n"
            f"X范围: {x_min:.2f} 至 {x_max:.2f} m; Y范围: {y_min:.2f} 至 {y_max:.2f} m.\n\n"
            f"高程 (Z) 统计:\n{z_stats_str}\n\n"
            f"坡度分级 (面积占比):\n{slope_stats_str}\n\n"
            f"坡向分级 (面积占比):\n{aspect_stats_str}\n"
        )

        # 如果配置了外部 AI，优先调用
        if api_key and api_url and model_name:
            headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
            data = {
                "model": model_name,
                "messages": [{"role": "user", "content": prompt}],
                "max_tokens": 1024, # 增加 token 限制以获取更详细内容
                "temperature": 0.2
            }
            try:
                r = requests.post(api_url, headers=headers, json=data, timeout=(10, 60))
                r.raise_for_status()
                res = r.json()
                if isinstance(res, dict):
                    if 'choices' in res and res['choices']:
                        try:
                            return res['choices'][0]['message']['content'].strip(), True
                        except Exception:
                            pass
                    if 'choices' in res and 'text' in res['choices'][0]:
                        return res['choices'][0].get('text', '').strip(), True
                return str(res), True
            except Exception as e:
                pass

        # 本地规则生成回退（当未配置 AI 或远程调用失败时使用）
        try:
            parts = []
            
            # 1. 概要
            relief = z_stats.get('max', 0) - z_stats.get('min', 0)
            parts.append(f"概要：研究区水平投影范围约为 {x_max-x_min:.1f} × {y_max-y_min:.1f} m，地形高差约 {relief:.2f} m，平均高程 {z_stats.get('mean', 0):.2f} m。地形起伏 {'较大' if relief>50 else ('中等' if relief>10 else '较小')}。")

            # 2. 高程
            parts.append(f"高程分析：高程中位数为 {z_stats.get('median', 0):.2f} m，四分位距 (P25-P75) 为 {z_stats.get('p25', 0):.2f} m 至 {z_stats.get('p75', 0):.2f} m，表明 50% 的区域集中在此高程范围。")

            # 3. 坡度
            if slope_stats:
                pct_flat = float(slope_stats.get('0-5° (平坦)', '0%').replace('%',''))
                pct_steep = float(slope_stats.get('25-35° (陡坡)', '0%').replace('%','')) + \
                            float(slope_stats.get('35-45° (峭坡)', '0%').replace('%','')) + \
                            float(slope_stats.get('> 45° (极陡)', '0%').replace('%',''))
                slope_desc = f"坡度分析：地形以缓坡 (5-15°) 和斜坡 (15-25°) 为主。平坦区域 (0-5°) 占比 {pct_flat:.1f}%，适宜建设。陡峭区域 (>25°) 总占比 {pct_steep:.1f}%，工程难度大，易发生水土流失。"
                parts.append(slope_desc)
            else:
                parts.append("坡度分析：未计算详细坡度分级。")

            # 4. 坡向
            if aspect_stats:
                # 查找优势坡向 (跳过 '平坦')
                dominant_aspect = max(
                    ( (k, v) for k, v in aspect_stats.items() if k != '平坦 (-1°)' ),
                    key=lambda item: float(item[1].replace('%',''))
                )
                aspect_desc = f"坡向分析：优势坡向为 {dominant_aspect[0]} (占比 {dominant_aspect[1]})。平坦区域占比 {aspect_stats.get('平坦 (-1°)', '0%')}。坡向分布影响局部日照和微气候，需在建筑布局时予以考虑。"
                parts.append(aspect_desc)
            else:
                parts.append("坡向分析：未计算详细坡向分级。")

            # 5. 风险
            risk_lines = []
            if slope_stats and (float(slope_stats.get('35-45° (峭坡)', '0%').replace('%','')) > 5 or float(slope_stats.get('> 45° (极陡)', '0%').replace('%','')) > 2):
                risk_lines.append("存在显著的滑坡和侵蚀风险；建议对陡坡 (>35°) 进行详细的地质灾害评估。")
            else:
                risk_lines.append("总体地形稳定性良好，但应关注局部陡坡和排水沟谷的冲刷问题。")
            parts.append("风险与建议：" + " ".join(risk_lines))
            
            # 6. 数据质量
            dq = f"数据点数: {len(self.data) if self.data is not None else 0}。若采样密度不足，建议进行密化测量（特别是陡坡处）并进行野外工程地质调查。"
            parts.append(f"数据质量与不确定性：{dq}")

            return "\n\n".join(parts), False
        except Exception as e:
            return f"无法生成结论（本地回退失败）: {e}", False

    # --- 结束替换 ---

    # ---------- 新增：生成单独图片到内存的辅助函数 ----------
    def _render_map_image(self, map_type: str):
        """
        map_type: 'contour' | 'slope' | 'aspect' | 'difference' | 'viewshed'
        返回：BytesIO（二进制 PNG 图像）
        图像包含色条及其标签/刻度（便于嵌入报告）
        """
        buf = io.BytesIO()
        if self.data is None or self.triangulation is None:
            return None
            
        # --- 公共设置 ---
        try:
            fig = Figure(facecolor='#2E2E2E')
            ax = fig.add_subplot(111, facecolor='#2E2E2E') # 背景色
            x = self.data['X'].values; y = self.data['Y'].values; z = self.data['Z'].values
            tri = self.triangulation
            
            # 获取当前色带
            cmap_name = self.combo_colormap.currentText()
            try: cmap = matplotlib.colormaps[cmap_name]
            except KeyError: cmap = plt.get_cmap(cmap_name)

            # 默认标题和色条标签
            title = f"2D {map_type.capitalize()} Map"
            cbar_label = 'Value'

            # --- 根据 map_type 绘制 ---
            pcm = None # 用于色条的对象

            if map_type == 'contour':
                try:
                    minor = float(self.line_minor_interval.text()); major = float(self.line_major_interval.text()); base = float(self.line_base_elevation.text())
                    zmin, zmax = z.min(), z.max(); start = np.floor((zmin-base)/minor)*minor + base
                    minor_lvls = np.arange(start, zmax+minor, minor); minor_lvls = minor_lvls[minor_lvls>=zmin]
                    major_lvls = [lv for lv in minor_lvls if np.isclose((lv-base)%major, 0, atol=1e-6)]
                    
                    pcm = ax.tricontourf(tri, z, levels=minor_lvls, cmap=cmap)
                    minor_lines = ax.tricontour(tri, z, levels=minor_lvls, colors='#CCCCCC', linewidths=0.5)
                    ax.clabel(minor_lines, inline=True, fontsize=7, fmt='%.1f') # 字体调小
                    if major_lvls:
                        major_lines = ax.tricontour(tri, z, levels=major_lvls, colors='#222222', linewidths=1.2)
                        ax.clabel(major_lines, inline=True, fontsize=8, fmt='%.1f', colors='white') # 字体调小
                    title = f"等高线图 (主线 {major}m)"
                    cbar_label = '高程 (m)'
                except Exception as e:
                    print(f"渲染等高线图失败 (回退): {e}")
                    pcm = ax.tricontourf(tri, z, levels=15, cmap=cmap)
                    cbar_label = '高程 (m)'; title = '等高线图 (默认)'

            elif map_type == 'slope':
                if self.slope_data is None: self.calculate_slope_aspect()
                if self.slope_data is not None:
                    pcm = ax.tripcolor(tri, self.slope_data, cmap=cmap, edgecolors='none')
                    cbar_label = '坡度 (°)'
                    title = '坡度图'
                else: title = "坡度图 (未计算)"

            elif map_type == 'aspect':
                if self.aspect_data is None: self.calculate_slope_aspect()
                if self.aspect_data is not None:
                    try: cmap_hsv = matplotlib.colormaps['hsv']
                    except KeyError: cmap_hsv = plt.get_cmap('hsv')
                    pcm = ax.tripcolor(tri, self.aspect_data, cmap=cmap_hsv, edgecolors='none', vmin=0, vmax=360)
                    cbar_label = '坡向'
                    title = '坡向图'
                else: title = "坡向图 (未计算)"

            elif map_type == 'difference':
                if self.data_compare is not None and self.interpolator_compare is not None and self.grid_z is not None:
                    grid_z_original = self.grid_z
                    Xg, Yg = np.meshgrid(self.grid_x, self.grid_y)
                    grid_z_compare = self.interpolator_compare(Xg, Yg)
                    diff_grid = grid_z_compare - grid_z_original
                    max_abs_diff = np.nanmax(np.abs(diff_grid)); max_abs_diff = max(max_abs_diff, 1e-6)
                    try: cmap_diff = matplotlib.colormaps['coolwarm']
                    except KeyError: cmap_diff = plt.get_cmap('coolwarm')
                    
                    pcm = ax.imshow(diff_grid, extent=(self.grid_x.min(), self.grid_x.max(), self.grid_y.min(), self.grid_y.max()),
                                    origin='lower', cmap=cmap_diff, vmin=-max_abs_diff, vmax=max_abs_diff, interpolation='bilinear')
                    cbar_label = '高程差 (m) [对比 - 原始]'
                    title = '差值图 (挖: 蓝 / 填: 红)'
                else:
                    title = "差值图 (数据不足)"
                    ax.text(0.5, 0.5, '请先加载对比DTM并生成格网', color='yellow', ha='center', va='center', transform=ax.transAxes)

            elif map_type == 'viewshed':
                if self.viewshed_data is not None:
                    try: cmap_gray = matplotlib.colormaps['gray']
                    except KeyError: cmap_gray = plt.get_cmap('gray')
                    ax.tricontourf(tri, z, levels=15, cmap=cmap_gray, alpha=0.6) # 底图
                    visible_data = self.viewshed_data.astype(float); visible_data[visible_data == 0] = np.nan
                    try: cmap_green = matplotlib.colors.ListedColormap(['#00FF00'])
                    except: cmap_green = 'Greens'
                    
                    # 使用 pcolormesh 绘制可见区域 (无色条)
                    Xg, Yg = np.meshgrid(self.grid_x, self.grid_y)
                    ax.pcolormesh(Xg, Yg, visible_data, cmap=cmap_green, alpha=0.5, shading='auto')
                    
                    if self.viewshed_observer_pos:
                        obs_x, obs_y = self.viewshed_observer_pos
                        ax.plot(obs_x, obs_y, 'r*', markersize=12, label="观察点")
                    title = '视域分析结果 (绿色=可见)'
                    pcm = None # 视域图通常不需要色条
                else:
                    title = "视域分析图 (未计算)"
                    ax.text(0.5, 0.5, '请先运行视域分析', color='yellow', ha='center', va='center', transform=ax.transAxes)

            # --- 通用后处理 ---
            ax.set_title(title, color='white')
            ax.set_xlabel('X', color='white'); ax.set_ylabel('Y', color='white')
            ax.tick_params(colors='white', labelcolor='white')
            for spine in ax.spines.values(): spine.set_color('#888888')
            try: ax.set_aspect('equal', adjustable='box')
            except: pass

            # 添加色条 (如果 pcm 有效)
            if pcm is not None:
                cbar = fig.colorbar(pcm, ax=ax, fraction=0.046, pad=0.04) # 调整 fraction/pad
                cbar.set_label(cbar_label, color='white')
                cbar.ax.yaxis.set_tick_params(color='white', labelcolor='white')
                if map_type == 'aspect': # 特殊处理坡向刻度
                    cbar.set_ticks([0, 90, 180, 270, 360])
                    cbar.ax.set_yticklabels(['北', '东', '南', '西', '北'])
            
            # --- 最终保存 ---
            fig.tight_layout() # 自动调整布局
            fig.savefig(buf, dpi=200, bbox_inches='tight', facecolor=fig.get_facecolor()) # 降低 DPI 节省空间
            buf.seek(0)
            
        except Exception as e:
            print(f"渲染地图图像 '{map_type}' 失败: {e}")
            buf = None # 返回 None 表示失败
        finally:
            plt.close(fig) # 确保关闭图形
            
        return buf
    
    def _render_los_map_image(self):
        """生成包含最后一次 LoS 分析结果的 2D 底图。"""
        buf = io.BytesIO()
        if self.data is None or self.triangulation is None or self.last_los_result is None:
            return None
            
        try:
            fig = Figure(facecolor='#2E2E2E')
            ax = fig.add_subplot(111, facecolor='#2E2E2E')
            x = self.data['X'].values; y = self.data['Y'].values; z = self.data['Z'].values
            tri = self.triangulation
            
            # 1. 绘制灰色等高线底图
            try: cmap_gray = matplotlib.colormaps['gray']
            except KeyError: cmap_gray = plt.get_cmap('gray')
            ax.tricontourf(tri, z, levels=15, cmap=cmap_gray, alpha=0.6)
            
            # 2. 绘制 LoS 线条
            p1, p2, is_visible = self.last_los_result
            color = '#00FF00' if is_visible else '#FF0000'
            ax.plot([p1[0], p2[0]], [p1[1], p2[1]], color=color, linestyle='--', linewidth=2, label="通视线 (LoS)")
            ax.plot([p1[0], p2[0]], [p1[1], p2[1]], 'X', color=color, markersize=10, markeredgewidth=2)
            
            # 添加标签
            ax.text(p1[0], p1[1], '  观察点', color=color, fontsize=9, ha='left', va='bottom')
            ax.text(p2[0], p2[1], '  目标点', color=color, fontsize=9, ha='left', va='bottom')

            # 3. 通用设置
            ax.set_title(f"两点通视分析 ({'通视' if is_visible else '遮挡'})", color='white')
            ax.set_xlabel('X', color='white'); ax.set_ylabel('Y', color='white')
            ax.tick_params(colors='white', labelcolor='white')
            for spine in ax.spines.values(): spine.set_color('#888888')
            try: ax.set_aspect('equal', adjustable='box')
            except: pass
            
            # 4. 保存
            fig.tight_layout()
            fig.savefig(buf, dpi=150, bbox_inches='tight', facecolor=fig.get_facecolor())
            buf.seek(0)
            
        except Exception as e:
            print(f"渲染 LoS 地图图像失败: {e}")
            buf = None
        finally:
            plt.close(fig)
            
        return buf

    def _render_3d_image(self):
        """
        返回：BytesIO PNG，包含色条
        """
        buf = io.BytesIO()
        if self.data is None or self.triangulation is None:
            return None
        try:
            fig = Figure(figsize=(8,6), facecolor='#2E2E2E')
            ax = fig.add_subplot(111, projection='3d', facecolor='#2E2E2E')
            x = self.data['X'].values; y = self.data['Y'].values; z = self.data['Z'].values
            # --- MODIFICATION: Use matplotlib.colormaps ---
            cmap_name = self.combo_colormap.currentText()
            try:
                cmap = matplotlib.colormaps[cmap_name]
            except KeyError:
                cmap = plt.get_cmap(cmap_name)
            # --- END MODIFICATION ---
            surf = ax.plot_trisurf(x, y, z, triangles=self.triangulation.triangles, cmap=cmap, linewidth=0, antialiased=True) # Use updated cmap
            cbar = fig.colorbar(surf, ax=ax, fraction=0.03, pad=0.04)
            cbar.set_label('Z (m)', color='white')
            cbar.ax.yaxis.set_tick_params(color='white', labelcolor='white')
            ax.set_xlabel('X', color='white'); ax.set_ylabel('Y', color='white')
            try:
                ax.set_zlabel('Z', color='white')
            except:
                pass
            ax.tick_params(colors='white', labelcolor='white')
            fig.savefig(buf, dpi=300, bbox_inches='tight', facecolor=fig.get_facecolor())
            buf.seek(0)
            plt.close(fig)
            return buf
        except Exception as e:
            try:
                plt.close('all')
            except:
                pass
            return None
    
    def _render_z_histogram(self):
        """
        生成高程直方图。
        返回 (BytesIO, stats_dict)
        """
        if self.data is None:
            return None, None
        try:
            z_data = self.data['Z'].values
            stats = {
                'min': float(np.nanmin(z_data)),
                'max': float(np.nanmax(z_data)),
                'mean': float(np.nanmean(z_data)),
                'median': float(np.nanmedian(z_data)),
                'std': float(np.nanstd(z_data)),
                'p25': float(np.nanpercentile(z_data, 25)),
                'p75': float(np.nanpercentile(z_data, 75))
            }

            buf = io.BytesIO()
            fig = Figure(figsize=(8, 5), facecolor='#2E2E2E')
            ax = fig.add_subplot(111, facecolor='#2E2E2E')
            
            ax.hist(z_data, bins=50, color='#00AEEF', alpha=0.7, edgecolor='#FFFFFF')
            
            ax.set_title('高程 (Z) 分布直方图', color='white')
            ax.set_xlabel('高程 (m)', color='white')
            ax.set_ylabel('频数', color='white')
            ax.tick_params(colors='white')
            ax.grid(True, linestyle='--', alpha=0.5)
            
            fig.savefig(buf, dpi=150, bbox_inches='tight', facecolor=fig.get_facecolor())
            buf.seek(0)
            plt.close(fig)
            return buf, stats
        except Exception as e:
            print(f"Error rendering Z histogram: {e}")
            plt.close('all')
            return None, None

    def _render_slope_histogram(self):
        """
        生成坡度直方图 (按面积加权)。
        返回 (BytesIO, stats_dict)
        """
        if self.slope_data is None or self.triangulation is None:
            return None, None
        try:
            # 计算每个三角面的面积 (平面)
            tri_pts = self.data[['X', 'Y']].values[self.triangulation.triangles]
            v1 = tri_pts[:, 1] - tri_pts[:, 0]
            v2 = tri_pts[:, 2] - tri_pts[:, 0]
            tri_areas_planar = 0.5 * np.abs(v1[:, 0] * v2[:, 1] - v1[:, 1] * v2[:, 0])
            total_area = np.sum(tri_areas_planar)
            
            slope_data = self.slope_data
            
            # 定义坡度分级
            bins = [0, 5, 15, 25, 35, 45, 90]
            labels = ['0-5° (平坦)', '5-15° (缓坡)', '15-25° (斜坡)', '25-35° (陡坡)', '35-45° (峭坡)', '> 45° (极陡)']
            
            # 计算每个分级的面积
            hist, _ = np.histogram(slope_data, bins=bins, weights=tri_areas_planar)
            hist_percent = (hist / total_area) * 100
            
            stats = {label: f"{percent:.2f}%" for label, percent in zip(labels, hist_percent)}
            stats['avg'] = f"{np.average(slope_data, weights=tri_areas_planar):.2f}°"

            buf = io.BytesIO()
            fig = Figure(figsize=(8, 5), facecolor='#2E2E2E')
            ax = fig.add_subplot(111, facecolor='#2E2E2E')
            
            ax.bar(labels, hist_percent, color='#FF8C00', alpha=0.8, edgecolor='#FFFFFF')
            
            ax.set_title('坡度分布直方图 (按面积加权)', color='white')
            ax.set_xlabel('坡度分级', color='white')
            ax.set_ylabel('面积占比 (%)', color='white')
            ax.tick_params(colors='white', axis='x', labelrotation=30)
            ax.grid(True, linestyle='--', alpha=0.5, axis='y')
            
            fig.savefig(buf, dpi=150, bbox_inches='tight', facecolor=fig.get_facecolor())
            buf.seek(0)
            plt.close(fig)
            return buf, stats
        except Exception as e:
            print(f"Error rendering Slope histogram: {e}")
            plt.close('all')
            return None, None

    def _render_aspect_histogram(self):
        """
        生成坡向玫瑰图 (按面积加权)。
        返回 (BytesIO, stats_dict)
        """
        if self.aspect_data is None or self.triangulation is None:
            return None, None
        try:
            # 计算三角面平面面积
            tri_pts = self.data[['X', 'Y']].values[self.triangulation.triangles]
            v1 = tri_pts[:, 1] - tri_pts[:, 0]
            v2 = tri_pts[:, 2] - tri_pts[:, 0]
            tri_areas_planar = 0.5 * np.abs(v1[:, 0] * v2[:, 1] - v1[:, 1] * v2[:, 0])
            total_area = np.sum(tri_areas_planar)
            
            aspect_data = self.aspect_data
            
            # 过滤掉平坦区域 (aspect == -1)
            valid_mask = aspect_data != -1
            aspect_data = aspect_data[valid_mask]
            tri_areas_planar = tri_areas_planar[valid_mask]
            
            # 定义8个方向 + 平坦
            bins = [-1, 0, 22.5, 67.5, 112.5, 157.5, 202.5, 247.5, 292.5, 337.5, 360]
            labels = ['北', '东北', '东', '东南', '南', '西南', '西', '西北']
            
            # 手动合并 '北' (337.5-360 和 0-22.5)
            hist, _ = np.histogram(aspect_data, bins=bins, weights=tri_areas_planar)
            hist_north = hist[0] + hist[-1]
            hist_other = hist[1:-1]
            hist_final = np.concatenate(([hist_north], hist_other))
            
            # 计算平坦面积
            flat_area = np.sum(tri_areas_planar[~valid_mask])
            hist_final = np.concatenate(([flat_area], hist_final))
            labels_final = ['平坦 (-1°)'] + labels
            
            total_area_with_flat = np.sum(hist_final)
            hist_percent = (hist_final / total_area_with_flat) * 100
            
            stats = {label: f"{percent:.2f}%" for label, percent in zip(labels_final, hist_percent)}

            buf = io.BytesIO()
            fig = Figure(figsize=(7, 7), facecolor='#2E2E2E')
            ax = fig.add_subplot(111, polar=True, facecolor='#2E2E2E') # 极坐标
            
            # 极坐标角度 (弧度)
            angles = np.deg2rad(np.array([0, 45, 90, 135, 180, 225, 270, 315]))
            # 玫瑰图数据 (不包括 '平坦')
            data_rose = hist_percent[1:]
            
            # 设置极坐标
            ax.set_theta_zero_location('N') # 0度设为北方
            ax.set_theta_direction(-1) # 顺时针
            ax.set_thetagrids(np.array([0, 45, 90, 135, 180, 225, 270, 315]), 
                              labels=['北 (N)', '东北 (NE)', '东 (E)', '东南 (SE)', '南 (S)', '西南 (SW)', '西 (W)', '西北 (NW)'])
            ax.tick_params(colors='white')
            
            ax.bar(angles, data_rose, width=np.deg2rad(45), color='#4A90E2', alpha=0.8, edgecolor='white')
            
            ax.set_title('坡向分布玫瑰图 (按面积加权)', color='white', y=1.1)
            ax.spines['polar'].set_color('white')
            
            fig.savefig(buf, dpi=150, bbox_inches='tight', facecolor=fig.get_facecolor())
            buf.seek(0)
            plt.close(fig)
            return buf, stats
        except Exception as e:
            print(f"Error rendering Aspect histogram: {e}")
            plt.close('all')
            return None, None
            
    # --- 结束新增 ---

    # ------------------ UI 小工具 ------------------
    def on_3d_mode_changed(self, text):
        self.current_3d_mode = "TIN_Mesh" if "TIN" in text else "Smoothed_Grid"
        self.update_plots()

    def on_2d_mode_changed(self, text):
        mapping = {"等高线图 (Contour)":"TIN_Contour","坡度图 (Slope)":"Slope","坡向图 (Aspect)":"Aspect","差值图 (Difference Map)":"Difference","视域分析 (Viewshed)":"Viewshed"}
        self.current_analysis_mode = mapping.get(text, "TIN_Contour")
        self.update_plots()

    def on_colormap_changed(self, text):
        self.update_plots()

    def on_grid_spacing_changed(self):
        try:
            raw = self.line_grid_spacing.text()
            if raw is None:
                raise ValueError("输入为空")
            txt = raw.strip()
            # quick normalization of common unicode punctuation and spaces
            txt = txt.replace('\u00A0', '')
            txt = txt.replace('\u2009', '')
            txt = txt.replace(' ', '')
            txt = txt.replace('，', '.')
            txt = txt.replace('．', '.')

            # Try direct float first
            try:
                val = float(txt)
            except Exception as e1:
                # try replace comma with dot (common decimal separator in some locales)
                try:
                    val = float(txt.replace(',', '.'))
                except Exception:
                    # fallback: extract first numeric-like token using regex
                    m = re.search(r"[-+]?\d+[\d,\.]*\d*", txt)
                    if m:
                        candidate = m.group(0)
                        candidate = candidate.replace(',', '.')
                        val = float(candidate)
                    else:
                        raise ValueError(f"无法解析为数字: {repr(raw)}")
            # basic sanity checks
            if not np.isfinite(val) or val <= 0:
                raise ValueError("间距必须为正数")
            # clamp to reasonable bounds to avoid accidental OOM
            min_spacing = 0.01
            max_spacing = 10000.0
            if val < min_spacing:
                QMessageBox.warning(self, "输入提醒", f"格网间距过小，已调整为最小允许值 {min_spacing}")
                val = min_spacing
                self.line_grid_spacing.setText(f"{val}")
            if val > max_spacing:
                QMessageBox.warning(self, "输入提醒", f"格网间距过大，已调整为最大允许值 {max_spacing}")
                val = max_spacing
                self.line_grid_spacing.setText(f"{val}")

            self.grid_spacing = val
            # kick off grid generation (background) and refresh plots
            self.generate_grid_data()
            self.update_plots()
        except Exception as e:
            # Write debug log to help diagnose weird input cases
            try:
                logp = os.path.join(os.path.dirname(__file__), 'grid_spacing_debug.log')
                with open(logp, 'a', encoding='utf-8') as lf:
                    lf.write(f"{datetime.now().isoformat()} RAW={repr(raw)} CLEAN={repr(txt)} ERR={repr(str(e))}\n")
            except Exception:
                pass
            # show the actual error to help debugging (trim long messages)
            msg = str(e)
            if len(msg) > 240:
                msg = msg[:240] + '...'
            QMessageBox.warning(self, "输入错误", f"格网间距无效: {msg}")

    def toggle_data_points_visibility(self):
        """切换 2D 视图上数据点的可见性。"""
        self.show_data_points = self.btn_toggle_points.isChecked()
        
        if self.show_data_points:
            self.btn_toggle_points.setText("隐藏数据点")
        else:
            self.btn_toggle_points.setText("显示数据点")
            
        # 触发 2D 画布重绘
        self.update_plots()

    def update_ui_state(self, enabled=False):
        # --- MODIFICATION: Update Widget List for enabling/disabling ---
        widgets = [
            self.combo_colormap, self.combo_2d_mode, self.combo_3d_mode, self.line_grid_spacing,self.btn_toggle_points,
            self.btn_apply_z_filter, self.btn_reset_z_filter, self.line_min_z, self.line_max_z,
            self.line_major_interval, self.line_minor_interval, self.line_base_elevation,
            self.btn_profile, self.btn_export_2d, self.btn_export_3d, self.btn_export_grid, self.btn_export_report,
            self.btn_popout_2d, self.btn_popout_3d, self.btn_reset_view,
            self.btn_load_compare,self.btn_load_vector,self.btn_query_tool,self.btn_add_point,self.btn_delete_point,
            self.btn_run_viewshed,self.btn_check_los,self.btn_export_modified_data,self.btn_zonal_stats
            # Removed: self.btn_rotate_up, self.btn_rotate_down, self.btn_rotate_left, self.btn_rotate_right
        ]

        # --- NEW --- 添加土方量按钮到列表
        try:
            widgets.append(self.btn_calc_volume)
        except AttributeError:
            pass # 控件可能尚未创建
        # --- END NEW ---

        # =======================================================
        # 新增：工具按钮也受使能状态控制
        # =======================================================
        try:
            widgets.extend([
                self.btn_tool_coord, self.btn_tool_distance, self.btn_tool_intersect,
                self.btn_tool_mapnum, self.btn_tool_leveling
            ])
        except AttributeError:
            pass # 控件可能尚未创建

        for w in widgets:
            try:
                w.setEnabled(enabled)
            except:
                pass
        self.btn_clear.setEnabled(True)

        # 实验工具按钮应始终可用
        try:
            self.btn_tool_coord.setEnabled(True)
            self.btn_tool_distance.setEnabled(True)
            self.btn_tool_intersect.setEnabled(True)
            self.btn_tool_mapnum.setEnabled(True)
            self.btn_tool_leveling.setEnabled(True)
        except AttributeError:
            pass

        if not enabled:
            self.raw_data = None; self.data = None; self.triangulation = None; self.interpolator = None
            self.grid_x = self.grid_y = self.grid_z = None; self.slope_data = self.aspect_data = None
            self.data_compare = None
            self.triangulation_compare = None
            self.interpolator_compare = None
            self.vector_layers = []
            self.is_querying = False
            self.is_adding_point = False
            self.is_deleting_point = False
            try:
                self.btn_query_tool.setChecked(False)
                self.btn_add_point.setChecked(False)
                self.btn_delete_point.setChecked(False)
            except: pass

            self.show_data_points = False
            try:
                self.btn_toggle_points.setChecked(False)
                self.btn_toggle_points.setText("显示数据点")
            except: pass

            self.last_volume_results = None

            self.viewshed_data = None
            self.viewshed_observer_pos = None
            self.is_setting_viewshed = False
            try:
                self.btn_run_viewshed.setChecked(False)
            except: pass

            self.is_checking_los = False
            self.los_points = []
            self.last_los_result = None
            try:
                self.btn_check_los.setChecked(False)
            except: pass

            try:
                self.canvas_2d.axes.clear(); self.canvas_3d.axes.clear()
                self.canvas_2d.axes.set_title("2D 等高线图 (请加载数据)", color='white')
                self.canvas_3d.axes.set_title("3D DTM 模型 (请加载数据)", color='white')
                self.canvas_2d.draw(); self.canvas_3d.draw()
            except:
                pass

    # ------------------ 地形定量分析 ------------------
    def update_terrain_stats(self):
        if self.data is None or len(self.data) < 3:
            self.lbl_area_planar.setText("平面面积：-- m²")
            self.lbl_area_surface.setText("表面面积：-- m²")
            self.lbl_z_range.setText("高程范围：-- ~ -- m")
            self.lbl_slope_range.setText("坡度范围：--° ~ --°")
            self.lbl_slope_avg.setText("平均坡度：--°")
            return
        try:
            self.calculate_areas()
            self.calculate_slope_aspect()
            zmin, zmax = self.data['Z'].min(), self.data['Z'].max()
            self.lbl_area_planar.setText(f"平面面积：{self.planar_area:,.2f} m²")
            self.lbl_area_surface.setText(f"表面面积：{self.surface_area:,.2f} m²")
            self.lbl_z_range.setText(f"高程范围：{zmin:.2f} ~ {zmax:.2f} m")
            self.lbl_slope_range.setText(f"坡度范围：{self.stats_slope_min:.2f}° ~ {self.stats_slope_max:.2f}°")
            self.lbl_slope_avg.setText(f"平均坡度：{self.stats_slope_avg:.2f}°")
        except Exception as e:
            QMessageBox.critical(self, "分析失败", str(e))

    # ---------------- Background workers ----------------
    # Worker that computes Delaunay, Triangulation, interpolator, slope/aspect and areas
    class _ComputeWorker(QObject):
        finished = pyqtSignal(object, object, object)  # triangulation, interpolator, extra dict
        error = pyqtSignal(str)

        def __init__(self, x, y, z):
            super().__init__()
            self.x = x; self.y = y; self.z = z

        @pyqtSlot()
        def run(self):
            try:
                pts = np.vstack((self.x, self.y)).T
                dela = Delaunay(pts)
                tri = Triangulation(self.x, self.y, dela.simplices)
                interp = LinearTriInterpolator(tri, self.z)
                # calculate slope/aspect and areas locally, return as extra
                # simple implementations (duplicate of MainWindow methods)
                # slope/aspect
                triangles = dela.simplices
                p1 = np.vstack((self.x[triangles[:,0]], self.y[triangles[:,0]], self.z[triangles[:,0]])).T
                p2 = np.vstack((self.x[triangles[:,1]], self.y[triangles[:,1]], self.z[triangles[:,1]])).T
                p3 = np.vstack((self.x[triangles[:,2]], self.y[triangles[:,2]], self.z[triangles[:,2]])).T
                V12 = p2 - p1; V13 = p3 - p1
                A = V12[:,1]*V13[:,2] - V12[:,2]*V13[:,1]
                B = V12[:,2]*V13[:,0] - V12[:,0]*V13[:,2]
                C = V12[:,0]*V13[:,1] - V12[:,1]*V13[:,0]
                horiz = np.sqrt(A**2 + B**2)
                S_rad = np.arctan2(horiz, np.abs(C))
                slope_data = 90 - np.degrees(S_rad)
                angle_from_east = np.degrees(np.arctan2(-B, -A))
                aspect_deg = 90 - angle_from_east
                aspect = np.where(aspect_deg < 0, 360 + aspect_deg, aspect_deg)
                aspect = np.where(aspect >= 360, aspect - 360, aspect)
                flat_mask = slope_data < 0.001
                aspect[flat_mask] = -1.0
                # areas
                V12 = p2 - p1; V13 = p3 - p1
                cross = np.cross(V12, V13)
                areas = 0.5 * np.sqrt(np.sum(cross**2, axis=1))
                surface_area = np.sum(areas)
                min_x, max_x = self.x.min(), self.x.max(); min_y, max_y = self.y.min(), self.y.max()
                planar_area = (max_x - min_x) * (max_y - min_y)

                extra = {
                    'slope_data': slope_data,
                    'aspect_data': aspect,
                    'surface_area': surface_area,
                    'planar_area': planar_area
                }
                self.finished.emit(tri, interp, extra)
            except Exception as e:
                self.error.emit(str(e))

    def start_compute_worker(self, x, y, z):
        # Create thread and worker
        self._compute_thread = QThread()
        self._compute_worker = MainWindow._ComputeWorker(x, y, z)
        self._compute_worker.moveToThread(self._compute_thread)
        self._compute_thread.started.connect(self._compute_worker.run)
        self._compute_worker.finished.connect(self.on_compute_finished)
        self._compute_worker.error.connect(self.on_compute_error)
        self._compute_worker.finished.connect(self._compute_thread.quit)
        self._compute_worker.finished.connect(self._compute_worker.deleteLater)
        self._compute_thread.finished.connect(self._compute_thread.deleteLater)
        self._compute_thread.start()

    def on_compute_finished(self, triangulation, interpolator, extra):
        try:
            self.triangulation = triangulation
            self.interpolator = interpolator
            self.slope_data = extra.get('slope_data')
            self.aspect_data = extra.get('aspect_data')
            self.surface_area = extra.get('surface_area', 0.0)
            self.planar_area = extra.get('planar_area', 0.0)
            # update UI
            try:
                self.update_terrain_stats()
            except:
                pass
            self.update_plots()
        except Exception as e:
            QMessageBox.critical(self, "错误", f"后台计算完成但应用失败: {e}")

    def on_compute_error(self, msg):
        QMessageBox.critical(self, "后台计算出错", msg)
    
    def load_comparison_data(self):
        """加载用于差分分析的第二个 DTM 文件。"""
        path, _ = QFileDialog.getOpenFileName(self, "选择对比 DTM 文件", "", "CSV (*.csv);;DAT (*.dat);;TXT (*.txt)")
        if not path:
            return
        
        try:
            # (这部分逻辑与 load_data 相同)
            ext = path.lower().split('.')[-1]
            if ext == 'csv':
                df = pd.read_csv(path)
                if set(['X', 'Y', 'Z']).issubset(df.columns):
                    df = df[['X', 'Y', 'Z']].copy()
                else:
                    mapping = ColumnMappingDialog.get_mapping(df.columns.tolist(), self)
                    if mapping is None:
                        return
                    df = df[[mapping[0], mapping[1], mapping[2]]].rename(columns={mapping[0]:'X', mapping[1]:'Y', mapping[2]:'Z'})
            else:
                with open(path, 'r') as f:
                    lines = f.readlines()
                parsed = []
                for ln in lines:
                    ln = ln.strip()
                    if not ln or ln.startswith('#'):
                        continue
                    parts = re.split(r'[\s,]+', ln)
                    if len(parts) >= 3:
                        try:
                            x, y, z = map(float, parts[:3])
                            parsed.append((x, y, z))
                        except:
                            continue
                df = pd.DataFrame(parsed, columns=['X','Y','Z'])
            
            if df is None or len(df) < 3:
                raise ValueError("对比 DTM 数据点不足。")
            
            df.dropna(subset=['X','Y','Z'], inplace=True)
            df.drop_duplicates(subset=['X','Y'], inplace=True)
            self.data_compare = df.reset_index(drop=True)
            
            # 为对比 DTM 启动后台计算
            self.start_compute_compare_worker(self.data_compare['X'].values, self.data_compare['Y'].values, self.data_compare['Z'].values)
            QMessageBox.information(self, "正在加载", "对比 DTM 正在后台计算...")

        except Exception as e:
            QMessageBox.critical(self, "加载对比 DTM 失败", str(e))
            self.data_compare = None

    def start_compute_compare_worker(self, x, y, z):
        """启动对比 DTM 的后台计算线程。"""
        # Create thread and worker
        self._compute_thread_compare = QThread()
        # 重用 _ComputeWorker 类
        self._compute_worker_compare = MainWindow._ComputeWorker(x, y, z)
        self._compute_worker_compare.moveToThread(self._compute_thread_compare)
        
        # 连接到独立的槽
        self._compute_thread_compare.started.connect(self._compute_worker_compare.run)
        self._compute_worker_compare.finished.connect(self.on_compute_compare_finished)
        self._compute_worker_compare.error.connect(self.on_compute_compare_error)
        
        # 清理
        self._compute_worker_compare.finished.connect(self._compute_thread_compare.quit)
        self._compute_worker_compare.finished.connect(self._compute_worker_compare.deleteLater)
        self._compute_thread_compare.finished.connect(self._compute_thread_compare.deleteLater)
        
        self._compute_thread_compare.start()

    def on_compute_compare_finished(self, triangulation, interpolator, extra):
        """对比 DTM 后台计算完成的槽。"""
        try:
            self.triangulation_compare = triangulation
            self.interpolator_compare = interpolator
            QMessageBox.information(self, "完成", f"对比 DTM 已成功加载并计算 (点数: {len(self.data_compare)})。")
        except Exception as e:
            QMessageBox.critical(self, "错误", f"对比 DTM 计算完成但应用失败: {e}")
            self.data_compare = None
            self.triangulation_compare = None
            self.interpolator_compare = None

    def on_compute_compare_error(self, msg):
        """对比 DTM 后台计算出错的槽。"""
        QMessageBox.critical(self, "对比 DTM 后台计算出错", msg)
        self.data_compare = None
        self.triangulation_compare = None
        self.interpolator_compare = None
    
    def load_vector_layer(self):
        """加载 GIS 矢量图层 (Shapefile 或 GeoJSON) 并存储。"""
        # 注意：Geopandas 可以自动处理 .shp, .geojson, .json
        path, _ = QFileDialog.getOpenFileName(self, "选择矢量图层文件", "", 
                                              "Shapefiles (*.shp);;GeoJSON (*.geojson *.json);;All Files (*)")
        if not path:
            return
            
        try:
            # 使用 Geopandas 读取文件
            gdf = gpd.read_file(path)
            
            if gdf.empty:
                QMessageBox.warning(self, "图层为空", "该矢量文件不包含任何要素。")
                return

            # 将加载的 GeoDataFrame 存储到列表中
            self.vector_layers.append(gdf)
            
            QMessageBox.information(self, "加载成功", 
                                    f"已加载矢量图层: {os.path.basename(path)}\n"
                                    f"要素数量: {len(gdf)}")
            
            # 立即刷新 2D 视图
            self.update_plots()

        except Exception as e:
            QMessageBox.critical(self, "矢量图层加载失败", 
                                 f"无法读取文件: {path}\n"
                                 f"错误: {e}\n\n"
                                 "请确保已安装 'geopandas' 及其所有依赖 (如 fiona)。")

    # GridWorker: generate grid in background with progress updates
    class _GridWorker(QObject):
        finished = pyqtSignal(object)  # grid_z
        progress = pyqtSignal(int)
        error = pyqtSignal(str)

        def __init__(self, interpolator, grid_x, grid_y, chunk_size=10000):
            super().__init__()
            self.interpolator = interpolator
            self.grid_x = grid_x
            self.grid_y = grid_y
            self.chunk_size = chunk_size
            self._cancel = False

        def cancel(self):
            self._cancel = True

        @pyqtSlot()
        def run(self):
            try:
                Xg, Yg = np.meshgrid(self.grid_x, self.grid_y)
                total = Xg.size
                vals = np.empty(total)
                pts_x = Xg.ravel(); pts_y = Yg.ravel()
                i = 0
                while i < total:
                    if self._cancel:
                        self.error.emit('cancelled')
                        return
                    j = min(i + self.chunk_size, total)
                    sub = self.interpolator(pts_x[i:j], pts_y[i:j])
                    # sub may be masked; convert to float with nan
                    try:
                        vals[i:j] = np.asarray(sub)
                    except Exception:
                        # fallback: fill with nan
                        vals[i:j] = np.nan
                    i = j
                    pct = int(100.0 * i / total)
                    self.progress.emit(pct)
                grid_z = vals.reshape(Xg.shape)
                self.finished.emit(grid_z)
            except Exception as e:
                self.error.emit(str(e))
    
    # ------------------ 交互式工具 (新功能) ------------------
    
    def toggle_query_mode(self):
        """切换属性查询模式。"""
        # 切换状态
        self.is_querying = self.btn_query_tool.isChecked()
        
        # 关闭所有其他交互模式
        if self.is_querying:
            self.btn_add_point.setChecked(False)
            self.is_adding_point = False
            self.btn_delete_point.setChecked(False); self.is_deleting_point = False
            self.btn_profile.setChecked(False) # (假设 btn_profile 也是 checkable)
            self.is_profiling = False
            self.btn_multi_profile.setChecked(False)
            self.multi_profile_mode = False
            QMessageBox.information(self, "属性查询", "已启用属性查询模式。\n请在 2D 视图上点击以查询信息。")
        
    def toggle_add_point_mode(self):
        """切换添加数据点模式。"""
        # 切换状态
        self.is_adding_point = self.btn_add_point.isChecked()
        
        # 关闭所有其他交互模式
        if self.is_adding_point:
            self.btn_query_tool.setChecked(False)
            self.is_querying = False
            self.btn_delete_point.setChecked(False); self.is_deleting_point = False
            self.btn_profile.setChecked(False)
            self.is_profiling = False
            self.btn_multi_profile.setChecked(False)
            self.multi_profile_mode = False
            QMessageBox.information(self, "添加数据点", "已启用添加数据点模式。\n请在 2D 视图上点击以选择位置。")

    def handle_query_click(self, x, y):
        """处理属性查询点击事件。"""
        if self.interpolator is None or self.triangulation is None:
            QMessageBox.warning(self, "查询失败", "插值器 (Interpolator) 尚未准备好。")
            return

        try:
            # 1. 查询插值高程 (Z)
            z_val = self.interpolator(x, y)
            if np.isnan(z_val):
                z_str = "N/A (点在TIN范围外)"
            else:
                z_str = f"{float(z_val):.3f} m"

            info = [
                f"坐标 (X): {x:.3f}",
                f"坐标 (Y): {y:.3f}",
                f"插值高程 (Z): {z_str}"
            ]

            # 2. 查询坡度/坡向 (基于三角面)
            if self.slope_data is not None and self.aspect_data is not None:
                # 查找点所在的三角形索引
                try:
                    finder = self.triangulation.get_trifinder()
                    tri_index = finder(x, y) # 6.0 修正：finder(x,y) 返回单个索引
                    
                    if tri_index == -1:
                        info.append("坡度: N/A (范围外)")
                        info.append("坡向: N/A (范围外)")
                    else:
                        slope_val = self.slope_data[tri_index]
                        aspect_val = self.aspect_data[tri_index]
                        info.append(f"坡度 (所在三角面): {slope_val:.2f}°")
                        info.append(f"坡向 (所在三角面): {aspect_val:.2f}°")
                except Exception as e:
                    info.append(f"坡度/坡向查询失败: {e}")
            
            QMessageBox.information(self, "属性查询结果", "\n".join(info))
            
        except Exception as e:
            QMessageBox.critical(self, "查询失败", f"查询时发生错误: {e}")

    def handle_add_point_click(self, x, y):
        """处理添加数据点点击事件。"""
        if self.data is None or self.raw_data is None:
            QMessageBox.warning(self, "操作失败", "请先加载一组基础数据。")
            self.toggle_add_point_mode() # 自动退出模式
            return

        try:
            # 1. 弹窗获取 Z 值
            z_val, ok = QInputDialog.getDouble(self, "输入高程", 
                                               f"请输入点 ({x:.2f}, {y:.2f}) 的高程 (Z) 值:", 
                                               decimals=3)
            
            if not ok:
                # 用户点击了取消
                self.btn_add_point.setChecked(False) # 取消按钮选中
                self.is_adding_point = False
                return

            # 2. 将新点添加到 self.data 和 self.raw_data
            new_point_df = pd.DataFrame([{'X': x, 'Y': y, 'Z': z_val}])
            
            self.data = pd.concat([self.data, new_point_df], ignore_index=True)
            self.raw_data = pd.concat([self.raw_data, new_point_df], ignore_index=True)
            
            QMessageBox.information(self, "添加成功", f"已添加点 ({x:.2f}, {y:.2f}, {z_val:.3f})。\n"
                                                  "将立即重新计算三角网 (TIN)...")

            # 3. 重置分析数据，触发重新计算
            self.triangulation = None
            self.interpolator = None
            self.grid_x = self.grid_y = self.grid_z = None
            self.slope_data = self.aspect_data = None
            self.surface_area = self.planar_area = 0.0
            
            # 4. 触发重绘 (这会自动调用 start_compute_worker)
            self.update_plots()
            
            # 5. 退出添加模式
            self.btn_add_point.setChecked(False)
            self.is_adding_point = False

        except Exception as e:
            QMessageBox.critical(self, "添加失败", f"添加点时发生错误: {e}")
            self.btn_add_point.setChecked(False)
            self.is_adding_point = False
    
    def toggle_delete_point_mode(self):
        """切换删除数据点模式。"""
        # 切换状态
        self.is_deleting_point = self.btn_delete_point.isChecked()
        
        # 关闭所有其他交互模式
        if self.is_deleting_point:
            self.btn_query_tool.setChecked(False)
            self.is_querying = False
            self.btn_add_point.setChecked(False)
            self.is_adding_point = False
            self.btn_profile.setChecked(False) # (假设 btn_profile 也是 checkable)
            self.is_profiling = False
            self.btn_multi_profile.setChecked(False)
            self.multi_profile_mode = False
            QMessageBox.information(self, "删除数据点", "已启用删除数据点模式。\n请在 2D 视图上点击您想删除的点附近。")

    def handle_delete_point_click(self, x, y):
        """处理删除数据点点击事件。"""
        # 至少需要3个点来构建TIN，因此我们不允许删除到3个点以下
        if self.data is None or len(self.data) < 4: 
            QMessageBox.warning(self, "操作失败", "数据点不足 (至少需要4个点才能删除)。")
            self.btn_delete_point.setChecked(False)
            self.is_deleting_point = False
            return

        try:
            # 1. 找到 self.data 中最近的点
            #    (self.data 是当前显示的数据)
            distances = np.sqrt((self.data['X'] - x)**2 + (self.data['Y'] - y)**2)
            nearest_index_in_data = distances.idxmin()
            point_to_delete = self.data.loc[nearest_index_in_data]
            px, py, pz = point_to_delete['X'], point_to_delete['Y'], point_to_delete['Z']

            # 2. 弹窗确认
            reply = QMessageBox.question(self, '确认删除',
                                         f"您是否要删除最近的数据点？\n\n"
                                         f"X: {px:.3f}\n"
                                         f"Y: {py:.3f}\n"
                                         f"Z: {pz:.3f}",
                                         QMessageBox.Yes | QMessageBox.No, QMessageBox.No)

            if reply == QMessageBox.Yes:
                # 3. 从 self.data 和 self.raw_data 中删除
                
                # 3a. 找到 self.raw_data 中的对应点 (使用浮点容差)
                #    这很重要，因为 self.data 可能是过滤后的，索引不同
                tolerance = 1e-6
                raw_indices = self.raw_data[
                    (np.abs(self.raw_data['X'] - px) < tolerance) &
                    (np.abs(self.raw_data['Y'] - py) < tolerance) &
                    (np.abs(self.raw_data['Z'] - pz) < tolerance)
                ].index
                
                if not raw_indices.empty:
                    raw_index_to_drop = raw_indices[0] # 删除第一个匹配项
                    self.raw_data = self.raw_data.drop(raw_index_to_drop)
                else:
                    # 如果在 raw_data 找不到（理论上不应发生），也打印一个警告
                    print(f"Warning: Point ({px},{py},{pz}) not found in raw_data for deletion.")

                # 3b. 从 self.data 中删除 (使用之前找到的索引)
                self.data = self.data.drop(nearest_index_in_data)
                
                # 3c. 重置索引以避免后续操作出错
                self.data = self.data.reset_index(drop=True)
                self.raw_data = self.raw_data.reset_index(drop=True)

                QMessageBox.information(self, "删除成功", "已删除数据点。\n将立即重新计算三角网 (TIN)...")
                
                # 4. 重置分析数据，触发重新计算
                self.triangulation = None
                self.interpolator = None
                self.grid_x = self.grid_y = self.grid_z = None
                self.slope_data = self.aspect_data = None
                self.surface_area = self.planar_area = 0.0
                
                # 5. 触发重绘 (这会自动调用 start_compute_worker)
                self.update_plots()
            
        except Exception as e:
            QMessageBox.critical(self, "删除失败", f"删除点时发生错误: {e}")
        
        # 6. 无论成功、失败还是取消，都退出删除模式
        self.btn_delete_point.setChecked(False)
        self.is_deleting_point = False

    def generate_grid_data(self):
        # start background grid generation using _GridWorker and show progress dialog
        if self.interpolator is None:
            return
        try:
            spacing = float(self.line_grid_spacing.text())
        except:
            spacing = self.grid_spacing
        # validate spacing
        if not np.isfinite(spacing) or spacing <= 0:
            QMessageBox.warning(self, "输入错误", "格网间距必须为正数")
            return

        x = self.data['X'].values; y = self.data['Y'].values
        min_x, max_x = x.min(), x.max(); min_y, max_y = y.min(), y.max()
        grid_x = np.arange(min_x, max_x+spacing, spacing)
        grid_y = np.arange(min_y, max_y+spacing, spacing)

        # safety: prevent creating excessively large grids that may crash the app
        max_points = int(5e6)  # allow up to ~5 million grid cells (adjustable)
        est_points = int(grid_x.size) * int(grid_y.size)
        if est_points <= 0:
            QMessageBox.warning(self, "错误", "无法生成格网：点数为零")
            return
        if est_points > max_points:
            # suggest a larger spacing to reduce point count
            suggested = spacing * np.sqrt(est_points / max_points)
            QMessageBox.warning(self, "内存限制", f"当前格网将生成约 {est_points:,} 点，可能导致程序崩溃。\n请增大格网间距至 >= {suggested:.3f}。")
            return

        # prevent starting multiple concurrent grid tasks
        try:
            thr = getattr(self, '_grid_thread', None)
            if thr is not None:
                # prefer QThread.isRunning() if available
                is_running = False
                try:
                    if hasattr(thr, 'isRunning'):
                        is_running = thr.isRunning()
                    else:
                        # fallback: check a running attribute or truthiness
                        is_running = bool(getattr(thr, 'running', False))
                except Exception:
                    is_running = False
                if is_running:
                    QMessageBox.information(self, "处理中", "已有格网生成任务正在运行，请稍后再试")
                    return
        except Exception:
            # if any unexpected error occurs, continue to allow grid generation
            pass

        # prepare worker
        self._grid_thread = QThread()
        self._grid_worker = MainWindow._GridWorker(self.interpolator, grid_x, grid_y, chunk_size=20000)
        self._grid_worker.moveToThread(self._grid_thread)
        self._grid_thread.started.connect(self._grid_worker.run)
        # progress dialog
        from PyQt5.QtWidgets import QProgressDialog
        pd = QProgressDialog("生成格网中...", "取消", 0, 100, self)
        pd.setWindowModality(Qt.WindowModal)
        pd.setMinimumDuration(200)

        def on_progress(p):
            try:
                pd.setValue(p)
            except:
                pass

        def on_finished(grid_z):
            try:
                self.grid_x = grid_x; self.grid_y = grid_y; self.grid_z = grid_z
                pd.setValue(100)
                QMessageBox.information(self, "完成", f"生成格网：{self.grid_z.shape}")
                self.update_plots()
            finally:
                try:
                    self._grid_thread.quit()
                except:
                    pass

        def on_error(msg):
            try:
                if msg == 'cancelled':
                    QMessageBox.information(self, "已取消", "格网生成已取消")
                else:
                    QMessageBox.critical(self, "错误", f"格网生成失败: {msg}")
            finally:
                try:
                    self._grid_thread.quit()
                except:
                    pass

        pd.canceled.connect(self._grid_worker.cancel)
        self._grid_worker.progress.connect(on_progress)
        self._grid_worker.finished.connect(on_finished)
        self._grid_worker.error.connect(on_error)
        self._grid_thread.start()

    # ---------------- 2D 主界面中键平移事件 ----------------
    def on_canvas2d_button_press(self, event):
        try:
            # Matplotlib 中鼠标中键为 button == 2
            if getattr(event, 'button', None) == 2:
                ax = self.canvas_2d.axes
                self._canvas2d_pan['active'] = True
                self._canvas2d_pan['xpix0'] = getattr(event, 'x', None)
                self._canvas2d_pan['ypix0'] = getattr(event, 'y', None)
                self._canvas2d_pan['orig_xlim'] = ax.get_xlim(); self._canvas2d_pan['orig_ylim'] = ax.get_ylim()
        except Exception:
            pass

    def on_canvas2d_button_release(self, event):
        try:
            if getattr(event, 'button', None) == 2:
                self._canvas2d_pan['active'] = False
                self._canvas2d_pan['xpix0'] = None; self._canvas2d_pan['ypix0'] = None
                self._canvas2d_pan['orig_xlim'] = None; self._canvas2d_pan['orig_ylim'] = None
        except Exception:
            pass

    def on_canvas2d_motion(self, event):
        try:
            if not self._canvas2d_pan.get('active', False):
                return
            if getattr(event, 'x', None) is None or getattr(event, 'y', None) is None:
                return
            ax = self.canvas_2d.axes
            xpix = event.x; ypix = event.y
            dxpix = xpix - self._canvas2d_pan.get('xpix0', xpix)
            dypix = ypix - self._canvas2d_pan.get('ypix0', ypix)
            bbox = ax.get_window_extent().transformed(self.canvas_2d.figure.dpi_scale_trans.inverted())
            width_px = bbox.width * self.canvas_2d.figure.dpi
            height_px = bbox.height * self.canvas_2d.figure.dpi
            ox0, ox1 = self._canvas2d_pan.get('orig_xlim', ax.get_xlim())
            oy0, oy1 = self._canvas2d_pan.get('orig_ylim', ax.get_ylim())
            dxdata = dxpix * (ox1 - ox0) / max(width_px, 1)
            dydata = dypix * (oy1 - oy0) / max(height_px, 1)
            ax.set_xlim(ox0 - dxdata, ox1 - dxdata)
            ax.set_ylim(oy0 - dydata, oy1 - dydata)
            self.canvas_2d.draw_idle()
        except Exception:
            pass

    # ------------------ 3D 视角控制 ------------------
    def reset_3d_view(self):
        try:
            self.canvas_3d.axes.view_init(elev=self.canvas_3d.default_elev, azim=self.canvas_3d.default_azim)
            self.canvas_3d.draw()
        except:
            pass

    # --- MODIFICATION: Removed rotate methods as buttons are gone ---
    # def rotate_up(self): ...
    # def rotate_down(self): ...
    # def rotate_left(self): ...
    # def rotate_right(self): ...

    # -------------------- 鼠标滚轮缩放 --------------------
    def on_scroll(self, event):
        """统一滚轮事件处理：根据事件所在 axes 判断是 2D 还是 3D 并调用相应缩放函数"""
        try:
            if event.inaxes is None:
                return
            # 2D 图片（非 3d）
            if event.inaxes == getattr(self.canvas_2d, 'axes', None):
                self.zoom_2d(event)
            # 3D 图片
            elif event.inaxes == getattr(self.canvas_3d, 'axes', None):
                self.zoom_3d(event)
        except Exception:
            pass

    def zoom_2d(self, event, scale_factor=1.2):
        """以鼠标位置为中心缩放 2D 视图；向上滚轮放大，向下缩小"""
        ax = self.canvas_2d.axes
        try:
            xdata = event.xdata if event.xdata is not None else 0.5*(ax.get_xlim()[0]+ax.get_xlim()[1])
            ydata = event.ydata if event.ydata is not None else 0.5*(ax.get_ylim()[0]+ax.get_ylim()[1])
            cur_xlim = ax.get_xlim(); cur_ylim = ax.get_ylim()
            if event.button == 'up':
                scale = 1.0/scale_factor
            else:
                scale = scale_factor
            new_width = (cur_xlim[1] - cur_xlim[0]) * scale
            new_height = (cur_ylim[1] - cur_ylim[0]) * scale
            ax.set_xlim([xdata - new_width*( (xdata - cur_xlim[0])/(cur_xlim[1]-cur_xlim[0]) ),
                         xdata + new_width*( (cur_xlim[1]-xdata)/(cur_xlim[1]-cur_xlim[0]) )])
            ax.set_ylim([ydata - new_height*( (ydata - cur_ylim[0])/(cur_ylim[1]-cur_ylim[0]) ),
                         ydata + new_height*( (cur_ylim[1]-ydata)/(cur_ylim[1]-cur_ylim[0]) )])
            self.canvas_2d.draw_idle()
        except Exception:
            pass

    def zoom_3d(self, event, scale_factor=1.15):
        """对 3D 视图进行缩放：通过缩放 x/y/z 轴范围来实现近似缩放效果"""
        ax = self.canvas_3d.axes
        try:
            # 取当前 x/y/z 范围并以中心缩放（鼠标位置在 3D 中不可靠）
            cur_xlim = ax.get_xlim(); cur_ylim = ax.get_ylim(); cur_zlim = ax.get_zlim()
            # 鼠标滚轮方向
            scale = (1.0/scale_factor) if getattr(event, 'button', None) == 'up' else scale_factor

            # 中心点使用当前范围中点
            cx = 0.5 * (cur_xlim[0] + cur_xlim[1])
            cy = 0.5 * (cur_ylim[0] + cur_ylim[1])
            cz = 0.5 * (cur_zlim[0] + cur_zlim[1])

            new_xw = max((cur_xlim[1] - cur_xlim[0]) * scale, 1e-6)
            new_yw = max((cur_ylim[1] - cur_ylim[0]) * scale, 1e-6)
            new_zw = max((cur_zlim[1] - cur_zlim[0]) * scale, 1e-6)

            new_xlim = (cx - new_xw*0.5, cx + new_xw*0.5)
            new_ylim = (cy - new_yw*0.5, cy + new_yw*0.5)
            new_zlim = (cz - new_zw*0.5, cz + new_zw*0.5)

            # 确保范围有效且未反转
            if new_xlim[0] >= new_xlim[1] or new_ylim[0] >= new_ylim[1] or new_zlim[0] >= new_zlim[1]:
                return

            ax.set_xlim(new_xlim)
            ax.set_ylim(new_ylim)
            ax.set_zlim(new_zlim)
            # 关闭自动缩放以保持我们设置的范围
            try:
                ax.autoscale(enable=False)
            except Exception:
                pass
            self.canvas_3d.draw_idle()
        except Exception:
            pass

    # =======================================================
    # 新增：工具弹窗启动器 (Handlers for new buttons)
    # =======================================================
    def open_coord_tool(self):
        dlg = CoordConvertDialog(self)
        dlg.exec_()

    def open_distance_tool(self):
        dlg = DistanceCalcDialog(self)
        dlg.exec_()

    def open_intersect_tool(self):
        dlg = ForwardIntersectDialog(self)
        dlg.exec_()

    def open_mapnum_tool(self):
        dlg = MapNumberingDialog(self)
        dlg.exec_()

    def open_leveling_tool(self):
        dlg = LevelingDialog(self)
        dlg.exec_()

    # =======================================================
    # 新增：主题切换和背景管理
    # =======================================================
    def _load_background_file_list(self):
        """加载同文件夹下所有符合 'background_X.jpg' 格式的图片文件。"""
        try:
            script_dir = os.path.dirname(os.path.abspath(__file__))
            all_files = [f for f in os.listdir(script_dir) if f.startswith('background_') and f.lower().endswith('.jpg')]
            
            def sort_key(filename):
                match = re.search(r'background_(\d+)\.jpg', filename, re.IGNORECASE)
                return int(match.group(1)) if match else 9999
            
            self.background_files = sorted(all_files, key=sort_key)
            print(f"Loaded {len(self.background_files)} background images.")
        except Exception as e:
            print(f"Error loading background file list: {e}")

    def apply_ui_preferences(self, theme_name=None, font_family=None, persist=True):
        """应用 CAD 风格主题与字体偏好（不影响功能逻辑）。"""
        if theme_name:
            self.ui_theme = theme_name
        if font_family is not None:
            self.ui_font = font_family

        if persist:
            os.environ["CAD_UI_THEME"] = self.ui_theme
            os.environ["CAD_UI_FONT"] = self.ui_font or ""

        # 若处于玻璃主题，仅记录设置，待切换回 CAD 时生效
        if self.current_theme == 'glass':
            return

        app = QApplication.instance()
        if app:
            app.setStyleSheet(build_cad_stylesheet(self.ui_theme, self.ui_font))
            if self.ui_font:
                try:
                    app.setFont(QFont(self.ui_font))
                except Exception:
                    pass

        canvas_theme = 'light' if self.ui_theme == 'cad_classic' else 'dark'
        try:
            self.canvas_2d.set_theme(canvas_theme)
            self.canvas_3d.set_theme(canvas_theme)
        except Exception:
            pass

        if hasattr(self, 'label_2d'):
            self._apply_section_label_style(self.label_2d)
        if hasattr(self, 'label_3d'):
            self._apply_section_label_style(self.label_3d)

        self._apply_cad_icons()
        self.update_plots()

    def _apply_section_label_style(self, label):
        if label is None:
            return
        if self.ui_theme == 'cad_classic':
            label.setStyleSheet("color: #2B2B2B; font-weight: bold; font-size: 11pt;")
        else:
            label.setStyleSheet("color: #C8C8C8; font-weight: bold; font-size: 11pt;")

    def _set_button_icon(self, button, kind, color, accent):
        if button is None:
            return
        icon = self._make_cad_icon(kind, size=16, color=color, accent=accent)
        button.setIcon(icon)
        button.setIconSize(QSize(16, 16))

    def _make_cad_icon(self, kind, size=16, color="#D0D0D0", accent="#4AA3DF"):
        pixmap = QPixmap(size, size)
        pixmap.fill(Qt.transparent)
        painter = QPainter(pixmap)
        painter.setRenderHint(QPainter.Antialiasing)
        pen = QPen(QColor(color))
        pen.setWidthF(1.6)
        pen.setCapStyle(Qt.RoundCap)
        pen.setJoinStyle(Qt.RoundJoin)
        painter.setPen(pen)
        painter.setBrush(Qt.NoBrush)

        m = 2
        s = size - 2

        if kind == 'folder':
            painter.drawRect(m, m + 3, s - 4, s - 6)
            painter.drawRect(m + 1, m + 1, s - 8, 4)
        elif kind == 'clear':
            painter.drawLine(m + 2, m + 2, s - 2, s - 2)
            painter.drawLine(s - 2, m + 2, m + 2, s - 2)
        elif kind == 'convert':
            painter.drawLine(m + 1, size // 2, s - 1, size // 2)
            painter.drawLine(s - 4, size // 2 - 3, s - 1, size // 2)
            painter.drawLine(s - 4, size // 2 + 3, s - 1, size // 2)
            painter.drawLine(m + 1, size // 2 + 4, s - 1, size // 2 + 4)
            painter.drawLine(m + 4, size // 2 + 1, m + 1, size // 2 + 4)
            painter.drawLine(m + 4, size // 2 + 7, m + 1, size // 2 + 4)
        elif kind == 'compare':
            painter.drawRect(m + 1, m + 2, s - 7, s - 7)
            painter.drawRect(m + 4, m + 5, s - 7, s - 7)
        elif kind == 'vector':
            painter.drawLine(m + 1, s - 3, size // 2, m + 2)
            painter.drawLine(size // 2, m + 2, s - 2, s - 5)
            painter.drawEllipse(m, s - 4, 3, 3)
            painter.drawEllipse(size // 2 - 2, m + 1, 3, 3)
            painter.drawEllipse(s - 3, s - 6, 3, 3)
        elif kind == 'check':
            painter.drawLine(m + 2, size // 2, size // 2 - 1, s - 3)
            painter.drawLine(size // 2 - 1, s - 3, s - 2, m + 3)
        elif kind == 'reset':
            painter.drawArc(m + 1, m + 1, s - 4, s - 4, 30 * 16, 300 * 16)
            painter.drawLine(m + 5, m + 1, m + 1, m + 1)
            painter.drawLine(m + 1, m + 1, m + 1, m + 5)
        elif kind == 'add_point':
            painter.drawEllipse(m + 1, m + 1, s - 5, s - 5)
            painter.drawLine(size // 2, m + 4, size // 2, s - 4)
            painter.drawLine(m + 4, size // 2, s - 4, size // 2)
        elif kind == 'delete_point':
            painter.drawEllipse(m + 1, m + 1, s - 5, s - 5)
            painter.drawLine(m + 4, size // 2, s - 4, size // 2)
        elif kind == 'points':
            painter.drawEllipse(m + 2, size // 2, 2, 2)
            painter.drawEllipse(size // 2 - 1, size // 2 - 3, 2, 2)
            painter.drawEllipse(s - 4, size // 2 + 1, 2, 2)
        elif kind == 'stats':
            painter.drawRect(m + 2, s - 6, 3, 4)
            painter.drawRect(size // 2 - 1, s - 9, 3, 7)
            painter.drawRect(s - 5, s - 12, 3, 10)
        elif kind == 'volume':
            painter.drawRect(m + 2, m + 4, s - 7, s - 7)
            painter.drawRect(m + 4, m + 2, s - 7, s - 7)
            painter.drawLine(m + 2, m + 4, m + 4, m + 2)
            painter.drawLine(s - 5, m + 4, s - 3, m + 2)
            painter.drawLine(m + 2, s - 3, m + 4, s - 5)
            painter.drawLine(s - 5, s - 3, s - 3, s - 5)
        elif kind == 'profile':
            painter.drawLine(m + 1, s - 3, m + 5, s - 7)
            painter.drawLine(m + 5, s - 7, size // 2, s - 4)
            painter.drawLine(size // 2, s - 4, s - 2, m + 4)
        elif kind == 'multi_profile':
            painter.drawLine(m + 1, s - 4, m + 4, s - 7)
            painter.drawLine(m + 4, s - 7, size // 2, s - 5)
            painter.drawLine(m + 1, s - 8, size // 2 - 1, m + 4)
        elif kind == 'viewshed':
            painter.drawPolygon(QPolygonF([QPointF(m + 2, s - 3), QPointF(size // 2, m + 3), QPointF(s - 2, s - 3)]))
        elif kind == 'los':
            painter.drawLine(m + 2, s - 3, s - 2, m + 3)
            painter.drawEllipse(m + 1, s - 4, 3, 3)
            painter.drawEllipse(s - 3, m + 2, 3, 3)
        elif kind == 'query':
            painter.drawEllipse(m + 2, m + 2, s - 8, s - 8)
            painter.drawLine(size // 2 + 2, size // 2 + 2, s - 2, s - 2)
        elif kind == 'crosshair':
            painter.drawEllipse(m + 1, m + 1, s - 5, s - 5)
            painter.drawLine(size // 2, m + 2, size // 2, s - 2)
            painter.drawLine(m + 2, size // 2, s - 2, size // 2)
        elif kind == 'distance':
            painter.drawLine(m + 2, size // 2, s - 2, size // 2)
            painter.drawLine(m + 4, size // 2 - 3, m + 2, size // 2)
            painter.drawLine(m + 4, size // 2 + 3, m + 2, size // 2)
            painter.drawLine(s - 4, size // 2 - 3, s - 2, size // 2)
            painter.drawLine(s - 4, size // 2 + 3, s - 2, size // 2)
        elif kind == 'intersect':
            painter.drawLine(m + 2, m + 2, s - 2, s - 2)
            painter.drawLine(s - 2, m + 2, m + 2, s - 2)
        elif kind == 'grid':
            painter.drawRect(m + 2, m + 2, s - 6, s - 6)
            painter.drawLine(size // 2, m + 2, size // 2, s - 4)
            painter.drawLine(m + 2, size // 2, s - 4, size // 2)
        elif kind == 'level':
            painter.drawLine(m + 2, size // 2, s - 2, size // 2)
            painter.drawEllipse(size // 2 - 2, size // 2 - 2, 4, 4)
        elif kind == 'export_image':
            painter.drawRect(m + 2, m + 2, s - 6, s - 6)
            painter.drawLine(m + 3, s - 5, size // 2, m + 5)
            painter.drawLine(size // 2, m + 5, s - 3, s - 5)
        elif kind == 'report':
            painter.drawRect(m + 3, m + 2, s - 7, s - 6)
            painter.drawLine(s - 4, m + 2, s - 4, m + 6)
            painter.drawLine(s - 4, m + 6, s - 6, m + 6)
        elif kind == 'table':
            painter.drawRect(m + 2, m + 2, s - 6, s - 6)
            painter.drawLine(m + 2, size // 2, s - 4, size // 2)
            painter.drawLine(size // 2, m + 2, size // 2, s - 4)
        elif kind == 'settings':
            painter.drawEllipse(m + 2, m + 2, s - 6, s - 6)
            painter.drawLine(size // 2, m + 2, size // 2, m)
            painter.drawLine(size // 2, s - 2, size // 2, s)
        elif kind == 'tag':
            painter.drawPolygon(QPolygonF([QPointF(m + 2, m + 4), QPointF(s - 4, m + 4), QPointF(s - 2, size // 2), QPointF(s - 4, s - 3), QPointF(m + 2, s - 3)]))
        elif kind == 'popout':
            painter.drawRect(m + 2, m + 3, s - 6, s - 6)
            painter.drawLine(size // 2, m + 2, s - 2, m + 2)
            painter.drawLine(s - 2, m + 2, s - 2, size // 2)
            painter.drawLine(s - 5, m + 2, s - 2, m + 5)
        elif kind == 'theme':
            painter.drawEllipse(m + 2, m + 2, s - 6, s - 6)
            painter.drawLine(size // 2, m + 2, size // 2, s - 2)

        painter.end()
        return QIcon(pixmap)

    def _apply_cad_icons(self):
        color = "#D0D0D0" if self.ui_theme == 'cad_2024' else "#2B2B2B"
        accent = "#4AA3DF" if self.ui_theme == 'cad_2024' else "#2A5E9A"

        icon_map = {
            'btn_load': 'folder',
            'btn_clear': 'clear',
            'btn_process_rtk': 'convert',
            'btn_load_compare': 'compare',
            'btn_load_vector': 'vector',
            'btn_apply_z_filter': 'check',
            'btn_reset_z_filter': 'reset',
            'btn_add_point': 'add_point',
            'btn_delete_point': 'delete_point',
            'btn_toggle_points': 'points',
            'btn_update_stats': 'stats',
            'btn_calc_volume': 'volume',
            'btn_profile': 'profile',
            'btn_multi_profile': 'multi_profile',
            'btn_run_viewshed': 'viewshed',
            'btn_check_los': 'los',
            'btn_query_tool': 'query',
            'btn_tool_coord': 'crosshair',
            'btn_tool_distance': 'distance',
            'btn_tool_intersect': 'intersect',
            'btn_tool_mapnum': 'grid',
            'btn_tool_leveling': 'level',
            'btn_zonal_stats': 'grid',
            'btn_export_2d': 'export_image',
            'btn_export_3d': 'export_image',
            'btn_export_grid': 'grid',
            'btn_export_report': 'report',
            'btn_export_profiles': 'profile',
            'btn_export_modified_data': 'table',
            'btn_set_api': 'settings',
            'btn_set_project': 'tag',
            'btn_toggle_theme': 'theme',
            'btn_reset_view': 'reset',
            'btn_popout_2d': 'popout',
            'btn_popout_3d': 'popout',
        }

        for attr, kind in icon_map.items():
            self._set_button_icon(getattr(self, attr, None), kind, color, accent)

    def _get_current_background_path(self):
        """获取当前背景图片的完整路径。"""
        if not self.background_files:
            return None
        file_name = self.background_files[self.current_background_index]
        path = os.path.join(os.path.dirname(os.path.abspath(__file__)), file_name)
        # 将路径中的 \ 替换为 / 以便 CSS 正确解析
        return path.replace('\\', '/')

    def _toggle_theme(self):
        """切换玻璃主题与 CAD 主题。"""
        if self.current_theme == 'dark':
            self.current_theme = 'glass'
            self.btn_toggle_theme.setText("切换主题 (CAD)")
        else:
            self.current_theme = 'dark'
            self.btn_toggle_theme.setText("切换主题 (Glass)")

        self._apply_theme_and_background()

    def _apply_theme_and_background(self):
        """应用当前的主题和背景。"""
        app = QApplication.instance()
        if self.current_theme == 'glass':
            path = self._get_current_background_path()
            if path:
                dynamic_glass_style = self.GLASS_STYLESHEET % f"'{path}'"
                app.setStyleSheet(dynamic_glass_style)
            else:
                app.setStyleSheet(self.GLASS_STYLESHEET % 'none')

            self.canvas_2d.set_theme('glass')
            self.canvas_3d.set_theme('glass')
            self.update_plots()
            return

        self.apply_ui_preferences(persist=False)

    def toggle_viewshed_mode(self):

        """切换视域分析模式。"""
        self.is_setting_viewshed = self.btn_run_viewshed.isChecked()
        
        if self.is_setting_viewshed:
            # 1. 检查格网是否已生成
            if self.grid_z is None:
                QMessageBox.warning(self, "操作受限", "请先在“模型渲染设置”中生成“Smoothed Grid (平滑曲面)”。")
                self.btn_run_viewshed.setChecked(False)
                self.is_setting_viewshed = False
                return

            # 2. 获取观察高度
            height, ok = QInputDialog.getDouble(self, "视域分析", "请输入观察点高度 (m):", 1.8, 0.1, 1000.0, 1)
            if not ok:
                self.btn_run_viewshed.setChecked(False)
                self.is_setting_viewshed = False
                return
            
            self.viewshed_obs_height = height
            
            # 3. 关闭所有其他交互模式
            self.btn_query_tool.setChecked(False); self.is_querying = False
            self.btn_add_point.setChecked(False); self.is_adding_point = False
            self.btn_delete_point.setChecked(False); self.is_deleting_point = False
            self.btn_profile.setChecked(False); self.is_profiling = False
            self.btn_multi_profile.setChecked(False); self.multi_profile_mode = False

            QMessageBox.information(self, "设置观察点", "请在 2D 视图上点击，以设置观察点的位置。")
        
    def handle_viewshed_click(self, x, y):
        """处理设置视域分析观察点的点击事件。"""
        try:
            # 1. 获取观察点位置 (x, y) 和地面高程 (z)
            obs_x, obs_y = x, y
            
            # 使用最近邻插值从格网获取地面 Z 值
            obs_ix = np.clip(np.round((obs_x - self.grid_x[0]) / self.grid_spacing), 0, len(self.grid_x) - 1).astype(int)
            obs_iy = np.clip(np.round((obs_y - self.grid_y[0]) / self.grid_spacing), 0, len(self.grid_y) - 1).astype(int)
            
            obs_z_ground = self.grid_z[obs_iy, obs_ix]
            
            if np.isnan(obs_z_ground):
                QMessageBox.warning(self, "点击无效", "您点击的位置在格网范围之外，无法计算。")
                return

            # 观察者的实际 3D 坐标（眼高）
            obs_pos = (obs_x, obs_y, obs_z_ground + self.viewshed_obs_height)
            
            # 存储 2D 观察点位置用于绘图
            self.viewshed_observer_pos = (obs_x, obs_y)
            
            # 2. 启动后台 Worker
            self.start_viewshed_worker(obs_pos)

        except Exception as e:
            QMessageBox.critical(self, "视域分析错误", f"设置观察点时出错: {e}")
        
        finally:
            # 3. 退出模式
            self.is_setting_viewshed = False
            self.btn_run_viewshed.setChecked(False)

    def start_viewshed_worker(self, obs_pos):
        """启动视域分析后台线程和进度条。"""
        try:
            # 检查是否已有线程在运行
            if hasattr(self, '_viewshed_thread') and self._viewshed_thread is not None and self._viewshed_thread.isRunning():
                QMessageBox.information(self, "处理中", "已有视域分析任务正在运行。")
                return

            self._viewshed_thread = QThread()
            self._viewshed_worker = _ViewshedWorker(
                obs_pos=obs_pos,
                grid_x=self.grid_x,
                grid_y=self.grid_y,
                grid_z=self.grid_z,
                spacing=self.grid_spacing
            )
            self._viewshed_worker.moveToThread(self._viewshed_thread)
            
            # 进度条
            from PyQt5.QtWidgets import QProgressDialog
            pd = QProgressDialog("正在计算视域...", "取消", 0, 100, self)
            pd.setWindowModality(Qt.WindowModal)
            pd.setMinimumDuration(500) # 超过 0.5 秒才显示

            # 连接信号
            self._viewshed_thread.started.connect(self._viewshed_worker.run)
            self._viewshed_worker.progress.connect(pd.setValue)
            self._viewshed_worker.finished.connect(self.on_viewshed_finished)
            self._viewshed_worker.error.connect(self.on_viewshed_error)
            pd.canceled.connect(self._viewshed_worker.cancel) # 允许用户取消
            
            # 清理
            self._viewshed_worker.finished.connect(pd.close)
            self._viewshed_worker.finished.connect(self._viewshed_thread.quit)
            self._viewshed_worker.finished.connect(self._viewshed_worker.deleteLater)
            self._viewshed_thread.finished.connect(self._viewshed_thread.deleteLater)

            self._viewshed_thread.start()
            
        except Exception as e:
            QMessageBox.critical(self, "线程错误", f"无法启动视域分析线程: {e}")

    def on_viewshed_finished(self, visibility_grid):
        """视域分析成功完成的槽。"""
        self.viewshed_data = visibility_grid
        QMessageBox.information(self, "计算完成", "视域分析已完成。")
        
        # 自动切换到视域分析视图
        self.combo_2d_mode.setCurrentText("视域分析 (Viewshed)")
        self.update_plots() # 触发重绘

    def on_viewshed_error(self, msg):
        """视域分析失败或取消的槽。"""
        if msg == 'cancelled':
            QMessageBox.information(self, "已取消", "视域分析已取消。")
        else:
            QMessageBox.critical(self, "计算失败", f"视域分析时发生错误: {msg}")
        self.viewshed_data = None
        self.viewshed_observer_pos = None

    def toggle_los_mode(self):
        """切换两点通视分析模式。"""
        self.is_checking_los = self.btn_check_los.isChecked()
        
        if self.is_checking_los:
            # 1. 检查插值器是否准备好
            if self.interpolator is None:
                QMessageBox.warning(self, "操作受限", "请先加载数据并等待三角网 (TIN) 计算完成。")
                self.btn_check_los.setChecked(False)
                return

            # 2. 获取观察点和目标点高度
            obs_h, ok1 = QInputDialog.getDouble(self, "设置观察点", "请输入 [观察点] 高度 (m):", 1.8, 0.1, 1000.0, 1)
            if not ok1:
                self.btn_check_los.setChecked(False); return
            tgt_h, ok2 = QInputDialog.getDouble(self, "设置目标点", "请输入 [目标点] 高度 (m):", 1.8, 0.1, 1000.0, 1)
            if not ok2:
                self.btn_check_los.setChecked(False); return
            
            self.los_obs_height = obs_h
            self.los_tgt_height = tgt_h

            # 3. 关闭所有其他交互模式
            self.btn_run_viewshed.setChecked(False); self.is_setting_viewshed = False
            self.btn_query_tool.setChecked(False); self.is_querying = False
            self.btn_add_point.setChecked(False); self.is_adding_point = False
            self.btn_delete_point.setChecked(False); self.is_deleting_point = False
            self.btn_profile.setChecked(False); self.is_profiling = False
            self.btn_multi_profile.setChecked(False); self.multi_profile_mode = False
            
            # 4. 重置状态
            self.los_points = []
            self.last_los_result = None # 清除上一条线
            self.update_plots() # 重绘以清除
            QMessageBox.information(self, "通视分析", "请在 2D 视图上点击 [观察点] 位置。")
        else:
            self.los_points = [] # 取消时清空


    def handle_los_click(self, x, y):
        """处理通视分析的点击事件。"""
        self.los_points.append((x, y))
        
        # 绘制临时标记
        self.canvas_2d.axes.plot(x, y, 'm+', markersize=12, markeredgewidth=2)
        self.canvas_2d.draw()

        if len(self.los_points) == 1:
            QMessageBox.information(self, "通视分析", "已设置 [观察点]。\n请在 2D 视图上点击 [目标点] 位置。")
        
        elif len(self.los_points) == 2:
            p1 = self.los_points[0]
            p2 = self.los_points[1]
            
            QApplication.setOverrideCursor(Qt.WaitCursor)
            is_visible = self.check_intervisibility(p1, p2, self.los_obs_height, self.los_tgt_height)
            QApplication.restoreOverrideCursor()
            
            # 存储结果用于持久绘制
            self.last_los_result = (p1, p2, is_visible)
            
            if is_visible:
                QMessageBox.information(self, "通视分析结果", "✅ 通视 (Visible)\n\n两点之间 (在指定高度) 没有地形遮挡。")
            else:
                QMessageBox.warning(self, "通视分析结果", "❌ 遮挡 (Obstructed)\n\n两点之间存在地形遮挡。")
            
            # 重置并退出模式
            self.los_points = []
            self.is_checking_los = False
            self.btn_check_los.setChecked(False)
            
            # 重绘所有画布
            self.update_plots()


    def check_intervisibility(self, p1, p2, obs_height, tgt_height):
        """
        基于 TIN (interpolator) 检查两点是否通视。
        """
        try:
            # 1. 获取两点的地面高程
            z1_ground = self.interpolator(p1[0], p1[1])
            z2_ground = self.interpolator(p2[0], p2[1])
            
            if np.isnan(z1_ground) or np.isnan(z2_ground):
                QMessageBox.warning(self, "计算错误", "所选点位于TIN范围之外。")
                return False

            # 2. 定义 3D 视线的起点和终点
            obs_x, obs_y, obs_z = p1[0], p1[1], z1_ground + obs_height
            tgt_x, tgt_y, tgt_z = p2[0], p2[1], z2_ground + tgt_height

            # 3. 沿 2D 视线生成采样点
            dist_2d = np.hypot(tgt_x - obs_x, tgt_y - obs_y)
            # 使用格网间距作为参考，如果格网不存在，则默认为 1.0 米
            step_size = self.grid_spacing if (self.grid_spacing is not None and self.grid_spacing > 0) else 1.0
            num_steps = int(dist_2d / step_size) + 2
            if num_steps < 10: num_steps = 10 # 确保至少采样 10 个点
            
            t = np.linspace(0, 1, num_steps)[1:-1] # 采样 [0, 1] 之间的点
            if t.size == 0:
                return True # 两点相邻，中间无点，视为通视

            x_line = obs_x + (tgt_x - obs_x) * t
            y_line = obs_y + (tgt_y - obs_y) * t
            
            # 4. 计算 3D 视线高度
            z_line_of_sight = obs_z + (tgt_z - obs_z) * t
            
            # 5. 计算视线正下方的地形高程
            terrain_z_under_line = self.interpolator(x_line, y_line)
            
            # 6. 检查遮挡
            # 检查是否有任何地形高程 (terrain_z) 高于 (>) 视线高程 (z_line_of_sight)
            # 增加 1e-6 (小容差) 避免浮点数精度问题
            is_obstructed = np.any(terrain_z_under_line > (z_line_of_sight + 1e-6))
            
            return not is_obstructed
            
        except Exception as e:
            QMessageBox.critical(self, "通视分析失败", f"计算时出错: {e}")
            return False
    
    def export_modified_data(self):
        """将当前内存中的 self.raw_data (包含添加/删除的点) 导出为 CSV 文件。"""
        # 检查是否有数据可导出
        if self.raw_data is None or self.raw_data.empty:
            QMessageBox.warning(self, "无数据", "当前没有已加载或修改的数据可导出。")
            return

        # 建议的文件名
        original_basename = "modified_data"
        if self.file_path:
            try:
                original_basename = os.path.splitext(os.path.basename(self.file_path))[0] + "_modified"
            except: pass # Use default if path parsing fails
        default_filename = f"{original_basename}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"

        # 弹出文件保存对话框
        fp, _ = QFileDialog.getSaveFileName(self, "导出修改后的数据", default_filename, "CSV 文件 (*.csv);;All Files (*)")

        if not fp:
            return # 用户取消

        try:
            QApplication.setOverrideCursor(Qt.WaitCursor)
            # 确保只导出 X, Y, Z 列，并且顺序正确
            if {'X', 'Y', 'Z'}.issubset(self.raw_data.columns):
                export_df = self.raw_data[['X', 'Y', 'Z']]
                export_df.to_csv(fp, index=False, float_format='%.6f') # 保存 CSV，不包含索引，保留6位小数
                QMessageBox.information(self, "导出成功", f"修改后的数据已成功导出到:\n{fp}")
            else:
                raise ValueError("内存数据缺少 X, Y 或 Z 列。")

        except Exception as e:
            QMessageBox.critical(self, "导出失败", f"导出数据时发生错误:\n{e}")
        finally:
            QApplication.restoreOverrideCursor()
        
    def _draw_vector_layers_3d(self, ax):
        """将加载的矢量图层绘制到 3D 轴上。"""
        if not self.vector_layers or self.interpolator is None:
            return

        for gdf in self.vector_layers:
            # 确保几何体有效
            if not gdf.is_valid.all():
                print("警告: 矢量图层包含无效几何体，正在尝试修复...")
                gdf['geometry'] = gdf.geometry.buffer(0) # 尝试修复

            # 遍历每个几何体 (要素)
            for geom in gdf.geometry:
                try:
                    if geom.geom_type == 'LineString':
                        x, y = geom.xy
                        # 插值 Z 坐标
                        z = self.interpolator(np.array(x), np.array(y))
                        # 过滤掉 NaN (TIN 范围外的点)
                        valid_mask = ~np.isnan(z)
                        if np.sum(valid_mask) >= 2: # 至少需要两个有效点才能画线
                            # 增加一点垂直偏移
                            offset = max(0.5, np.nanmean(z[valid_mask]) * 0.002) if np.any(valid_mask) else 0.5
                            ax.plot(np.array(x)[valid_mask], np.array(y)[valid_mask], z[valid_mask] + offset,
                                    color='cyan', linewidth=2)
                                    
                    elif geom.geom_type == 'Polygon':
                        # 绘制多边形边界
                        x, y = geom.exterior.xy
                        z = self.interpolator(np.array(x), np.array(y))
                        valid_mask = ~np.isnan(z)
                        if np.sum(valid_mask) >= 2:
                            offset = max(0.5, np.nanmean(z[valid_mask]) * 0.002) if np.any(valid_mask) else 0.5
                            ax.plot(np.array(x)[valid_mask], np.array(y)[valid_mask], z[valid_mask] + offset,
                                    color='#00FFFF', linewidth=1.5, linestyle=':') # 浅青色虚线

                        # (可选) 绘制内部孔洞边界 (如果需要)
                        # for interior in geom.interiors:
                        #     x_i, y_i = interior.xy
                        #     z_i = self.interpolator(np.array(x_i), np.array(y_i))
                        #     valid_mask_i = ~np.isnan(z_i)
                        #     if np.sum(valid_mask_i) >= 2:
                        #         offset_i = max(0.5, np.nanmean(z_i[valid_mask_i]) * 0.002) if np.any(valid_mask_i) else 0.5
                        #         ax.plot(np.array(x_i)[valid_mask_i], np.array(y_i)[valid_mask_i], z_i[valid_mask_i] + offset_i,
                        #                 color='#88FFFF', linewidth=1, linestyle=':') # 更浅的颜色

                    elif geom.geom_type == 'Point':
                        x, y = geom.x, geom.y
                        z = self.interpolator(x, y)
                        if not np.isnan(z):
                            offset = max(1.0, z * 0.002) if z else 1.0
                            ax.scatter(x, y, z + offset, color='lime', marker='s', s=30) # 绿色方块标记点

                    elif geom.geom_type in ['MultiLineString', 'MultiPolygon', 'MultiPoint']:
                        # 对 Multi* 类型，递归处理每个部分
                        for part in geom.geoms:
                            # 重新构建包含单个部分的 GeoDataFrame 以便调用
                            temp_gdf = gpd.GeoDataFrame([1], geometry=[part], crs=gdf.crs)
                            self._draw_vector_layers_3d(ax, layers=[temp_gdf]) # 递归调用 (简化版)

                except Exception as e:
                    print(f"绘制 3D 矢量要素时出错: {e} (几何类型: {geom.geom_type})")

    def calculate_grid_slope_aspect(self):
        """
        从 self.grid_z 计算栅格化的坡度和坡向。
        返回 (grid_slope, grid_aspect) 或 (None, None)
        """
        if self.grid_z is None or self.grid_spacing <= 0:
            print("警告: 无法计算栅格坡度/坡向，格网数据未生成。")
            return None, None
            
        try:
            # 使用 numpy.gradient 计算 x 和 y 方向的高程变化率
            dz_dy, dz_dx = np.gradient(self.grid_z, self.grid_spacing, self.grid_spacing)
            
            # 计算坡度 (弧度 和 度)
            slope_rad = np.arctan(np.sqrt(dz_dx**2 + dz_dy**2))
            grid_slope = np.degrees(slope_rad)
            
            # 计算坡向 (度, 从北方顺时针)
            # 注意: arctan2(dy, dx) 的结果范围是 [-pi, pi]，需要转换
            aspect_rad = np.arctan2(dz_dx, -dz_dy) # 注意参数顺序和符号，使 0 度朝北
            grid_aspect = np.degrees(aspect_rad)
            grid_aspect = (grid_aspect + 360) % 360 # 转换为 0-360 度
            
            # 平坦区域 (坡度接近0) 的坡向设为 -1
            grid_aspect[grid_slope < 0.1] = -1.0 
            
            return grid_slope, grid_aspect
            
        except Exception as e:
            print(f"计算栅格坡度/坡向时出错: {e}")
            return None, None
        
    def run_zonal_statistics(self):
        """
        执行分区统计：用户选择矢量多边形图层和分析栅格，计算统计结果 (带解释)。
        """
        # 1. 检查必要数据
        if self.grid_z is None or self.grid_spacing <= 0:
            QMessageBox.warning(self, "数据缺失", "请先生成“平滑格网 (Smoothed Grid)”数据。")
            return
            
        polygon_layers = []
        layer_names = []
        for i, gdf in enumerate(self.vector_layers):
            if not gdf.empty and gdf.geometry.geom_type.str.contains('Polygon').any():
                layer_name = getattr(gdf, 'filename', f"图层 {i+1}")
                if layer_name and isinstance(layer_name, str):
                     layer_name = os.path.basename(layer_name)
                else:
                     layer_name = f"图层 {i+1}"
                polygon_layers.append(gdf)
                layer_names.append(layer_name)

        if not polygon_layers:
            QMessageBox.warning(self, "数据缺失", "请先加载至少一个包含多边形要素的矢量图层 (.shp, .geojson)。")
            return

        # 2. 让用户选择图层和分析类型
        layer_name, ok1 = QInputDialog.getItem(self, "选择分区图层", "请选择用于分区的矢量图层:", layer_names, 0, False)
        if not ok1: return
        
        selected_gdf = polygon_layers[layer_names.index(layer_name)]
        
        analysis_types = ["高程 (Elevation)", "坡度 (Slope)", "坡向 (Aspect)"]
        analysis_type, ok2 = QInputDialog.getItem(self, "选择分析栅格", "请选择要统计的栅格数据:", analysis_types, 0, False)
        if not ok2: return

        QApplication.setOverrideCursor(Qt.WaitCursor)
        try:
            # 3. 准备栅格数据和地理变换信息
            target_grid = None
            unit = ""
            analysis_name = ""
            
            if analysis_type == "高程 (Elevation)":
                target_grid = self.grid_z
                unit = "米 (m)"
                analysis_name = "高程"
            elif analysis_type == "坡度 (Slope)":
                grid_slope, _ = self.calculate_grid_slope_aspect()
                if grid_slope is None: raise ValueError("无法计算栅格坡度。")
                target_grid = grid_slope
                unit = "度 (°)"
                analysis_name = "坡度"
            elif analysis_type == "坡向 (Aspect)":
                _, grid_aspect = self.calculate_grid_slope_aspect()
                if grid_aspect is None: raise ValueError("无法计算栅格坡向。")
                target_grid = grid_aspect
                unit = "度 (°)"
                analysis_name = "坡向"
            
            if target_grid is None: raise ValueError("未能准备好目标栅格数据。")

            # 创建 Rasterio 仿射变换
            x_origin = self.grid_x[0] - self.grid_spacing / 2.0 
            y_origin = self.grid_y[-1] + self.grid_spacing / 2.0
            transform = from_origin(x_origin, y_origin, self.grid_spacing, self.grid_spacing)
            
            # 准备栅格
            target_grid = target_grid.astype(np.float32)
            nodata_value = -9999.0
            target_grid_masked = np.where(np.isnan(target_grid), nodata_value, target_grid) # 使用 where 替换 nan

            # 4. 执行分区统计
            stats = rasterstats.zonal_stats(
                selected_gdf,
                target_grid_masked, # 使用处理过 NaN 的数组
                affine=transform,
                stats=['count', 'min', 'max', 'mean', 'median', 'std'], # 移除 'sum'
                nodata=nodata_value,
                geojson_out=True
            )
            
            # 5. 格式化结果并显示 (带解释)
            results_text = f"--- 分区统计结果 ---\n"
            results_text += f"分区图层: {layer_name}\n"
            results_text += f"统计栅格: {analysis_name} ({unit})\n"
            results_text += f"-------------------------\n"
            results_text += f"说明：统计的是每个矢量多边形区域内，对应栅格像元的值。\n\n"

            for i, feature in enumerate(stats):
                props = feature['properties']
                feature_id = props.get('name', props.get('id', f"要素 {i+1}")) 
                results_text += f"区域: {feature_id}\n"
                
                count = props.get('count')
                min_val = props.get('min')
                max_val = props.get('max')
                mean_val = props.get('mean')
                median_val = props.get('median')
                std_val = props.get('std')

                results_text += f"  - 像元数量 (Count): {count if count is not None else 'N/A'}\n"
                results_text += f"     (区域内参与统计的栅格单元个数)\n"
                
                if min_val is not None:
                    results_text += f"  - 最小值 (Min): {min_val:.3f} {unit}\n"
                    results_text += f"     (区域内 {analysis_name} 的最小值)\n"
                else: results_text += "  - 最小值 (Min): N/A\n"

                if max_val is not None:
                    results_text += f"  - 最大值 (Max): {max_val:.3f} {unit}\n"
                    results_text += f"     (区域内 {analysis_name} 的最大值)\n"
                else: results_text += "  - 最大值 (Max): N/A\n"

                if mean_val is not None:
                    results_text += f"  - 平均值 (Mean): {mean_val:.3f} {unit}\n"
                    results_text += f"     (区域内 {analysis_name} 的算术平均值)\n"
                else: results_text += "  - 平均值 (Mean): N/A\n"

                if median_val is not None:
                    results_text += f"  - 中位数 (Median): {median_val:.3f} {unit}\n"
                    results_text += f"     (区域内 {analysis_name} 的中值，可反映一般水平)\n"
                else: results_text += "  - 中位数 (Median): N/A\n"

                if std_val is not None:
                    results_text += f"  - 标准差 (StdDev): {std_val:.3f} {unit}\n"
                    results_text += f"     (反映区域内 {analysis_name} 的离散程度，值越大表示变化越剧烈)\n"
                else: results_text += "  - 标准差 (StdDev): N/A\n"

                # 坡向特别说明
                if analysis_name == "坡向":
                    results_text += "  * 坡向说明: 0°=北, 90°=东, 180°=南, 270°=西。\n"
                    results_text += "    值为 -1.0 代表平坦区域。平均值和标准差对坡向意义有限。\n"
                    results_text += "    请主要关注 Min/Max 范围和 Count 数量。\n"
                
                results_text += "\n"

            # 使用 QTextEdit 显示结果
            result_dialog = QDialog(self)
            result_dialog.setWindowTitle("分区统计结果")
            result_dialog.setMinimumSize(600, 450) # 增大窗口
            layout = QVBoxLayout(result_dialog)
            text_edit = QTextEdit()
            text_edit.setReadOnly(True)
            text_edit.setFontFamily("Consolas") # 等宽字体
            text_edit.setFontPointSize(10)     # 调整字体大小
            text_edit.setText(results_text)
            layout.addWidget(text_edit)
            close_button = QPushButton("关闭")
            close_button.clicked.connect(result_dialog.accept)
            layout.addWidget(close_button)
            result_dialog.exec_()

        except ImportError:
             QMessageBox.critical(self, "库缺失", "执行分区统计需要 'rasterio' 和 'rasterstats' 库。\n请先安装： pip install rasterio rasterstats")
        except Exception as e:
            QMessageBox.critical(self, "分区统计失败", f"执行分区统计时发生错误:\n{e}")
        finally:
            QApplication.restoreOverrideCursor()

    def mouseDoubleClickEvent(self, event):
        """处理主窗口的双击事件以切换背景。"""
        # 仅在玻璃主题下生效
        if self.current_theme == 'glass':
            if event.button() == Qt.LeftButton:
                if self.background_files:
                    # 切换到下一个背景
                    self.current_background_index = (self.current_background_index + 1) % len(self.background_files)
                    # 重新应用主题（这将加载新图片）
                    self._apply_theme_and_background()
                    event.accept()
                    return
        super().mouseDoubleClickEvent(event)

    def resizeEvent(self, event):
        """窗口大小改变时，重新应用背景（以防图片拉伸）。"""
        # 仅在玻璃主题下生效
        if self.current_theme == 'glass':
            self._apply_theme_and_background()
        super().resizeEvent(event)

    # =======================================================
    # (MainWindow 类结束)
    # =======================================================

# =========================================================================
# =========================================================================
# 新增：来自实验的工具类 (Dialogs)
# =========================================================================
# =========================================================================

# -------------------- 实验五：密码登录对话框 --------------------
class LoginDialog(QDialog):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("DTM Pro 登录")
        
        self.setWindowFlags(Qt.Window | Qt.FramelessWindowHint) # 无边框
        
        try:
            # 手动设置全屏
            screen_geometry = QGuiApplication.primaryScreen().geometry()
            self.setGeometry(screen_geometry)
        except Exception as e:
            print(f"Warning: Could not set geometry, falling back to maximize: {e}")
            self.setWindowState(Qt.WindowMaximized) # Fallback

        # 用于存储背景图片的列表
        self.background_files = []
        # self._load_background_file_list() # <-- *不*在这里调用
        self.current_background_index = 0
        
        # --- 创建 UI ---
        self.main_layout = QVBoxLayout(self)
        self.main_layout.setContentsMargins(0, 0, 0, 0)
        
        self.background_label = QLabel(self)
        self.background_label.setAlignment(Qt.AlignCenter)
        self.background_label.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
        self.background_label.mouseDoubleClickEvent = self._on_background_double_click
        self.main_layout.addWidget(self.background_label)
        
        self.login_card = QWidget(self.background_label)
        self.login_card.setFixedSize(500, 380) # 高度 380
        self.login_card.setStyleSheet("""
            QWidget {
                background-color: rgba(255, 255, 255, 0.2);
                border-radius: 20px;
                border: 1px solid rgba(255, 255, 255, 0.4);
                backdrop-filter: blur(15px);
                box-shadow: 0 8px 32px 0 rgba(31, 38, 135, 0.37);
            }
            QLabel { color: #FFFFFF; font-size: 16px; font-weight: bold; }
            QLineEdit {
                background-color: rgba(255, 255, 255, 0.3);
                border: 1px solid rgba(255, 255, 255, 0.5);
                border-radius: 8px; padding: 10px; color: #FFFFFF; font-size: 16px;
            }
            QLineEdit::placeholder { 
                color: rgba(255, 255, 255, 0.7); /* 提高一点对比度 */
                font-size: 16px; /* <--- 确保占位符也是 16px */
            }
            QPushButton {
                background-color: rgba(0, 123, 255, 0.7);
                color: white; border: none; border-radius: 8px;
                padding: 12px 25px; font-size: 16px; font-weight: bold;
            }
            QPushButton:hover { background-color: rgba(0, 123, 255, 0.9); }
            QPushButton#btnExit { background-color: rgba(220, 53, 69, 0.7); }
            QPushButton#btnExit:hover { background-color: rgba(220, 53, 69, 0.9); }
        """)
        
        card_layout = QVBoxLayout(self.login_card)
        card_layout.setContentsMargins(40, 40, 40, 40)
        card_layout.setAlignment(Qt.AlignCenter)
        
        title_label = QLabel("DTM Pro 登录")
        title_label.setAlignment(Qt.AlignCenter)
        title_label.setStyleSheet("font-size: 30px; margin-bottom: 20px; color: #FFFFFF;")
        card_layout.addWidget(title_label)
        
        self.txt_password = QLineEdit()
        self.txt_password.setEchoMode(QLineEdit.Password)
        self.txt_password.setPlaceholderText("请输入密码 (提示：202305311)")
        card_layout.addWidget(self.txt_password)
        card_layout.addSpacing(25)

        btn_layout = QHBoxLayout()
        self.btn_login = QPushButton("登录")
        self.btn_exit = QPushButton("退出")
        self.btn_exit.setObjectName("btnExit")
        btn_layout.addWidget(self.btn_login)
        btn_layout.addSpacing(15)
        btn_layout.addWidget(self.btn_exit)
        card_layout.addLayout(btn_layout) 
        
        card_layout.addSpacing(15) 
        
        self.lbl_message = QLabel("") # <--- 消息标签被创建
        self.lbl_message.setAlignment(Qt.AlignCenter)
        self.lbl_message.setWordWrap(True)
        self.lbl_message.setStyleSheet("background-color: transparent; color: white;")
        card_layout.addWidget(self.lbl_message)

        # --- 关键修改：在这里调用 _load_background_file_list ---
        self._load_background_file_list() # 在 lbl_message 创建后调用
        # --- 结束修改 ---

        # 信号连接
        self.btn_login.clicked.connect(self.check_login)
        self.btn_exit.clicked.connect(self.reject)
        self.txt_password.returnPressed.connect(self.check_login)

        # 初始加载背景
        self._load_current_background() # <--- 现在调用这个
        
        self.background_label.resizeEvent = self._on_background_label_resized
        self._center_login_card()
    
    def _load_background_file_list(self):
        """加载同文件夹下所有符合 'background_X.jpg' 格式的图片文件。"""
        try:
            script_dir = os.path.dirname(os.path.abspath(__file__))
            all_files = [f for f in os.listdir(script_dir) if f.startswith('background_') and f.lower().endswith('.jpg')]
            
            # 按数字排序
            def sort_key(filename):
                match = re.search(r'background_(\d+)\.jpg', filename, re.IGNORECASE)
                return int(match.group(1)) if match else 9999 # 无数字的排到最后
            
            self.background_files = sorted(all_files, key=sort_key)
            
            if not self.background_files:
                # --- 修改：移除弹窗，改为在卡片中显示 ---
                # QMessageBox.warning(self, "警告", "未找到任何 'background_X.jpg' 背景图片文件...")
                
                # 确保 self.lbl_message 已经初始化
                if hasattr(self, 'lbl_message'):
                    self.lbl_message.setText("警告：未找到 'background_X.jpg' 背景图片。\n请将背景图放入程序文件夹。")
                    self.lbl_message.setStyleSheet("""
                        QLabel {
                            color: #000000; /* 深色文字 */
                            background-color: rgba(255, 193, 7, 0.8); /* 黄色警告背景 */
                            font-size: 15px; /* 字体稍小以适应多行 */
                            font-weight: bold; 
                            padding: 8px;
                            border-radius: 5px;
                        }
                    """)
                else:
                    print("警告：未找到背景图片（lbl_message 尚未初始化）")
                # --- 结束修改 ---
                
        except Exception as e:
            # 如果在启动时发生其他错误（如权限问题），也在卡片中显示
            if hasattr(self, 'lbl_message'):
                self.lbl_message.setText(f"加载背景时出错: {e}")
                self.lbl_message.setStyleSheet("""
                    QLabel {
                        color: #FFFFFF; 
                        background-color: rgba(220, 53, 69, 0.7); /* 红色错误背景 */
                        font-size: 15px;
                        font-weight: bold; 
                        padding: 8px;
                        border-radius: 5px;
                    }
                """)

    def _load_current_background(self):
        """加载当前索引对应的背景图片并显示。"""
        if not self.background_files:
            # --- 修改：不再设置大号文本，只设置深色背景 ---
            self.background_label.setText("") # 清空文本
            self.background_label.setStyleSheet("background-color: #333;") # 设置一个深色背景
            # 警告信息将由 _load_background_file_list 显示在卡片内
            # --- 结束修改 ---
            return

        file_name = self.background_files[self.current_background_index]
        image_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), file_name)
        
        pixmap = QPixmap(image_path)
        if not pixmap.isNull():
            # 缩放图片以适应窗口，保持比例，并确保填充整个区域
            scaled_pixmap = pixmap.scaled(self.background_label.size(), Qt.KeepAspectRatioByExpanding, Qt.SmoothTransformation)
            self.background_label.setPixmap(scaled_pixmap)
            self.background_label.setText("") # 清除文本
        else:
            # 如果加载特定图片失败（例如图片损坏），也在卡片内显示
            if hasattr(self, 'lbl_message'):
                self.lbl_message.setText(f"加载图片失败: {file_name}")
                self.lbl_message.setStyleSheet("""
                    QLabel {
                        color: #FFFFFF; 
                        background-color: rgba(220, 53, 69, 0.7); /* 红色错误背景 */
                        font-size: 13px;
                        font-weight: bold; 
                        padding: 8px;
                        border-radius: 5px;
                    }
                """)


    def _on_background_double_click(self, event):
        """双击背景时切换到下一张图片。"""
        if event.button() == Qt.LeftButton:
            if self.background_files:
                self.current_background_index = (self.current_background_index + 1) % len(self.background_files)
                self._load_current_background()
            event.accept()

    def _on_background_label_resized(self, event):
        """当背景标签大小改变时，重新居中登录卡片并重新加载背景图以适应新尺寸。"""
        self._center_login_card()
        self._load_current_background() # 重新加载以适应新的标签大小
        event.accept()

    def _center_login_card(self):
        """将登录卡片居中放置在背景标签上。"""
        card_width = self.login_card.width()
        card_height = self.login_card.height()
        
        label_width = self.background_label.width()
        label_height = self.background_label.height()
        
        self.login_card.move(
            (label_width - card_width) // 2,
            (label_height - card_height) // 2
        )

    def check_login(self):
        password = self.txt_password.text().strip()
        correct_password = "202305311" #

        if password == correct_password:
            # 登录成功
            self.lbl_message.setText("登录成功！正在进入...")
            self.lbl_message.setStyleSheet("""
                QLabel {
                    color: #FFFFFF; 
                    background-color: rgba(40, 167, 69, 0.7); /* 绿色半透明背景 */
                    font-size: 15px; 
                    font-weight: bold; 
                    padding: 8px;
                    border-radius: 5px;
                }
            """)
            
            # 禁用控件，防止重复点击
            self.txt_password.setEnabled(False)
            self.btn_login.setEnabled(False)
            self.btn_exit.setEnabled(False)
            
            # 延迟 1 秒后自动接受 (关闭) 对话框
            QTimer.singleShot(1000, self.accept)

        else:
            # 登录失败
            self.lbl_message.setText("密码错误，请重新输入")
            self.lbl_message.setStyleSheet("""
                QLabel {
                    color: #FFFFFF; 
                    background-color: rgba(220, 53, 69, 0.7); /* 红色半透明背景 */
                    font-size: 15px; 
                    font-weight: bold; 
                    padding: 8px;
                    border-radius: 5px;
                }
            """)
            
            self.txt_password.clear() # 清空密码
            self.txt_password.setFocus() # 重新聚焦

# -------------------- 实验三：距离计算对话框 --------------------
class DistanceCalcDialog(QDialog):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("实验三：距离计算")
        self.setMinimumSize(450, 400)

        layout = QVBoxLayout(self)
        grid = QGridLayout()
        grid.setSpacing(10)

        # 输入
        self.txt_xa = QLineEdit("11")
        self.txt_ya = QLineEdit("22")
        self.txt_xb = QLineEdit("33")
        self.txt_yb = QLineEdit("44")

        grid.addWidget(QLabel("点 A (XA):"), 0, 0)
        grid.addWidget(self.txt_xa, 0, 1)
        grid.addWidget(QLabel("点 A (YA):"), 1, 0)
        grid.addWidget(self.txt_ya, 1, 1)
        grid.addWidget(QLabel("点 B (XB):"), 2, 0)
        grid.addWidget(self.txt_xb, 2, 1)
        grid.addWidget(QLabel("点 B (YB):"), 3, 0)
        grid.addWidget(self.txt_yb, 3, 1)

        layout.addLayout(grid)

        # 按钮
        self.btn_calc = QPushButton("计算距离")
        self.btn_calc.clicked.connect(self.calculate_distance)
        layout.addWidget(self.btn_calc)

        # 结果
        self.result_box = QTextEdit()
        self.result_box.setReadOnly(True)
        layout.addWidget(self.result_box, 1) # 占据更多空间

    def calculate_distance(self):
        try:
            #
            xa = float(self.txt_xa.text().strip())
            ya = float(self.txt_ya.text().strip())
            xb = float(self.txt_xb.text().strip())
            yb = float(self.txt_yb.text().strip())

            dx = xb - xa #
            dy = yb - ya #
            dist = math.sqrt(dx**2 + dy**2) #

            sb = []
            sb.append(f"输入：") #
            sb.append(f"  A = ({xa}, {ya})") #
            sb.append(f"  B = ({xb}, {yb})") #
            sb.append("\n计算结果：") #
            sb.append(f"  ΔX = {dx:.6f} m") #
            sb.append(f"  ΔY = {dy:.6f} m") #
            sb.append(f"  DistAB = {dist:.3f} m") #
            self.result_box.setText("\n".join(sb)) #

        except ValueError:
            QMessageBox.warning(self, "输入错误", "请输入有效的数字！")
        except Exception as e:
            QMessageBox.critical(self, "计算错误", str(e))

# -------------------- 实验二：坐标转换对话框 --------------------
class CoordConvertDialog(QDialog):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("实验二：空间坐标转换工具")
        self.setMinimumSize(500, 450)

        #
        self.ellipsoids = [
            {"Name": "WGS-84", "a": 6378137.0, "f": 1 / 298.257223563},
            {"Name": "CGCS2000", "a": 6378137.0, "f": 1 / 298.257222101},
            {"Name": "克拉索夫斯基", "a": 6378245.0, "f": 1 / 298.3},
            {"Name": "国际1975", "a": 6378140.0, "f": 1 / 298.257}
        ]
        self.is_blh_to_xyz = True # 默认 经纬高程 -> XYZ

        layout = QVBoxLayout(self)

        # 椭球选择
        top_layout = QHBoxLayout()
        top_layout.addWidget(QLabel("选择椭球:"))
        self.combo_ellipsoid = QComboBox()
        self.combo_ellipsoid.addItems([e["Name"] for e in self.ellipsoids])
        self.combo_ellipsoid.currentIndexChanged.connect(self.show_ellipsoid_param)
        top_layout.addWidget(self.combo_ellipsoid, 1)
        layout.addLayout(top_layout)

        # 参数显示
        self.lbl_ellipsoid_param = QLabel()
        self.show_ellipsoid_param() # 初始化显示
        layout.addWidget(self.lbl_ellipsoid_param)

        # 模式切换
        self.btn_toggle_mode = QPushButton("切换为 XYZ -> 经纬高程")
        self.btn_toggle_mode.clicked.connect(self.toggle_mode) #
        layout.addWidget(self.btn_toggle_mode)

        # 输入
        grid = QGridLayout()
        self.lbl1 = QLabel("纬度 (B):")
        self.lbl2 = QLabel("经度 (L):")
        self.lbl3 = QLabel("高程 (H):")
        self.txt1 = QLineEdit("1")
        self.txt2 = QLineEdit("2")
        self.txt3 = QLineEdit("333")
        grid.addWidget(self.lbl1, 0, 0)
        grid.addWidget(self.txt1, 0, 1)
        grid.addWidget(self.lbl2, 1, 0)
        grid.addWidget(self.txt2, 1, 1)
        grid.addWidget(self.lbl3, 2, 0)
        grid.addWidget(self.txt3, 2, 1)
        layout.addLayout(grid)

        # 计算
        self.btn_calc = QPushButton("计算")
        self.btn_calc.clicked.connect(self.calculate) #
        layout.addWidget(self.btn_calc)

        # 结果
        self.result_box = QTextEdit()
        self.result_box.setReadOnly(True)
        self.result_box.setFontFamily("Consolas")
        layout.addWidget(self.result_box, 1)

        self.update_labels() # 初始化标签

    def show_ellipsoid_param(self):
        idx = self.combo_ellipsoid.currentIndex()
        ep = self.ellipsoids[idx]
        self.lbl_ellipsoid_param.setText(f"当前椭球：{ep['Name']}  a={ep['a']}  f={ep['f']:.15f}") #

    def update_labels(self):
        if self.is_blh_to_xyz:
            #
            self.lbl1.setText("纬度 (B) [deg]:")
            self.lbl2.setText("经度 (L) [deg]:")
            self.lbl3.setText("高程 (H) [m]:")
            self.btn_toggle_mode.setText("切换为 XYZ -> 经纬高程")
        else:
            #
            self.lbl1.setText("X [m]:")
            self.lbl2.setText("Y [m]:")
            self.lbl3.setText("Z [m]:")
            self.btn_toggle_mode.setText("切换为 经纬高程 -> XYZ")

    def toggle_mode(self):
        self.is_blh_to_xyz = not self.is_blh_to_xyz #
        self.update_labels() #
        # 交换输入和输出
        result_text = self.result_box.toPlainText()
        self.txt1.clear() #
        self.txt2.clear() #
        self.txt3.clear() #

        # 尝试解析旧结果并填入新输入
        try:
            if self.is_blh_to_xyz: # 之前是 XYZ->BLH，现在是 BLH->XYZ
                lines = [line.split(':')[-1].strip() for line in result_text.split('\n') if ':' in line]
                if len(lines) >= 3:
                    self.txt1.setText(lines[0])
                    self.txt2.setText(lines[1])
                    self.txt3.setText(lines[2])
            else: # 之前是 BLH->XYZ，现在是 XYZ->BLH
                lines = [line.split(':')[-1].strip() for line in result_text.split('\n') if ':' in line]
                if len(lines) >= 3:
                    self.txt1.setText(lines[0])
                    self.txt2.setText(lines[1])
                    self.txt3.setText(lines[2])
        except Exception:
            pass # 解析失败则保持清空
        self.result_box.clear()

    def calculate(self):
        try:
            v1 = float(self.txt1.text().strip()) #
            v2 = float(self.txt2.text().strip()) #
            v3 = float(self.txt3.text().strip()) #

            idx = self.combo_ellipsoid.currentIndex()
            ep = self.ellipsoids[idx]
            a, f = ep['a'], ep['f'] #
            e2 = 2 * f - f * f #
            pi = math.pi #

            if self.is_blh_to_xyz:
                # BLH -> XYZ
                lat_deg, lon_deg, h = v1, v2, v3 #
                radLat = math.radians(lat_deg) #
                radLon = math.radians(lon_deg) #

                sinLat = math.sin(radLat)
                cosLat = math.cos(radLat)
                sinLon = math.sin(radLon)
                cosLon = math.cos(radLon)

                N = a / math.sqrt(1 - e2 * sinLat**2) #

                X = (N + h) * cosLat * cosLon #
                Y = (N + h) * cosLat * sinLon #
                Z = (N * (1 - e2) + h) * sinLat #

                self.result_box.setText(f"计算结果 (XYZ):\n"
                                        f"X: {X:.2f}\n"
                                        f"Y: {Y:.2f}\n"
                                        f"Z: {Z:.2f}") #
            else:
                # XYZ -> BLH
                X, Y, Z = v1, v2, v3 #

                lon_rad = math.atan2(Y, X) #
                p = math.sqrt(X**2 + Y**2) #

                # 迭代计算
                lat_rad = math.atan2(Z, p * (1 - e2)) # 初始值
                lat0 = 0
                iter_count = 0

                #
                while abs(lat_rad - lat0) > 1e-10 and iter_count < 20:
                    lat0 = lat_rad #
                    sinLat = math.sin(lat0)
                    N = a / math.sqrt(1 - e2 * sinLat**2) #
                    h = p / math.cos(lat0) - N #
                    lat_rad = math.atan2(Z, p * (1 - e2 * N / (N + h))) #
                    iter_count += 1

                # 最终值
                sinLat = math.sin(lat_rad)
                N = a / math.sqrt(1 - e2 * sinLat**2)
                h = p / math.cos(lat_rad) - N

                lat_deg = math.degrees(lat_rad) #
                lon_deg = math.degrees(lon_rad) #

                self.result_box.setText(f"计算结果 (经纬高程):\n"
                                        f"纬度: {lat_deg:.8f}\n"
                                        f"经度: {lon_deg:.8f}\n"
                                        f"高程: {h:.2f}") #

        except ValueError:
            QMessageBox.warning(self, "输入错误", "请输入有效的数字！") #
        except Exception as e:
            QMessageBox.critical(self, "计算错误", str(e))

# -------------------- 实验四：前方交会绘图画布 --------------------
class DrawingCanvas(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.points = None # 将存储 (xa, ya, xb, yb, xp, yp, anga_rad, angb_rad)
        self.setMinimumSize(300, 300)
        self.setStyleSheet("background-color: #3C3C3C; border: 1px solid #555;")

    def set_points(self, data):
        self.points = data
        self.update() # 触发重绘

    def paintEvent(self, event):
        painter = QPainter(self)
        painter.setRenderHint(QPainter.Antialiasing) #
        painter.fillRect(self.rect(), QColor("#2E2E2E"))

        if not self.points:
            painter.setPen(QColor("#AAAAAA"))
            painter.drawText(self.rect(), Qt.AlignCenter, "请输入数据并点击[计算]") #
            return

        xa, ya, xb, yb, xp, yp, anga_rad, angb_rad = self.points

        # 模拟 VB.NET 的坐标缩放逻辑
        min_x = min(xa, xb, xp)
        max_x = max(xa, xb, xp)
        min_y = min(ya, yb, yp)
        max_y = max(ya, yb, yp)

        pad_x = (max_x - min_x) * 0.15
        pad_y = (max_y - min_y) * 0.15
        pad = max(pad_x, pad_y, 10.0) # 确保 padding 至少为 10

        min_x -= pad
        max_x += pad
        min_y -= pad
        max_y += pad

        data_width = max_x - min_x
        data_height = max_y - min_y

        if data_width == 0 or data_height == 0:
             return # 避免除零错误

        w = self.width() - 40 #
        h = self.height() - 40 #

        scale_x = w / data_width
        scale_y = h / data_height
        scale = min(scale_x, scale_y) #

        # 转换函数 (Y轴翻转)
        def to_screen(data_x, data_y):
            screen_x = 20 + (data_x - min_x) * scale
            screen_y = self.height() - 20 - (data_y - min_y) * scale #
            return QPointF(screen_x, screen_y)

        pa = to_screen(xa, ya) #
        pb = to_screen(xb, yb) #
        pp = to_screen(xp, yp) #

        # 绘制线
        painter.setPen(QPen(QColor("red"), 2))
        painter.drawLine(pa, pb) #
        painter.setPen(QPen(QColor("#F0F0F0"), 1))
        painter.drawLine(pa, pp) #
        painter.drawLine(pb, pp) #

        # 绘制点
        # P (圆)
        painter.setBrush(QColor("white"))
        painter.setPen(QPen(QColor("black"), 2))
        painter.drawEllipse(pp, 6, 6)

        # A (三角)
        painter.setBrush(QColor("red"))
        painter.setPen(QPen(QColor("red"), 2))
        poly_a = QPolygonF([QPointF(pa.x() - 6, pa.y() + 8),
                            QPointF(pa.x() + 6, pa.y() + 8),
                            QPointF(pa.x(), pa.y() - 6)])
        painter.drawPolygon(poly_a)

        # B (三角)
        poly_b = QPolygonF([QPointF(pb.x() - 6, pb.y() + 8),
                            QPointF(pb.x() + 6, pb.y() + 8),
                            QPointF(pb.x(), pb.y() - 6)])
        painter.drawPolygon(poly_b)

        # 绘制标签
        font = QFont("Arial", 12, QFont.Bold)
        painter.setFont(font)
        painter.setPen(QColor("red"))
        painter.drawText(QPointF(pa.x() - 10, pa.y() - 20), "A") #
        painter.drawText(QPointF(pb.x() - 10, pb.y() - 20), "B") #
        painter.setPen(QColor("#F0F0F0"))
        painter.drawText(QPointF(pp.x() - 8, pp.y() - 20), "P") #

        # 绘制角度弧
        painter.setPen(QPen(QColor("#00AEEF"), 2))
        painter.setBrush(Qt.NoBrush)

        # 角度 A (alpha)
        angle_ab = math.atan2(yb - ya, xb - xa) #
        angle_ap = math.atan2(yp - ya, xp - xa) #

        start_a = math.degrees(angle_ab) #
        sweep_a = math.degrees(angle_ap - angle_ab) #
        if sweep_a < 0: sweep_a += 360 #

        rect_a = QRectF(pa.x() - 30, pa.y() - 30, 60, 60)
        painter.drawArc(rect_a, int(start_a * 16), int(sweep_a * 16)) #

        # 角度 B (beta)
        angle_ba = math.atan2(ya - yb, xa - xb) #
        angle_bp = math.atan2(yp - yb, xp - xb) #

        start_b = math.degrees(angle_ba) #
        sweep_b = math.degrees(angle_bp - angle_ba) #
        if sweep_b < 0: sweep_b += 360 #

        rect_b = QRectF(pb.x() - 30, pb.y() - 30, 60, 60)
        painter.drawArc(rect_b, int(start_b * 16), int(sweep_b * 16)) #

        # 绘制角度标签
        painter.setFont(QFont("Arial", 14, QFont.Bold))
        painter.setPen(QColor("#00AEEF"))
        painter.drawText(QPointF(pa.x() + 8, pa.y() - 10), "α") #
        painter.drawText(QPointF(pb.x() - 28, pb.y() - 10), "β") #

# -------------------- 实验四：前方交会对话框 (修正) --------------------
class ForwardIntersectDialog(QDialog):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("实验四：前方交会计算")
        self.setMinimumSize(800, 600) # 增大窗口大小以容纳绘图

        # 主布局
        main_layout = QVBoxLayout(self)

        # 顶部输入布局
        top_layout = QHBoxLayout()

        # 已知点
        gb_known = QGroupBox("已知点数据输入")
        grid_known = QGridLayout()
        self.txt_xa = QLineEdit("11")
        self.txt_ya = QLineEdit("33")
        self.txt_xb = QLineEdit("22")
        self.txt_yb = QLineEdit("44")
        grid_known.addWidget(QLabel("XA:"), 0, 0)
        grid_known.addWidget(self.txt_xa, 0, 1)
        grid_known.addWidget(QLabel("YA:"), 0, 2)
        grid_known.addWidget(self.txt_ya, 0, 3)
        grid_known.addWidget(QLabel("XB:"), 1, 0)
        grid_known.addWidget(self.txt_xb, 1, 1)
        grid_known.addWidget(QLabel("YB:"), 1, 2)
        grid_known.addWidget(self.txt_yb, 1, 3)
        gb_known.setLayout(grid_known)
        top_layout.addWidget(gb_known)

        # 观测角
        gb_obs = QGroupBox("观测数据输入 (格式: D.mmss)")
        grid_obs = QGridLayout()
        self.txt_alpha = QLineEdit("30.3000")
        self.txt_beta = QLineEdit("30.0000")
        grid_obs.addWidget(QLabel("α (Alpha):"), 0, 0)
        grid_obs.addWidget(self.txt_alpha, 0, 1)
        grid_obs.addWidget(QLabel("β (Beta):"), 1, 0)
        grid_obs.addWidget(self.txt_beta, 1, 1)
        gb_obs.setLayout(grid_obs)
        top_layout.addWidget(gb_obs)

        main_layout.addLayout(top_layout)

        # 底部用于绘图和结果的分割器
        bottom_splitter = QSplitter(Qt.Horizontal)

        # 绘图画布 (替换 PictureBox)
        self.drawing_canvas = DrawingCanvas(self)
        bottom_splitter.addWidget(self.drawing_canvas)

        # 结果
        self.result_box = QTextEdit()
        self.result_box.setReadOnly(True)
        bottom_splitter.addWidget(self.result_box)

        bottom_splitter.setSizes([450, 350])
        main_layout.addWidget(bottom_splitter, 1)

        # 按钮
        self.btn_calc = QPushButton("计算")
        self.btn_calc.clicked.connect(self.calculate) #
        main_layout.addWidget(self.btn_calc, 0, Qt.AlignRight)

        # 实例变量存储计算结果
        self.points_data = None

    def dms_to_rad(self, dms_float):
        #
        d = int(dms_float)
        m_s = (dms_float - d) * 100
        m = int(m_s)
        s = (m_s - m) * 100
        deg = d + m / 60.0 + s / 3600.0
        return math.radians(deg)

    def dms_to_string(self, dms_float):
        #
        d = int(dms_float)
        m_s = (dms_float - d) * 100
        m = int(m_s)
        s = (m_s - m) * 100
        return f"{d}°{m}′{s:.2f}″"

    def calculate(self):
        try:
            xa = float(self.txt_xa.text().strip()) #
            ya = float(self.txt_ya.text().strip()) #
            xb = float(self.txt_xb.text().strip()) #
            yb = float(self.txt_yb.text().strip()) #
            anga_dms = float(self.txt_alpha.text().strip()) #
            angb_dms = float(self.txt_beta.text().strip()) #

            anga_rad = self.dms_to_rad(anga_dms)
            angb_rad = self.dms_to_rad(angb_dms)

            cot_a = 1.0 / math.tan(anga_rad) #
            cot_b = 1.0 / math.tan(angb_rad) #

            #
            xp = (xa * cot_b + xb * cot_a - ya + yb) / (cot_a + cot_b)
            yp = (ya * cot_b + yb * cot_a + xa - xb) / (cot_a + cot_b)

            #
            sb = []
            sb.append(f"XA = {xa:.3f}")
            sb.append(f"YA = {ya:.3f}\n")
            sb.append(f"XB = {xb:.3f}")
            sb.append(f"YB = {yb:.3f}\n")
            sb.append(f"α = {self.dms_to_string(anga_dms)}")
            sb.append(f"β = {self.dms_to_string(angb_dms)}\n")
            sb.append("计算结果:")
            sb.append(f"XP = {xp:.3f}")
            sb.append(f"YP = {yp:.3f}")
            self.result_box.setText("\n".join(sb))

            # 存储数据用于绘图并触发重绘
            self.points_data = (xa, ya, xb, yb, xp, yp, anga_rad, angb_rad)
            self.drawing_canvas.set_points(self.points_data)

        except ValueError:
            QMessageBox.warning(self, "输入错误", "请输入有效的数字！角度请使用 D.mmss 格式。") #
        except ZeroDivisionError:
            QMessageBox.critical(self, "计算错误", "角度计算错误（cot(a)+cot(b)为0）。")
        except Exception as e:
            QMessageBox.critical(self, "计算错误", str(e))

# -------------------- 实验七：地形图编号对话框 --------------------
class MapNumberingDialog(QDialog):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("实验七：地形图分幅编号计算")
        self.setMinimumSize(500, 450)

        # 比例尺代码, 经度差(秒), 纬度差(秒)
        #
        self.scales_info = [
            {'name': "1/100万", 'code': 'A', 'lng_diff_sec': 6*3600,     'lat_diff_sec': 4*3600},
            {'name': "1/50万",  'code': 'B', 'lng_diff_sec': 3*3600,     'lat_diff_sec': 2*3600},
            {'name': "1/25万",  'code': 'C', 'lng_diff_sec': 1*3600+30*60, 'lat_diff_sec': 1*3600},
            {'name': "1/10万",  'code': 'D', 'lng_diff_sec': 30*60,      'lat_diff_sec': 20*60},
            {'name': "1/5万",   'code': 'E', 'lng_diff_sec': 15*60,      'lat_diff_sec': 10*60},
            {'name': "1/2.5万", 'code': 'F', 'lng_diff_sec': 7*60+30,    'lat_diff_sec': 5*60},
            {'name': "1/10000", 'code': 'G', 'lng_diff_sec': 3*60+45,    'lat_diff_sec': 2*60+30},
            {'name': "1/5000",  'code': 'H', 'lng_diff_sec': 1*60+52.5,  'lat_diff_sec': 1*60+15}
        ]

        layout = QVBoxLayout(self)
        grid = QGridLayout()

        grid.addWidget(QLabel("比例尺:"), 0, 0)
        self.combo_scale = QComboBox()
        self.combo_scale.addItems([s['name'] for s in self.scales_info]) #
        grid.addWidget(self.combo_scale, 0, 1)

        grid.addWidget(QLabel("经度 (度/分/秒):"), 1, 0)
        self.txt_lon = QLineEdit("113/47/39.66")
        grid.addWidget(self.txt_lon, 1, 1)

        grid.addWidget(QLabel("纬度 (度/分/秒):"), 2, 0)
        self.txt_lat = QLineEdit("34/46/47.25")
        grid.addWidget(self.txt_lat, 2, 1)

        layout.addLayout(grid)

        self.btn_calc = QPushButton("计算图幅编号")
        self.btn_calc.clicked.connect(self.calculate)
        layout.addWidget(self.btn_calc)

        self.result_box = QTextEdit()
        self.result_box.setReadOnly(True)
        layout.addWidget(self.result_box, 1)

    def parse_dms_to_deg(self, dms_str):
        #
        parts = dms_str.strip().split('/')
        if len(parts) < 1: return 0.0
        d = float(parts[0]) if parts[0] else 0.0
        m = float(parts[1]) if len(parts) > 1 and parts[1] else 0.0
        s = float(parts[2]) if len(parts) > 2 and parts[2] else 0.0
        return d + m / 60.0 + s / 3600.0

    def calculate(self):
        try:
            scale_index = self.combo_scale.currentIndex()
            scale_info = self.scales_info[scale_index]
            scale_char = scale_info['code'] #

            lon_str = self.txt_lon.text()
            lat_str = self.txt_lat.text()

            lon_deg = self.parse_dms_to_deg(lon_str)
            lat_deg = self.parse_dms_to_deg(lat_str)

            if not (0 <= lon_deg <= 180 and 0 <= lat_deg <= 90):
                QMessageBox.warning(self, "范围错误", "经度范围: 0-180度，纬度范围: 0-90度") #
                return

            # 1:100万图幅编号
            a = int(math.floor(lat_deg / 4)) + 1 # 1:100万行号
            b = int(math.floor(lon_deg / 6)) + 31 # 1:100万列号
            row_char = chr(64 + a) # A, B, C...
            col_num_1M = f"{b:02}"

            # 计算内部行列号
            lat_total_sec = lat_deg * 3600 #
            lon_total_sec = lon_deg * 3600 #

            lat_diff_sec = scale_info['lat_diff_sec'] #
            lng_diff_sec = scale_info['lng_diff_sec'] #

            #
            lat_base_sec = math.floor(lat_deg / 4) * 4 * 3600
            lat_in_1M = lat_total_sec - lat_base_sec
            c_index = math.floor(lat_in_1M / lat_diff_sec)
            rows_in_1M = int(round((4*3600) / lat_diff_sec))
            c = rows_in_1M - c_index

            #
            lon_base_sec = math.floor(lon_deg / 6) * 6 * 3600
            lon_in_1M = lon_total_sec - lon_base_sec
            d_index = math.floor(lon_in_1M / lng_diff_sec)
            d = 1 + d_index

            row_num_inner = f"{int(c):03}" #
            col_num_inner = f"{int(d):03}" #

            final_code = f"{row_char}{col_num_1M}{scale_char}{row_num_inner}{col_num_inner}" #

            sb = []
            sb.append("=== 地形图分幅编号计算结果 ===") #
            sb.append(f"【输入参数】") #
            sb.append(f"比例尺: {scale_info['name']}") #
            sb.append(f"经度: {lon_str} (={lon_deg:.6f}°)")
            sb.append(f"纬度: {lat_str} (={lat_deg:.6f}°)\n")
            sb.append("【计算过程】") #
            sb.append(f"1:100万图幅行号: {a} → {row_char}") #
            sb.append(f"1:100万图幅列号: {b}") #
            sb.append(f"比例尺代码: {scale_char}") #
            sb.append(f"内部行号(c): {row_num_inner}")
            sb.append(f"内部列号(d): {col_num_inner}\n")
            sb.append("【最终结果】") #
            sb.append(f"地形图编号: {final_code}") #

            self.result_box.setText("\n".join(sb))

        except ValueError:
            QMessageBox.warning(self, "输入错误", "请输入有效的数字！格式：度/分/秒") #
        except Exception as e:
            QMessageBox.critical(self, "计算错误", str(e))


# -------------------- 实验八：水准闭合差对话框 --------------------
class LevelingDialog(QDialog):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("实验八：闭合水准路线闭合差计算")
        self.setMinimumSize(450, 500)

        self.n_points = 6 # 固定为6个点

        layout = QVBoxLayout(self)
        layout.addWidget(QLabel(f"请输入 {self.n_points} 个高差 (单位: m):")) #

        grid = QGridLayout()
        self.txt_inputs = []
        for i in range(self.n_points):
            txt = QLineEdit() #
            self.txt_inputs.append(txt)
            row, col = divmod(i, 3)
            grid.addWidget(txt, row, col) #

        # 预填示例数据
        self.txt_inputs[0].setText("1")
        self.txt_inputs[1].setText("-1")
        self.txt_inputs[2].setText("2")
        self.txt_inputs[3].setText("-2")
        self.txt_inputs[4].setText("0")
        self.txt_inputs[5].setText("0.005")

        layout.addLayout(grid)

        self.btn_calc = QPushButton("计算闭合差") #
        self.btn_calc.clicked.connect(self.calculate)
        layout.addWidget(self.btn_calc)

        self.result_box = QTextEdit()
        self.result_box.setReadOnly(True) #
        self.result_box.setFontFamily("Consolas")
        layout.addWidget(self.result_box, 1)

    def calculate(self):
        delta_h = []
        sum_h = 0.0

        try:
            for i in range(self.n_points):
                val_str = self.txt_inputs[i].text().strip()
                if not val_str:
                    raise ValueError(f"第 {i+1} 个高差为空！")
                val = float(val_str) #
                delta_h.append(val)
                sum_h += val #
        except ValueError as e:
            QMessageBox.warning(self, "输入错误", f"高差输入无效！\n{e}") #
            return

        f = round(sum_h, 3) # 闭合差

        sb = []
        sb.append(f"闭合差 f = {f:.3f} m") #

        # 闭合差限差 5cm = 0.05m
        if abs(f) > 0.05: #
            sb.append("\n⚠ 闭合差超限！") #
            QMessageBox.warning(self, "超限", "闭合差超限！请检查测量数据。") #
        else:
            correction = -f / self.n_points #
            sb.append(f"平均改正值 = {correction:.3f} m") #
            sb.append("\n改正后高差：") #

            for i in range(self.n_points):
                corrected = delta_h[i] + correction #
                sb.append(f"  第{i+1}段: {corrected:.3f} m") #
            sb.append("\n✅ 闭合差平差完成。") #

        self.result_box.setText("\n".join(sb))


if __name__ == "__main__":
    try:
        from PyQt5.Qt import qputenv
        qputenv(b"QT_SCALE_FACTOR", b"1.0")
    except:
        pass
        
    app = QApplication(sys.argv)
    # 不在这里设置样式表
    
    # =======================================================
    # 启动登录界面 (实验五)
    # =======================================================
    login_dialog = LoginDialog()
    if login_dialog.exec_() == QDialog.Accepted:
        # 登录成功，显示主窗口
        w = MainWindow()
        w.showMaximized() # 主程序最大化显示
        
        # 关键：在主窗口显示后，设置默认的样式表
        # 这样 MainWindow 才能正确继承
        w.apply_ui_preferences(persist=False)

        sys.exit(app.exec_())
    else:
        # 用户取消登录，LoginDialog 的 reject() 已经调用 QApplication.quit()
        sys.exit(0) # 确保程序退出