gui.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
昭通洪水可视化集成程序 - GUI模块
包含所有GUI界面相关的类和函数
"""
import sys
import os

# 添加当前目录到Python路径
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

print("Starting flood visualization application...")
print(f"Python version: {sys.version}")
print(f"Current directory: {os.getcwd()}")
print(f"Script directory: {os.path.dirname(os.path.abspath(__file__))}")

import tkinter as tk
from tkinter import ttk, filedialog, messagebox
import matplotlib
# 优化matplotlib后端
matplotlib.use('Agg')  # 使用Agg后端，提高渲染性能
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
from matplotlib.figure import Figure
import numpy as np
import pandas as pd
from scipy.optimize import curve_fit
import plotly.graph_objects as go
from plotly.subplots import make_subplots
from plotly.offline import plot_mpl
import threading
import queue
import time

# 图表绘制任务队列
plot_queue = queue.Queue()

# 图表绘制线程类
class PlotThread(threading.Thread):
    """异步图表绘制线程"""
    def __init__(self, queue):
        threading.Thread.__init__(self, daemon=True)
        self.queue = queue
        self.running = True
    
    def run(self):
        """运行图表绘制线程"""
        while self.running:
            try:
                # 从队列获取任务
                task = self.queue.get(timeout=0.1)
                if task is None:
                    break
                
                # 执行图表绘制任务
                func, args, kwargs = task
                try:
                    func(*args, **kwargs)
                except Exception as e:
                    print(f"图表绘制错误: {e}")
                finally:
                    # 标记任务完成
                    self.queue.task_done()
            except queue.Empty:
                continue
            except Exception as e:
                print(f"图表绘制线程错误: {e}")
    
    def stop(self):
        """停止图表绘制线程"""
        self.running = False
        # 发送终止信号
        self.queue.put(None)

# 启动图表绘制线程
plot_thread = PlotThread(plot_queue)
plot_thread.start()

# 异步绘制装饰器
def async_plot(func):
    """异步绘制图表的装饰器"""
    def wrapper(*args, **kwargs):
        # 将绘制任务放入队列
        plot_queue.put((func, args, kwargs))
    return wrapper

# 导入配置文件
from config import (
    FLOOD_TYPE_PARAMS,
    DEFAULT_PARAMS,
    CHART_CONFIG
)

# 导入计算模块
from calculations import (
    get_eta_value,
    calculate_pd0,
    calculate_qm0,
    calculate_w240,
    calculate_qp,
    calculate_w24p,
    calculate_phi,
    calculate_kp,
    find_water_depth,
    calculate_scour_coefficient,
    calculate_bridge_average_velocity,
    calculate_backwater_coefficient,
    calculate_max_backwater_height,
    calculate_backwater_curve_length,
    calculate_bridge_cross_section_area,
    calculate_soil_erosion_modulus,
    calculate_unit_hydrograph_design_flood
)

# 导入工具模块
from utils import (
    validate_numeric_input,
    parse_float_list,
    export_to_excel,
    save_plot,
    get_return_period_label,
    format_number,
    generate_flood_risk_map,
    generate_flood_impact_map
)

# 导入业务逻辑模块
from business_logic import FloodCalculationService

# -------------------------- GUI界面类 --------------------------

class FloodVisualizationApp:
    """
    昭通洪水可视化集成程序主界面类
    """
    def __init__(self, root):
        self.root = root
        self.root.title("昭通洪水可视化集成程序")
        # 调整窗口大小，使其更适合现代显示器
        self.root.geometry("1400x900")
        self.root.minsize(1280, 720)
        # 添加窗口大小变化事件
        self.root.bind("<Configure>", self.on_window_resize)
        
        # 设置主题样式
        self.style = ttk.Style()
        self.style.theme_use('clam')
        
        # 现代化洪水相关配色方案 - 更协调的蓝色系
        # 主色调：蓝色系（代表水、河流），使用更专业的蓝色调
        primary_color = '#0f766e'  # 深青色（代表专业、可靠）
        primary_hover = '#0d9488'  # 亮青色（悬停效果）
        secondary_color = '#3b82f6'  # 蓝色（辅助色）
        secondary_hover = '#60a5fa'  # 亮蓝色（悬停效果）
        accent_color = '#f59e0b'  # 橙色（强调色，用于重要按钮）
        accent_hover = '#fbbf24'  # 亮橙色（悬停效果）
        warning_color = '#f59e0b'  # 警告黄色
        warning_hover = '#fbbf24'  # 警告黄色悬停
        danger_color = '#ef4444'  # 危险红色
        danger_hover = '#f87171'  # 危险红色悬停
        background_color = '#f0f4f8'  # 浅蓝色背景（更清爽）
        card_color = '#ffffff'  # 卡片白色
        text_color = '#1e293b'  # 深灰文字（提高可读性）
        text_secondary = '#64748b'  # 次要文字颜色
        border_color = '#cbd5e1'  # 边框颜色
        focus_color = '#3b82f6'  # 焦点颜色
        
        # 配置颜色主题，确保使用支持中文的字体
        self.style.configure('TLabel', font=('Microsoft YaHei', 10), foreground=text_color, background=background_color)
        
        # 主按钮样式
        self.style.configure('TButton', font=('Microsoft YaHei', 10, 'bold'), padding=8, foreground='white', background=primary_color, borderwidth=0, relief='flat', borderradius=4)
        self.style.map('TButton', 
                      background=[('active', primary_hover), ('disabled', '#cbd5e1'), ('hover', primary_hover)],
                      foreground=[('disabled', '#94a3b8')],
                      relief=[('pressed', 'flat'), ('!pressed', 'flat')],
                      padding=[('hover', 10)])
        
        # 强调按钮样式
        self.style.configure('Accent.TButton', font=('Microsoft YaHei', 10, 'bold'), padding=8, foreground='white', background=accent_color, borderwidth=0, relief='flat', borderradius=4)
        self.style.map('Accent.TButton', 
                      background=[('active', accent_hover), ('disabled', '#cbd5e1'), ('hover', accent_hover)],
                      foreground=[('disabled', '#94a3b8')],
                      relief=[('pressed', 'flat'), ('!pressed', 'flat')],
                      padding=[('hover', 10)])
        
        # 次要按钮样式
        self.style.configure('Secondary.TButton', font=('Microsoft YaHei', 10), padding=8, foreground=text_color, background='#e2e8f0', borderwidth=0, relief='flat', borderradius=4)
        self.style.map('Secondary.TButton', 
                      background=[('active', '#cbd5e1'), ('disabled', '#f1f5f9'), ('hover', '#cbd5e1')],
                      foreground=[('disabled', '#94a3b8')],
                      relief=[('pressed', 'flat'), ('!pressed', 'flat')],
                      padding=[('hover', 10)])
        
        # 输入框样式
        self.style.configure('TEntry', font=('Microsoft YaHei', 10), fieldbackground=card_color, bordercolor=border_color, relief='flat', borderwidth=1, padding=8)
        self.style.map('TEntry', 
                      fieldbackground=[('focus', card_color)],
                      bordercolor=[('focus', focus_color), ('!focus', border_color)],
                      relief=[('focus', 'solid'), ('!focus', 'flat')])
        
        # 下拉框样式
        self.style.configure('TCombobox', font=('Microsoft YaHei', 10), fieldbackground=card_color, bordercolor=border_color, relief='flat', borderwidth=1, padding=8)
        self.style.map('TCombobox', 
                      fieldbackground=[('focus', card_color)],
                      bordercolor=[('focus', focus_color), ('!focus', border_color)],
                      relief=[('focus', 'solid'), ('!focus', 'flat')])
        
        # 复选框样式
        self.style.configure('TCheckbutton', font=('Microsoft YaHei', 10), foreground=text_color, background=background_color, padding=5)
        self.style.map('TCheckbutton', 
                      foreground=[('active', primary_color), ('hover', primary_color)],
                      background=[('active', background_color), ('hover', background_color)])
        
        # 单选按钮样式
        self.style.configure('TRadiobutton', font=('Microsoft YaHei', 10), foreground=text_color, background=background_color, padding=5)
        self.style.map('TRadiobutton', 
                      foreground=[('active', primary_color), ('hover', primary_color)],
                      background=[('active', background_color), ('hover', background_color)])
        
        self.style.configure('TLabelframe', font=('Microsoft YaHei', 11, 'bold'), padding=12, background=background_color, bordercolor=border_color, relief='flat', borderwidth=1)
        self.style.configure('TLabelframe.Label', font=('Microsoft YaHei', 11, 'bold'), foreground=primary_color, background=background_color)
        
        # 改进标签页样式
        self.style.configure('TNotebook', background=background_color, bordercolor=border_color, relief='flat', padding=5)
        self.style.configure('TNotebook.Tab', font=('Microsoft YaHei', 11, 'bold'), padding=[15, 8], background='#e2e8f0', foreground=text_color, relief='flat', borderwidth=0, borderradius=4)
        self.style.map('TNotebook.Tab', 
                      background=[('selected', primary_color), ('active', '#cbd5e1'), ('hover', '#cbd5e1')],
                      foreground=[('selected', 'white'), ('active', text_color), ('hover', text_color)],
                      relief=[('selected', 'flat'), ('!selected', 'flat')])
        
        # 优化表格样式
        self.style.configure('Treeview', 
                           font=('Microsoft YaHei', 10), 
                           background=card_color, 
                           foreground=text_color, 
                           fieldbackground=card_color, 
                           relief='flat',
                           rowheight=28,  # 增加行高，提高可读性
                           padding=8)  # 增加内边距
        self.style.configure('Treeview.Heading', 
                           font=('Microsoft YaHei', 10, 'bold'), 
                           background=primary_color, 
                           foreground='white', 
                           bordercolor=border_color, 
                           relief='flat',
                           padding=12)  # 增加表头内边距
        self.style.map('Treeview', 
                      background=[('selected', '#bfdbfe'), ('hover', '#f1f5f9')],
                      foreground=[('selected', text_color)],
                      fieldbackground=[('selected', '#bfdbfe'), ('hover', '#f1f5f9')])
        
        self.style.configure('Horizontal.TScrollbar', background='#cbd5e1', troughcolor='#f1f5f9', relief='flat', borderwidth=1)
        self.style.configure('Vertical.TScrollbar', background='#cbd5e1', troughcolor='#f1f5f9', relief='flat', borderwidth=1)
        self.style.map('Horizontal.TScrollbar', 
                      background=[('active', focus_color), ('hover', focus_color)],
                      troughcolor=[('hover', '#e2e8f0')])
        self.style.map('Vertical.TScrollbar', 
                      background=[('active', focus_color), ('hover', focus_color)],
                      troughcolor=[('hover', '#e2e8f0')])
        
        # 设置Tkinter默认字体和样式
        self.root.option_add('*Background', background_color)
        self.root.option_add('*Foreground', text_color)
        
        # 设置窗口背景色
        self.root.configure(bg=background_color)
        
        # 数据存储
        self.flood_service = FloodCalculationService()
        
        self.design_flood_data = {
            'basic_params': {},
            'intermediate_results': {},
            'design_results': []
        }
        
        self.flood_level_data = {
            'params': {},
            'results': []
        }
        
        self.water_level_discharge_data = {
            'discharges': [],
            'water_levels': [],
            'return_periods': [],
            'bank_elevation': None,
            'bridge_bottom_elevation': None,
            'bridge_name': "桥梁"
        }
        
        # 历史洪水对比数据
        self.compare_charts_data = []
        
        self.backwater_analysis_data = {
            'params': {},
            'results': []
        }
        
        # 进度条相关变量
        self.progress_window = None
        self.progress_bar = None
        self.progress_label = None
        
        # 创建工具栏
        self.create_toolbar()
        
        # 绑定快捷键
        self.bind_shortcuts()
        
        # 创建主框架
        self.main_frame = ttk.Frame(self.root, padding="10")
        self.main_frame.pack(fill=tk.BOTH, expand=True)
        
        # 配置主框架的网格布局，确保其能够正确响应窗口大小变化
        self.main_frame.grid_rowconfigure(0, weight=1)
        self.main_frame.grid_columnconfigure(0, weight=1)
        
        # 添加洪水相关的视觉元素
        self.add_flood_visual_elements()
        
        # 创建功能选择标签页
        self.create_tab_control()
        
        # 创建状态栏
        self.create_status_bar()
        
        # 添加窗口关闭事件处理
        self.root.protocol("WM_DELETE_WINDOW", self.on_closing)
        
    def on_closing(self):
        """窗口关闭事件处理"""
        try:
            # 停止图表绘制线程
            plot_thread.stop()
        except Exception as e:
            print(f"停止图表绘制线程错误: {e}")
        
        # 关闭所有matplotlib图形
        plt.close('all')
        
        # 销毁主窗口
        self.root.destroy()
        
        # 退出程序
        sys.exit(0)
        
    def create_tab_control(self):
        """创建功能选择标签页"""
        # 创建头部区域，包含标题和视觉元素
        header_frame = ttk.Frame(self.main_frame, padding="20")
        header_frame.pack(fill=tk.X, pady=5)
        
        # 左侧：洪水相关视觉元素
        visual_frame = ttk.Frame(header_frame)
        visual_frame.pack(side=tk.LEFT, padx=10)
        
        # 显示洪水相关的图标，使用文本图标避免依赖PIL库
        ttk.Label(visual_frame, text="🌊", font=('Arial', 48)).pack()
        
        # 右侧：应用标题和描述
        title_frame = ttk.Frame(header_frame)
        title_frame.pack(side=tk.LEFT, padx=20, fill=tk.BOTH, expand=True)
        
        # 主标题 - 使用更现代的字体和颜色
        main_title = ttk.Label(title_frame, text="昭通洪水可视化集成程序", font=('Microsoft YaHei', 20, 'bold'), foreground='#0f766e')
        main_title.pack(anchor=tk.W)
        
        # 副标题 - 使用次要文字颜色
        sub_title = ttk.Label(title_frame, text="专业的洪水计算与可视化工具", font=('Microsoft YaHei', 12), foreground='#64748b')
        sub_title.pack(anchor=tk.W, pady=5)
        
        # 分隔线 - 更粗的分隔线，增强视觉层次感
        separator = ttk.Separator(header_frame, orient=tk.HORIZONTAL)
        separator.pack(fill=tk.X, pady=15)
        
        # 创建标签控件
        self.tab_control = ttk.Notebook(self.main_frame)
        
        # 创建各个标签页
        self.tab1 = ttk.Frame(self.tab_control)
        self.tab2 = ttk.Frame(self.tab_control)
        self.tab3 = ttk.Frame(self.tab_control)
        self.tab4 = ttk.Frame(self.tab_control)
        self.tab5 = ttk.Frame(self.tab_control)
        self.tab6 = ttk.Frame(self.tab_control)
        self.tab7 = ttk.Frame(self.tab_control)  # 洪水风险图标签页
        
        # 添加标签页到标签控件 - 使用图标增强视觉识别性
        self.tab_control.add(self.tab1, text='📊 设计洪水计算')
        self.tab_control.add(self.tab2, text='🌊 洪水位计算')
        self.tab_control.add(self.tab3, text='📈 水位流量关系图')
        self.tab_control.add(self.tab5, text='⚡ 壅水分析计算')
        self.tab_control.add(self.tab6, text='📋 历史洪水对比')
        self.tab_control.add(self.tab7, text='🗺️ 洪水风险图')
        self.tab_control.add(self.tab4, text='📁 计算结果')
        
        # 配置标签控件，使其能够正确响应窗口大小变化
        self.tab_control.pack(fill=tk.BOTH, expand=True, pady=10)
        
        # 添加标签页切换事件，用于更新状态栏信息
        self.tab_control.bind("<<NotebookTabChanged>>", self.on_tab_changed)
        
        # 初始化各个标签页内容
        self.init_compare_charts_tab()
        self.init_design_flood_tab()
        self.init_flood_level_tab()
        self.init_water_level_discharge_tab()
        self.init_results_tab()
        self.init_backwater_analysis_tab()
        self.init_flood_risk_tab()  # 初始化洪水风险图标签页
    
    def init_design_flood_tab(self):
        """初始化设计洪水计算标签页"""
        # 创建主布局框架
        main_frame = ttk.Frame(self.tab1, padding="20")
        main_frame.pack(fill=tk.BOTH, expand=True)
        
        # 使用Grid布局替代Pack布局，提高响应式能力
        main_frame.columnconfigure(0, minsize=380, weight=0)  # 输入面板固定宽度，适当增加宽度
        main_frame.columnconfigure(1, weight=1)  # 结果面板自适应扩展
        main_frame.rowconfigure(0, weight=1)
        
        # 左侧输入面板容器（带滚动条）
        input_container = ttk.Frame(main_frame, style='Card.TFrame')
        input_container.grid(row=0, column=0, sticky="nsew", padx=10, pady=10)
        
        # 创建Canvas和滚动条
        canvas = tk.Canvas(input_container, width=380, bg=self.style.configure('.')['background'])
        scrollbar = ttk.Scrollbar(input_container, orient="vertical", command=canvas.yview)
        scrollable_frame = ttk.Frame(canvas)
        
        # 配置Canvas
        scrollable_frame.bind(
            "<Configure>",
            lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
        )
        
        canvas.create_window((0, 0), window=scrollable_frame, anchor="nw", width=380)
        canvas.configure(yscrollcommand=scrollbar.set)
        
        # 布局Canvas和滚动条
        canvas.pack(side="left", fill="both", expand=True)
        scrollbar.pack(side="right", fill="y")
        
        # 左侧输入面板 - 使用更现代的卡片式设计
        input_frame = ttk.LabelFrame(scrollable_frame, text="输入参数", padding="20", style='Card.TLabelframe')
        input_frame.pack(fill=tk.BOTH, expand=True, pady=10)
        
        # 右侧结果面板容器
        result_container = ttk.Frame(main_frame, style='Card.TFrame')
        result_container.grid(row=0, column=1, sticky="nsew", padx=10, pady=10)
        
        # 创建Canvas和滚动条
        result_canvas = tk.Canvas(result_container, bg=self.style.configure('.')['background'])
        result_scrollbar = ttk.Scrollbar(result_container, orient="vertical", command=result_canvas.yview)
        result_scrollable_frame = ttk.Frame(result_canvas)
        
        # 配置Canvas
        result_scrollable_frame.bind(
            "<Configure>",
            lambda e: result_canvas.configure(scrollregion=result_canvas.bbox("all"))
        )
        
        result_canvas.create_window((0, 0), window=result_scrollable_frame, anchor="nw")
        result_canvas.configure(yscrollcommand=result_scrollbar.set)
        
        # 布局Canvas和滚动条
        result_canvas.pack(side="left", fill="both", expand=True)
        result_scrollbar.pack(side="right", fill="y")
        
        # 右侧结果面板 - 使用卡片式设计
        result_frame = ttk.LabelFrame(result_scrollable_frame, text="计算结果", padding="20", style='Card.TLabelframe')
        result_frame.pack(fill=tk.BOTH, expand=True)
        
        # 输入面板内容
        self.create_design_flood_input(input_frame)
        
        # 结果面板内容
        self.create_design_flood_result(result_frame)
    
    def create_design_flood_input(self, parent):
        """创建设计洪水计算输入表单"""
        # 创建验证变量和函数
        vcmd_float = (self.root.register(self.validate_float), '%P', '%W')
        vcmd_float_positive = (self.root.register(self.validate_float_positive), '%P', '%W')
        vcmd_float_non_negative = (self.root.register(self.validate_float_non_negative), '%P', '%W')
        vcmd_list = (self.root.register(self.validate_float_list), '%P', '%W')
        invcmd = (self.root.register(self.invalid_input), '%W')
        
        # 计算方法选择卡片
        method_card = ttk.LabelFrame(parent, text="计算方法选择", padding="15")
        method_card.pack(fill=tk.X, expand=True, pady=10)
        
        # 创建方法选择框架，使用并列的复选框
        ttk.Label(method_card, text="请选择计算方法（可多选）：", font=('Microsoft YaHei', 10, 'bold')).pack(anchor=tk.W, pady=(0, 10))
        method_frame = ttk.Frame(method_card)
        method_frame.pack(fill=tk.X, pady=5)
        
        # 创建复选框变量
        self.traditional_method_var = tk.BooleanVar(value=True)
        self.unit_hydrograph_method_var = tk.BooleanVar(value=False)
        
        ttk.Checkbutton(method_frame, text="📊 地区综合法", variable=self.traditional_method_var, command=self.toggle_method_frames).pack(anchor=tk.W, pady=5, side=tk.LEFT, padx=10)
        ttk.Checkbutton(method_frame, text="📈 单位线法", variable=self.unit_hydrograph_method_var, command=self.toggle_method_frames).pack(anchor=tk.W, pady=5, side=tk.LEFT, padx=20)
        
        # 传统方法输入卡片
        self.traditional_method_frame = ttk.LabelFrame(parent, text="地区综合法参数", padding="15")
        self.traditional_method_frame.pack(fill=tk.X, expand=True, pady=10)
        self.create_traditional_method_input(self.traditional_method_frame, vcmd_float, vcmd_float_positive, vcmd_float_non_negative, vcmd_list, invcmd)
        
        # 单位线法输入卡片
        self.unit_hydrograph_method_frame = ttk.LabelFrame(parent, text="单位线法参数", padding="15")
        self.unit_hydrograph_method_frame.pack(fill=tk.X, expand=True, pady=10)
        self.create_unit_hydrograph_method_input(self.unit_hydrograph_method_frame, vcmd_float, vcmd_float_positive, vcmd_float_non_negative, vcmd_list, invcmd)
        

        
        # 按钮框架 - 使用更现代的布局
        button_frame = ttk.Frame(parent, padding=10)
        button_frame.pack(fill=tk.X, pady=15)
        
        # 按钮网格布局
        button_frame.columnconfigure(0, weight=1)
        button_frame.columnconfigure(1, weight=1)
        
        # 保存参数按钮
        ttk.Button(button_frame, text="💾 保存参数", command=lambda: self.save_params("design_flood"), style='Secondary.TButton').grid(row=0, column=0, padx=5, pady=5, sticky="ew")
        
        # 加载参数按钮
        ttk.Button(button_frame, text="📂 加载参数", command=lambda: self.load_params("design_flood"), style='Secondary.TButton').grid(row=0, column=1, padx=5, pady=5, sticky="ew")
        
        # 计算按钮
        ttk.Button(button_frame, text="🚀 开始计算", command=self.calculate_design_flood, style='Accent.TButton').grid(row=1, column=0, padx=5, pady=5, sticky="ew")
        
        # 批量计算按钮
        ttk.Button(button_frame, text="📋 批量计算", command=self.batch_calculate_design_flood, style='TButton').grid(row=1, column=1, padx=5, pady=5, sticky="ew")
        
        # 重置按钮
        ttk.Button(button_frame, text="🔄 重置", command=self.reset_design_flood_input, style='Secondary.TButton').grid(row=2, column=0, columnspan=2, padx=5, pady=5, sticky="ew")
    
    def create_traditional_method_input(self, parent, vcmd_float, vcmd_float_positive, vcmd_float_non_negative, vcmd_list, invcmd):
        """创建传统方法输入表单"""
        # 洪水类型选择
        ttk.Label(parent, text="洪水类型：").pack(anchor=tk.W, pady=(10, 5))
        self.flood_type_var = tk.StringVar()
        flood_type_options = list(FLOOD_TYPE_PARAMS.keys())
        flood_type_combobox = ttk.Combobox(parent, textvariable=self.flood_type_var, values=flood_type_options, width=30)
        flood_type_combobox.pack(fill=tk.X, pady=2)
        flood_type_combobox.current(1)  # 默认选择泼机河型
        
        # 流域面积
        ttk.Label(parent, text="流域面积（km²）：").pack(anchor=tk.W, pady=(15, 5))
        self.area_entry = ttk.Entry(parent, width=30, validate="key", validatecommand=vcmd_float_positive, invalidcommand=invcmd)
        self.area_entry.pack(fill=tk.X, pady=2)
        self.area_entry.insert(0, str(DEFAULT_PARAMS['design_flood']['area']))
        
        # 24h点暴雨均值
        ttk.Label(parent, text="24h点暴雨均值（mm）：").pack(anchor=tk.W, pady=(15, 5))
        self.pd24_entry = ttk.Entry(parent, width=30, validate="key", validatecommand=vcmd_float_positive, invalidcommand=invcmd)
        self.pd24_entry.pack(fill=tk.X, pady=2)
        self.pd24_entry.insert(0, str(DEFAULT_PARAMS['design_flood']['pd24']))
        
        # 点面折减系数η
        ttk.Label(parent, text="点面折减系数η：").pack(anchor=tk.W, pady=(15, 5))
        self.eta_entry = ttk.Entry(parent, width=30, validate="key", validatecommand=vcmd_float_non_negative, invalidcommand=invcmd)
        self.eta_entry.pack(fill=tk.X, pady=2)
        self.eta_entry.insert(0, str(DEFAULT_PARAMS['design_flood']['eta']))
        
        # 地理参数C
        ttk.Label(parent, text="地理参数C：").pack(anchor=tk.W, pady=(15, 5))
        self.c_entry = ttk.Entry(parent, width=30, validate="key", validatecommand=vcmd_float_non_negative, invalidcommand=invcmd)
        self.c_entry.pack(fill=tk.X, pady=2)
        self.c_entry.insert(0, str(DEFAULT_PARAMS['design_flood']['c']))
        
        # 指数n
        ttk.Label(parent, text="指数n：").pack(anchor=tk.W, pady=(15, 5))
        self.n_exp_entry = ttk.Entry(parent, width=30, validate="key", validatecommand=vcmd_float_positive, invalidcommand=invcmd)
        self.n_exp_entry.pack(fill=tk.X, pady=2)
        self.n_exp_entry.insert(0, str(DEFAULT_PARAMS['design_flood']['n_exp']))
        
        # 洪峰流量变差系数Cv_q
        ttk.Label(parent, text="洪峰流量变差系数Cv_q：").pack(anchor=tk.W, pady=(15, 5))
        self.cv_q_entry = ttk.Entry(parent, width=30, validate="key", validatecommand=vcmd_float_non_negative, invalidcommand=invcmd)
        self.cv_q_entry.pack(fill=tk.X, pady=2)
        self.cv_q_entry.insert(0, str(DEFAULT_PARAMS['design_flood']['cv_q']))
        
        # 24小时洪量变差系数Cv_w24
        ttk.Label(parent, text="24小时洪量变差系数Cv_w24：").pack(anchor=tk.W, pady=(15, 5))
        self.cv_w24_entry = ttk.Entry(parent, width=30, validate="key", validatecommand=vcmd_float_non_negative, invalidcommand=invcmd)
        self.cv_w24_entry.pack(fill=tk.X, pady=2)
        self.cv_w24_entry.insert(0, str(DEFAULT_PARAMS['design_flood']['cv_w24']))
        
        # 设计频率
        ttk.Label(parent, text="设计频率（%，空格分隔，1%对应100年一遇）：").pack(anchor=tk.W, pady=(15, 5))
        self.frequencies_entry = ttk.Entry(parent, width=30, validate="key", validatecommand=vcmd_list, invalidcommand=invcmd)
        self.frequencies_entry.pack(fill=tk.X, pady=2)
        self.frequencies_entry.insert(0, DEFAULT_PARAMS['design_flood']['frequencies'])
    
    def create_unit_hydrograph_method_input(self, parent, vcmd_float, vcmd_float_positive, vcmd_float_non_negative, vcmd_list, invcmd):
        """创建单位线法输入表单"""
        # 流域面积
        ttk.Label(parent, text="流域面积（km²）：").pack(anchor=tk.W, pady=(10, 5))
        self.unit_area_entry = ttk.Entry(parent, width=30, validate="key", validatecommand=vcmd_float_positive, invalidcommand=invcmd)
        self.unit_area_entry.pack(fill=tk.X, pady=2)
        self.unit_area_entry.insert(0, str(DEFAULT_PARAMS['design_flood']['area']))
        
        # 主河道长度
        ttk.Label(parent, text="主河道长度（km）：").pack(anchor=tk.W, pady=(15, 5))
        self.unit_L_entry = ttk.Entry(parent, width=30, validate="key", validatecommand=vcmd_float_positive, invalidcommand=invcmd)
        self.unit_L_entry.pack(fill=tk.X, pady=2)
        self.unit_L_entry.insert(0, "10.0")
        
        # 主河道平均比降
        ttk.Label(parent, text="主河道平均比降（‰）：").pack(anchor=tk.W, pady=(15, 5))
        self.unit_J_entry = ttk.Entry(parent, width=30, validate="key", validatecommand=vcmd_float_positive, invalidcommand=invcmd)
        self.unit_J_entry.pack(fill=tk.X, pady=2)
        self.unit_J_entry.insert(0, "10.0")
        
        # 24h暴雨均值
        ttk.Label(parent, text="24h暴雨均值（mm）：").pack(anchor=tk.W, pady=(15, 5))
        self.unit_H24_entry = ttk.Entry(parent, width=30, validate="key", validatecommand=vcmd_float_positive, invalidcommand=invcmd)
        self.unit_H24_entry.pack(fill=tk.X, pady=2)
        self.unit_H24_entry.insert(0, str(DEFAULT_PARAMS['design_flood']['pd24']))
        
        # 暴雨变差系数
        ttk.Label(parent, text="暴雨变差系数Cv：").pack(anchor=tk.W, pady=(15, 5))
        self.unit_Cv_entry = ttk.Entry(parent, width=30, validate="key", validatecommand=vcmd_float_non_negative, invalidcommand=invcmd)
        self.unit_Cv_entry.pack(fill=tk.X, pady=2)
        self.unit_Cv_entry.insert(0, "0.35")
        
        # 暴雨偏态系数
        ttk.Label(parent, text="暴雨偏态系数Cs：").pack(anchor=tk.W, pady=(15, 5))
        self.unit_Cs_entry = ttk.Entry(parent, width=30, validate="key", validatecommand=vcmd_float_non_negative, invalidcommand=invcmd)
        self.unit_Cs_entry.pack(fill=tk.X, pady=2)
        self.unit_Cs_entry.insert(0, "3.5")
        
        # 设计频率
        ttk.Label(parent, text="设计频率（%，空格分隔，1%对应100年一遇）：").pack(anchor=tk.W, pady=(15, 5))
        self.unit_frequencies_entry = ttk.Entry(parent, width=30, validate="key", validatecommand=vcmd_list, invalidcommand=invcmd)
        self.unit_frequencies_entry.pack(fill=tk.X, pady=2)
        self.unit_frequencies_entry.insert(0, DEFAULT_PARAMS['design_flood']['frequencies'])
    
    def init_flood_level_tab(self):
        """初始化洪水位计算标签页"""
        # 创建主布局框架
        main_frame = ttk.Frame(self.tab2, padding="10")
        main_frame.pack(fill=tk.BOTH, expand=True)
        
        # 使用Grid布局替代Pack布局，提高响应式能力
        main_frame.columnconfigure(0, minsize=300, weight=0)  # 输入面板固定宽度
        main_frame.columnconfigure(1, weight=1)  # 结果面板自适应扩展
        main_frame.rowconfigure(0, weight=1)
        
        # 左侧输入面板容器（带滚动条）
        input_container = ttk.Frame(main_frame)
        input_container.grid(row=0, column=0, sticky="nsew", padx=5, pady=5)
        
        # 创建Canvas和滚动条
        canvas = tk.Canvas(input_container, width=300)
        scrollbar = ttk.Scrollbar(input_container, orient="vertical", command=canvas.yview)
        scrollable_frame = ttk.Frame(canvas)
        
        # 配置Canvas
        scrollable_frame.bind(
            "<Configure>",
            lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
        )
        
        canvas.create_window((0, 0), window=scrollable_frame, anchor="nw", width=300)
        canvas.configure(yscrollcommand=scrollbar.set)
        
        # 布局Canvas和滚动条
        canvas.pack(side="left", fill="both", expand=True)
        scrollbar.pack(side="right", fill="y")
        
        # 左侧输入面板
        input_frame = ttk.LabelFrame(scrollable_frame, text="输入参数", padding="10")
        input_frame.pack(fill=tk.BOTH, expand=True)
        
        # 右侧结果面板容器
        result_container = ttk.Frame(main_frame)
        result_container.grid(row=0, column=1, sticky="nsew", padx=5, pady=5)
        
        # 创建Canvas和滚动条
        result_canvas = tk.Canvas(result_container)
        result_scrollbar = ttk.Scrollbar(result_container, orient="vertical", command=result_canvas.yview)
        result_scrollable_frame = ttk.Frame(result_canvas)
        
        # 配置Canvas
        result_scrollable_frame.bind(
            "<Configure>",
            lambda e: result_canvas.configure(scrollregion=result_canvas.bbox("all"))
        )
        
        result_canvas.create_window((0, 0), window=result_scrollable_frame, anchor="nw")
        result_canvas.configure(yscrollcommand=result_scrollbar.set)
        
        # 布局Canvas和滚动条
        result_canvas.pack(side="left", fill="both", expand=True)
        result_scrollbar.pack(side="right", fill="y")
        
        # 右侧结果面板
        result_frame = ttk.LabelFrame(result_scrollable_frame, text="计算结果", padding="10")
        result_frame.pack(fill=tk.BOTH, expand=True)
        
        # 输入面板内容
        self.create_flood_level_input(input_frame)
        
        # 结果面板内容
        self.create_flood_level_result(result_frame)
    
    def create_flood_level_input(self, parent):
        """创建洪水位计算输入表单"""
        # 创建验证变量和函数
        vcmd_float = (self.root.register(self.validate_float), '%P', '%W')
        vcmd_float_positive = (self.root.register(self.validate_float_positive), '%P', '%W')
        vcmd_float_non_negative = (self.root.register(self.validate_float_non_negative), '%P', '%W')
        vcmd_list = (self.root.register(self.validate_float_list), '%P', '%W')
        invcmd = (self.root.register(self.invalid_input), '%W')
        
        # 断面类型选择
        ttk.Label(parent, text="断面类型：").pack(anchor=tk.W, pady=(10, 5))
        self.section_type_var = tk.StringVar(value="trapezoid")
        
        section_frame = ttk.Frame(parent)
        section_frame.pack(fill=tk.X, pady=2)
        
        ttk.Radiobutton(section_frame, text="矩形断面", variable=self.section_type_var, value="rectangle", command=self.toggle_section_type).pack(anchor=tk.W, pady=2)
        ttk.Radiobutton(section_frame, text="梯形断面", variable=self.section_type_var, value="trapezoid", command=self.toggle_section_type).pack(anchor=tk.W, pady=2)
        
        # 河道宽度
        ttk.Label(parent, text="河道宽度（m）：").pack(anchor=tk.W, pady=(15, 5))
        self.b_entry = ttk.Entry(parent, width=30, validate="key", validatecommand=vcmd_float_positive, invalidcommand=invcmd)
        self.b_entry.pack(fill=tk.X, pady=2)
        self.b_entry.insert(0, str(DEFAULT_PARAMS['flood_level']['b']))
        
        # 边坡系数（梯形断面）
        self.m_frame = ttk.Frame(parent)
        self.m_frame.pack(fill=tk.X, pady=2)
        ttk.Label(self.m_frame, text="边坡系数m：").pack(anchor=tk.W, pady=(15, 5))
        self.m_entry = ttk.Entry(self.m_frame, width=30, validate="key", validatecommand=vcmd_float_positive, invalidcommand=invcmd)
        self.m_entry.pack(fill=tk.X, pady=2)
        self.m_entry.insert(0, str(DEFAULT_PARAMS['flood_level']['m']))
        
        # 河床高程
        ttk.Label(parent, text="河床高程（m）：").pack(anchor=tk.W, pady=(15, 5))
        self.bed_elevation_entry = ttk.Entry(parent, width=30, validate="key", validatecommand=vcmd_float, invalidcommand=invcmd)
        self.bed_elevation_entry.pack(fill=tk.X, pady=2)
        self.bed_elevation_entry.insert(0, str(DEFAULT_PARAMS['flood_level']['bed_elevation']))
        
        # 河岸高程
        ttk.Label(parent, text="河岸高程（m）：").pack(anchor=tk.W, pady=(15, 5))
        self.bank_elevation_entry = ttk.Entry(parent, width=30, validate="key", validatecommand=vcmd_float, invalidcommand=invcmd)
        self.bank_elevation_entry.pack(fill=tk.X, pady=2)
        self.bank_elevation_entry.insert(0, str(DEFAULT_PARAMS['flood_level']['bank_elevation']))
        
        # 曼宁糙率n
        ttk.Label(parent, text="曼宁糙率n：").pack(anchor=tk.W, pady=(15, 5))
        self.n_entry = ttk.Entry(parent, width=30, validate="key", validatecommand=vcmd_float_positive, invalidcommand=invcmd)
        self.n_entry.pack(fill=tk.X, pady=2)
        self.n_entry.insert(0, str(DEFAULT_PARAMS['flood_level']['n']))
        
        # 水面比降S
        ttk.Label(parent, text="水面比降S：").pack(anchor=tk.W, pady=(15, 5))
        self.s_entry = ttk.Entry(parent, width=30, validate="key", validatecommand=vcmd_float_positive, invalidcommand=invcmd)
        self.s_entry.pack(fill=tk.X, pady=2)
        self.s_entry.insert(0, str(DEFAULT_PARAMS['flood_level']['s']))
        
        # 设计流量
        ttk.Label(parent, text="设计洪峰流量（m³/s，空格分隔）：").pack(anchor=tk.W, pady=(15, 5))
        self.q_list_entry = ttk.Entry(parent, width=30, validate="key", validatecommand=vcmd_list, invalidcommand=invcmd)
        self.q_list_entry.pack(fill=tk.X, pady=2)
        self.q_list_entry.insert(0, DEFAULT_PARAMS['flood_level']['q_list'])
        
        # 导入设计洪水结果按钮
        ttk.Button(parent, text="导入设计洪水计算结果", command=self.import_design_flood_to_flood_level, style='TButton').pack(fill=tk.X, pady=10)
        
        # 按钮框架
        button_frame = ttk.Frame(parent)
        button_frame.pack(fill=tk.X, pady=10)
        
        # 保存参数按钮
        ttk.Button(button_frame, text="保存参数", command=lambda: self.save_params("flood_level"), style='TButton').pack(fill=tk.X, pady=5)
        
        # 加载参数按钮
        ttk.Button(button_frame, text="加载参数", command=lambda: self.load_params("flood_level"), style='TButton').pack(fill=tk.X, pady=5)
        
        # 计算按钮
        ttk.Button(button_frame, text="开始计算", command=self.calculate_flood_level, style='TButton').pack(fill=tk.X, pady=5)
        
        # 重置按钮
        ttk.Button(button_frame, text="重置", command=self.reset_flood_level_input, style='TButton').pack(fill=tk.X, pady=5)
    
    def init_water_level_discharge_tab(self):
        """初始化水位流量关系图标签页"""
        # 创建主布局框架
        main_frame = ttk.Frame(self.tab3, padding="10")
        main_frame.pack(fill=tk.BOTH, expand=True)
        
        # 使用Grid布局替代Pack布局，提高响应式能力
        main_frame.columnconfigure(0, minsize=300, weight=0)  # 输入面板固定宽度
        main_frame.columnconfigure(1, weight=1)  # 绘图区域自适应扩展
        main_frame.rowconfigure(0, weight=1)
        
        # 左侧输入面板容器（带滚动条）
        input_container = ttk.Frame(main_frame)
        input_container.grid(row=0, column=0, sticky="nsew", padx=5, pady=5)
        
        # 创建Canvas和滚动条
        canvas = tk.Canvas(input_container, width=300)
        scrollbar = ttk.Scrollbar(input_container, orient="vertical", command=canvas.yview)
        scrollable_frame = ttk.Frame(canvas)
        
        # 配置Canvas
        scrollable_frame.bind(
            "<Configure>",
            lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
        )
        
        canvas.create_window((0, 0), window=scrollable_frame, anchor="nw", width=300)
        canvas.configure(yscrollcommand=scrollbar.set)
        
        # 布局Canvas和滚动条
        canvas.pack(side="left", fill="both", expand=True)
        scrollbar.pack(side="right", fill="y")
        
        # 左侧输入面板
        input_frame = ttk.LabelFrame(scrollable_frame, text="绘图参数", padding="10")
        input_frame.pack(fill=tk.BOTH, expand=True)
        
        # 右侧绘图区域
        plot_frame = ttk.LabelFrame(main_frame, text="水位流量关系图", padding="10")
        plot_frame.grid(row=0, column=1, sticky="nsew", padx=5, pady=5)
        
        # 输入面板内容
        self.create_water_level_discharge_input(input_frame)
        
        # 为绘图区域添加垂直滚动条
        plot_canvas = tk.Canvas(plot_frame)
        plot_scrollbar = ttk.Scrollbar(plot_frame, orient="vertical", command=plot_canvas.yview)
        plot_scrollable_frame = ttk.Frame(plot_canvas)
        
        # 配置Canvas
        plot_scrollable_frame.bind(
            "<Configure>",
            lambda e: plot_canvas.configure(scrollregion=plot_canvas.bbox("all"))
        )
        
        plot_canvas.create_window((0, 0), window=plot_scrollable_frame, anchor="nw")
        plot_canvas.configure(yscrollcommand=plot_scrollbar.set)
        
        # 布局Canvas和滚动条
        plot_canvas.pack(side="left", fill="both", expand=True)
        plot_scrollbar.pack(side="right", fill="y")
        
        # 绘图区域
        self.create_water_level_discharge_plot(plot_scrollable_frame)
    
    def create_water_level_discharge_input(self, parent):
        """创建水位流量关系图输入表单"""
        # 创建验证变量和函数
        vcmd_float = (self.root.register(self.validate_float), '%P', '%W')
        vcmd_float_positive = (self.root.register(self.validate_float_positive), '%P', '%W')
        vcmd_float_non_negative = (self.root.register(self.validate_float_non_negative), '%P', '%W')
        vcmd_list = (self.root.register(self.validate_float_list), '%P', '%W')
        invcmd = (self.root.register(self.invalid_input), '%W')
        
        # 桥梁名称
        ttk.Label(parent, text="桥梁名称：").pack(anchor=tk.W, pady=(10, 5))
        self.bridge_name_entry = ttk.Entry(parent, width=30)
        self.bridge_name_entry.pack(fill=tk.X, pady=2)
        self.bridge_name_entry.insert(0, DEFAULT_PARAMS['water_level_discharge']['bridge_name'])
        
        # 河岸高程
        ttk.Label(parent, text="河岸高程（m）：").pack(anchor=tk.W, pady=(15, 5))
        self.wld_bank_elevation_entry = ttk.Entry(parent, width=30, validate="key", validatecommand=vcmd_float, invalidcommand=invcmd)
        self.wld_bank_elevation_entry.pack(fill=tk.X, pady=2)
        self.wld_bank_elevation_entry.insert(0, str(DEFAULT_PARAMS['water_level_discharge']['bank_elevation']))
        
        # 桥底设计高程
        ttk.Label(parent, text="桥底设计高程（m）：").pack(anchor=tk.W, pady=(15, 5))
        self.wld_bridge_bottom_elevation_entry = ttk.Entry(parent, width=30, validate="key", validatecommand=vcmd_float, invalidcommand=invcmd)
        self.wld_bridge_bottom_elevation_entry.pack(fill=tk.X, pady=2)
        self.wld_bridge_bottom_elevation_entry.insert(0, str(DEFAULT_PARAMS['water_level_discharge']['bridge_bottom_elevation']))
        
        # 数据来源选择
        ttk.Label(parent, text="数据来源：").pack(anchor=tk.W, pady=(15, 5))
        self.data_source_var = tk.StringVar(value="manual")
        
        source_frame = ttk.Frame(parent)
        source_frame.pack(fill=tk.X, pady=2)
        
        ttk.Radiobutton(source_frame, text="使用计算结果数据", variable=self.data_source_var, value="calculated").pack(anchor=tk.W, pady=2)
        ttk.Radiobutton(source_frame, text="手动输入数据", variable=self.data_source_var, value="manual").pack(anchor=tk.W, pady=2)
        
        # 手动输入数据区域
        self.manual_data_frame = ttk.Frame(parent)
        self.manual_data_frame.pack(fill=tk.X, pady=2)
        
        ttk.Label(self.manual_data_frame, text="洪峰流量（m³/s，空格分隔）：").pack(anchor=tk.W, pady=(15, 5))
        self.wld_discharges_entry = ttk.Entry(self.manual_data_frame, width=30, validate="key", validatecommand=vcmd_list, invalidcommand=invcmd)
        self.wld_discharges_entry.pack(fill=tk.X, pady=2)
        self.wld_discharges_entry.insert(0, DEFAULT_PARAMS['water_level_discharge']['discharges'])
        
        ttk.Label(self.manual_data_frame, text="水位高程（m，空格分隔）：").pack(anchor=tk.W, pady=(15, 5))
        self.wld_water_levels_entry = ttk.Entry(self.manual_data_frame, width=30, validate="key", validatecommand=vcmd_list, invalidcommand=invcmd)
        self.wld_water_levels_entry.pack(fill=tk.X, pady=2)
        self.wld_water_levels_entry.insert(0, DEFAULT_PARAMS['water_level_discharge']['water_levels'])
        
        ttk.Label(self.manual_data_frame, text="重现期（年，空格分隔）：").pack(anchor=tk.W, pady=(15, 5))
        self.wld_return_periods_entry = ttk.Entry(self.manual_data_frame, width=30, validate="key", validatecommand=vcmd_list, invalidcommand=invcmd)
        self.wld_return_periods_entry.pack(fill=tk.X, pady=2)
        self.wld_return_periods_entry.insert(0, DEFAULT_PARAMS['water_level_discharge']['return_periods'])
        
        # 导入洪水位计算结果按钮
        ttk.Button(parent, text="导入洪水位计算结果", command=self.import_flood_level_to_wld, style='TButton').pack(fill=tk.X, pady=10)
        
        # 按钮框架
        button_frame = ttk.Frame(parent)
        button_frame.pack(fill=tk.X, pady=10)
        
        # 保存参数按钮
        ttk.Button(button_frame, text="保存参数", command=lambda: self.save_params("water_level_discharge"), style='TButton').pack(fill=tk.X, pady=5)
        
        # 加载参数按钮
        ttk.Button(button_frame, text="加载参数", command=lambda: self.load_params("water_level_discharge"), style='TButton').pack(fill=tk.X, pady=5)
        
        # 绘图按钮
        ttk.Button(button_frame, text="绘制图表", command=self.plot_water_level_discharge, style='TButton').pack(fill=tk.X, pady=5)
        
        # 重置按钮
        ttk.Button(button_frame, text="重置", command=self.reset_water_level_discharge_input, style='TButton').pack(fill=tk.X, pady=5)
        
        # 导出按钮
        ttk.Button(parent, text="导出图表", command=self.export_water_level_discharge_plot, style='TButton').pack(fill=tk.X, pady=5)
    
    def init_results_tab(self):
        """初始化计算结果标签页"""
        # 创建主布局框架
        main_frame = ttk.Frame(self.tab4, padding="10")
        main_frame.pack(fill=tk.BOTH, expand=True)
        
        # 结果选择框架
        result_select_frame = ttk.Frame(main_frame)
        result_select_frame.pack(fill=tk.X, pady=5)
        
        ttk.Label(result_select_frame, text="选择结果类型：").pack(side=tk.LEFT, padx=5)
        self.result_type_var = tk.StringVar(value="design_flood")
        result_types = [
            ("设计洪水计算结果", "design_flood"),
            ("洪水位计算结果", "flood_level"),
            ("壅水分析计算结果", "backwater_analysis")
        ]
        for text, value in result_types:
            ttk.Radiobutton(result_select_frame, text=text, variable=self.result_type_var, value=value, command=self.update_results_display).pack(side=tk.LEFT, padx=10)
        
        # 导出按钮框架
        export_frame = ttk.Frame(result_select_frame)
        export_frame.pack(side=tk.RIGHT, padx=5)
        ttk.Button(export_frame, text="导出为Excel", command=self.export_results, style='TButton').pack(side=tk.LEFT, padx=5)
        ttk.Button(export_frame, text="导出为Word", command=self.export_results_as_word, style='TButton').pack(side=tk.LEFT, padx=5)
        
        # 结果表格框架
        result_table_frame = ttk.LabelFrame(main_frame, text="计算结果表格", padding="10")
        result_table_frame.pack(fill=tk.BOTH, expand=True, pady=5)
        
        # 创建结果表格
        self.create_results_table(result_table_frame)
        
        # 结果叙述框架
        result_narrative_frame = ttk.LabelFrame(main_frame, text="计算结果详细叙述", padding="10")
        result_narrative_frame.pack(fill=tk.BOTH, expand=True, pady=5)
        
        # 创建滚动文本框用于显示详细叙述
        narrative_scrollbar = ttk.Scrollbar(result_narrative_frame)
        self.results_narrative = tk.Text(result_narrative_frame, wrap=tk.WORD, yscrollcommand=narrative_scrollbar.set, font=('SimHei', 10))
        narrative_scrollbar.config(command=self.results_narrative.yview)
        
        # 布局文本框和滚动条
        self.results_narrative.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        narrative_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        
        # 初始显示提示信息
        self.results_narrative.insert(tk.END, "请选择结果类型查看详细计算结果叙述...")
    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    
    def init_compare_charts_tab(self):
        """初始化历史洪水对比标签页"""
        # 创建主布局框架
        main_frame = ttk.Frame(self.tab6, padding="10")
        main_frame.pack(fill=tk.BOTH, expand=True)
        
        # 使用Grid布局
        main_frame.columnconfigure(0, minsize=350, weight=0)
        main_frame.columnconfigure(1, weight=1)
        main_frame.rowconfigure(0, weight=1)
        
        # 左侧控制面板容器（带滚动条）
        control_container = ttk.Frame(main_frame)
        control_container.grid(row=0, column=0, sticky="nsew", padx=5, pady=5)
        
        # 创建Canvas和滚动条
        canvas = tk.Canvas(control_container, width=350, bg=self.style.configure('.')['background'])
        scrollbar = ttk.Scrollbar(control_container, orient="vertical", command=canvas.yview)
        scrollable_frame = ttk.Frame(canvas)
        
        # 配置Canvas
        scrollable_frame.bind(
            "<Configure>",
            lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
        )
        
        canvas.create_window((0, 0), window=scrollable_frame, anchor="nw", width=350)
        canvas.configure(yscrollcommand=scrollbar.set)
        
        # 布局Canvas和滚动条
        canvas.pack(side="left", fill="both", expand=True)
        scrollbar.pack(side="right", fill="y")
        
        # 左侧控制面板
        control_frame = ttk.LabelFrame(scrollable_frame, text="历史洪水对比", padding="10")
        control_frame.pack(fill=tk.BOTH, expand=True, pady=5)
        
        # 洪水历史对比参数
        ttk.Label(control_frame, text="洪水历史对比", font=('SimHei', 10, 'bold')).pack(anchor=tk.W, pady=(10, 5))
        
        ttk.Label(control_frame, text="历史洪水年份：").pack(anchor=tk.W, pady=(5, 2))
        self.history_years_var = tk.StringVar(value="2010 2015 2020")
        ttk.Entry(control_frame, textvariable=self.history_years_var, width=30).pack(fill=tk.X, pady=2)
        
        ttk.Label(control_frame, text="历史洪峰流量（m³/s，空格分隔）：").pack(anchor=tk.W, pady=5)
        self.history_q_var = tk.StringVar(value="150 180 200")
        ttk.Entry(control_frame, textvariable=self.history_q_var, width=30).pack(fill=tk.X, pady=2)
        
        ttk.Label(control_frame, text="历史洪水位（m，空格分隔）：").pack(anchor=tk.W, pady=5)
        self.history_z_var = tk.StringVar(value="1918.2 1918.5 1919.0")
        ttk.Entry(control_frame, textvariable=self.history_z_var, width=30).pack(fill=tk.X, pady=2)
        
        ttk.Label(control_frame, text="设计洪峰流量（m³/s）：").pack(anchor=tk.W, pady=5)
        self.design_q_var = tk.StringVar(value="220")
        ttk.Entry(control_frame, textvariable=self.design_q_var, width=30).pack(fill=tk.X, pady=2)
        
        ttk.Label(control_frame, text="设计洪水位（m）：").pack(anchor=tk.W, pady=5)
        self.design_z_var = tk.StringVar(value="1919.5")
        ttk.Entry(control_frame, textvariable=self.design_z_var, width=30).pack(fill=tk.X, pady=2)
        
        # 对比类型选择（默认历史洪水对比）
        ttk.Separator(control_frame, orient=tk.HORIZONTAL).pack(fill=tk.X, pady=15)
        
        ttk.Label(control_frame, text="对比类型", font=('SimHei', 10, 'bold')).pack(anchor=tk.W, pady=(10, 5))
        self.compare_type_var = tk.StringVar(value="history")
        
        type_frame = ttk.Frame(control_frame)
        type_frame.pack(fill=tk.X, pady=5)
        
        ttk.Radiobutton(type_frame, text="历史洪水对比", variable=self.compare_type_var, value="history").pack(anchor=tk.W, pady=2)
        
        # 按钮框架
        button_frame = ttk.Frame(control_frame)
        button_frame.pack(fill=tk.X, pady=15)
        
        # 绘制对比图表按钮
        ttk.Button(button_frame, text="绘制对比图表", command=self.plot_compare_charts, style='TButton').pack(fill=tk.X, pady=5)
        
        # 导出对比图表按钮
        ttk.Button(button_frame, text="导出对比图表", command=self.export_compare_charts, style='TButton').pack(fill=tk.X, pady=5)
        
        # 右侧绘图区域
        plot_frame = ttk.LabelFrame(main_frame, text="历史洪水对比", padding="10")
        plot_frame.grid(row=0, column=1, sticky="nsew", padx=5, pady=5)
        
        # 创建对比图表Figure
        self.compare_fig = Figure(figsize=(10, 7), dpi=100)
        self.compare_ax = self.compare_fig.add_subplot(111)
        
        # 设置图表背景和网格样式
        self.compare_fig.patch.set_facecolor('#f0f4f8')
        self.compare_ax.set_facecolor('#ffffff')
        self.compare_ax.grid(True, linestyle='--', alpha=0.7, color='#e2e8f0')
        
        # 创建Canvas
        self.compare_canvas = FigureCanvasTkAgg(self.compare_fig, master=plot_frame)
        self.compare_canvas.draw()
        self.compare_canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
        
        # 添加Matplotlib工具栏
        self.compare_toolbar = NavigationToolbar2Tk(self.compare_canvas, plot_frame)
        self.compare_toolbar.update()
        
        # 初始显示提示信息 - 使用更现代化的样式
        self.compare_ax.text(0.5, 0.5, "请在左侧输入参数并点击'绘制对比图表'按钮", 
                           ha='center', va='center', fontsize=14, 
                           color='#64748b', fontweight='bold', 
                           transform=self.compare_ax.transAxes)
        
        # 设置图表标题和标签的字体样式
        self.compare_ax.set_title('历史洪水对比', fontdict={'fontsize': 16, 'fontweight': 'bold', 'color': '#1e293b'})
        self.compare_ax.set_xlabel('年份', fontdict={'fontsize': 12, 'fontweight': 'bold', 'color': '#1e293b'})
        self.compare_ax.set_ylabel('流量/水位', fontdict={'fontsize': 12, 'fontweight': 'bold', 'color': '#1e293b'})
        
        # 优化坐标轴刻度样式
        self.compare_ax.tick_params(axis='both', which='major', labelsize=10, colors='#475569')
    
    def init_flood_risk_tab(self):
        """初始化洪水风险图标签页"""
        # 创建主布局框架
        main_frame = ttk.Frame(self.tab7, padding="10")
        main_frame.pack(fill=tk.BOTH, expand=True)
        
        # 使用Grid布局
        main_frame.columnconfigure(0, minsize=350, weight=0)
        main_frame.columnconfigure(1, weight=1)
        main_frame.rowconfigure(0, weight=1)
        
        # 左侧控制面板容器（带滚动条）
        control_container = ttk.Frame(main_frame)
        control_container.grid(row=0, column=0, sticky="nsew", padx=5, pady=5)
        
        # 创建Canvas和滚动条
        canvas = tk.Canvas(control_container, width=350, bg=self.style.configure('.')['background'])
        scrollbar = ttk.Scrollbar(control_container, orient="vertical", command=canvas.yview)
        scrollable_frame = ttk.Frame(canvas)
        
        # 配置Canvas
        scrollable_frame.bind(
            "<Configure>",
            lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
        )
        
        canvas.create_window((0, 0), window=scrollable_frame, anchor="nw", width=350)
        canvas.configure(yscrollcommand=scrollbar.set)
        
        # 布局Canvas和滚动条
        canvas.pack(side="left", fill="both", expand=True)
        scrollbar.pack(side="right", fill="y")
        
        # 左侧控制面板
        control_frame = ttk.LabelFrame(scrollable_frame, text="洪水风险计算与可视化", padding="10")
        control_frame.pack(fill=tk.BOTH, expand=True, pady=5)
        
        # 洪水风险计算参数
        ttk.Label(control_frame, text="洪水风险计算参数", font=('SimHei', 10, 'bold')).pack(anchor=tk.W, pady=(10, 5))
        
        # 重现期选择
        ttk.Label(control_frame, text="设计重现期（年，空格分隔）：").pack(anchor=tk.W, pady=(5, 2))
        self.risk_return_periods_var = tk.StringVar(value="2 5 10 20 50 100")
        ttk.Entry(control_frame, textvariable=self.risk_return_periods_var, width=30).pack(fill=tk.X, pady=2)
        
        # 人口密度
        ttk.Label(control_frame, text="人口密度（人/km²）：").pack(anchor=tk.W, pady=(10, 5))
        self.population_density_var = tk.StringVar(value="200")
        ttk.Entry(control_frame, textvariable=self.population_density_var, width=30).pack(fill=tk.X, pady=2)
        
        # 资产密度
        ttk.Label(control_frame, text="资产密度（万元/km²）：").pack(anchor=tk.W, pady=(10, 5))
        self.asset_density_var = tk.StringVar(value="5000")
        ttk.Entry(control_frame, textvariable=self.asset_density_var, width=30).pack(fill=tk.X, pady=2)
        
        # 洪水风险图类型选择
        ttk.Separator(control_frame, orient=tk.HORIZONTAL).pack(fill=tk.X, pady=15)
        
        ttk.Label(control_frame, text="风险图类型", font=('SimHei', 10, 'bold')).pack(anchor=tk.W, pady=(10, 5))
        self.risk_map_type_var = tk.StringVar(value="risk_level")
        
        type_frame = ttk.Frame(control_frame)
        type_frame.pack(fill=tk.X, pady=5)
        
        ttk.Radiobutton(type_frame, text="风险等级分布图", variable=self.risk_map_type_var, value="risk_level").pack(anchor=tk.W, pady=2)
        ttk.Radiobutton(type_frame, text="风险与水深关系图", variable=self.risk_map_type_var, value="risk_vs_depth").pack(anchor=tk.W, pady=2)
        ttk.Radiobutton(type_frame, text="多重现期对比图", variable=self.risk_map_type_var, value="multi_return_period").pack(anchor=tk.W, pady=2)
        ttk.Radiobutton(type_frame, text="风险指数分布图", variable=self.risk_map_type_var, value="risk_index").pack(anchor=tk.W, pady=2)
        
        # 按钮框架
        button_frame = ttk.Frame(control_frame)
        button_frame.pack(fill=tk.X, pady=15)
        
        # 计算洪水风险按钮
        ttk.Button(button_frame, text="计算洪水风险", command=self.calculate_flood_risk, style='TButton').pack(fill=tk.X, pady=5)
        
        # 绘制风险图按钮
        ttk.Button(button_frame, text="绘制风险图", command=self.plot_flood_risk_map, style='TButton').pack(fill=tk.X, pady=5)
        
        # 导出风险图按钮
        ttk.Button(button_frame, text="导出风险图", command=self.export_flood_risk_map, style='TButton').pack(fill=tk.X, pady=5)
        
        # 右侧绘图区域
        self.risk_plot_frame = ttk.LabelFrame(main_frame, text="洪水风险图", padding="10")
        self.risk_plot_frame.grid(row=0, column=1, sticky="nsew", padx=5, pady=5)
        
        # 为绘图区域添加垂直滚动条
        plot_canvas = tk.Canvas(self.risk_plot_frame)
        plot_scrollbar = ttk.Scrollbar(self.risk_plot_frame, orient="vertical", command=plot_canvas.yview)
        self.risk_plot_scrollable_frame = ttk.Frame(plot_canvas)
        
        # 配置Canvas
        self.risk_plot_scrollable_frame.bind(
            "<Configure>",
            lambda e: plot_canvas.configure(scrollregion=plot_canvas.bbox("all"))
        )
        
        plot_canvas.create_window((0, 0), window=self.risk_plot_scrollable_frame, anchor="nw")
        plot_canvas.configure(yscrollcommand=plot_scrollbar.set)
        
        # 布局Canvas和滚动条
        plot_canvas.pack(side="left", fill="both", expand=True)
        plot_scrollbar.pack(side="right", fill="y")
        
        # 初始显示提示信息
        self.risk_plot_label = ttk.Label(self.risk_plot_scrollable_frame, text="请计算洪水风险并绘制风险图", font=('SimHei', 12))
        self.risk_plot_label.pack(pady=50)
    
    def calculate_flood_risk(self):
        """计算洪水风险"""
        try:
            # 获取设计洪水计算结果
            if not self.design_flood_data['design_results']:
                messagebox.showwarning("警告", "请先完成设计洪水计算")
                return
            
            # 获取洪水位计算结果
            if not self.flood_level_data['results']:
                messagebox.showwarning("警告", "请先完成洪水位计算")
                return
            
            # 获取用户输入参数
            return_periods = list(map(float, self.risk_return_periods_var.get().split()))
            population_density = float(self.population_density_var.get())
            asset_density = float(self.asset_density_var.get())
            
            # 从设计洪水结果中提取对应重现期的洪峰流量
            design_results = self.design_flood_data['design_results']
            flood_level_results = self.flood_level_data['results']
            
            # 准备计算参数
            flood_data = []
            for i, period in enumerate(return_periods):
                # 查找对应重现期的洪峰流量
                q = None
                for result in design_results:
                    if abs(result['return_period'] - period) < 0.1:
                        q = result['qp']
                        break
                
                # 查找对应流量的水位
                z = None
                if q is not None:
                    for result in flood_level_results:
                        if abs(result['q'] - q) < 0.1:
                            z = result['flood_elevation']
                            break
                
                if q is not None and z is not None:
                    flood_data.append({
                        'return_period': period,
                        'discharge': q,
                        'water_level': z
                    })
            
            if not flood_data:
                messagebox.showwarning("警告", "未找到对应重现期的设计洪水结果")
                return
            
            # 使用业务逻辑层计算洪水风险
            self.flood_service.calculate_flood_risk(flood_data, population_density, asset_density)
            
            messagebox.showinfo("成功", "洪水风险计算完成")
            
        except Exception as e:
            messagebox.showerror("错误", f"洪水风险计算失败: {str(e)}")
    
    def plot_flood_risk_map(self):
        """绘制洪水风险图"""
        try:
            # 检查是否已计算洪水风险
            if not hasattr(self.flood_service, 'flood_risk_data') or not self.flood_service.flood_risk_data:
                messagebox.showwarning("警告", "请先计算洪水风险")
                return
            
            # 清除之前的绘图
            for widget in self.risk_plot_scrollable_frame.winfo_children():
                widget.destroy()
            
            # 获取用户选择的风险图类型
            map_type = self.risk_map_type_var.get()
            
            # 准备数据
            flood_risk_data = self.flood_service.flood_risk_data
            risk_results = flood_risk_data.get('results', [])
            
            # 创建Matplotlib图形
            fig = plt.Figure(figsize=(10, 6), dpi=100)
            ax = fig.add_subplot(111)
            
            # 根据不同的风险图类型绘制图形
            if map_type == 'risk_level':
                # 风险等级分布图
                return_periods = [data['return_period'] for data in risk_results]
                # 使用flood_risk_level字段，而不是risk_level
                risk_levels = [data['flood_risk_level'] for data in risk_results]
                
                # 将风险等级转换为数值，便于绘图
                risk_level_to_num = {
                    "低风险": 1,
                    "中风险": 2,
                    "高风险": 3,
                    "极高风险": 4
                }
                risk_level_nums = [risk_level_to_num[level] for level in risk_levels]
                
                ax.bar(return_periods, risk_level_nums, color='skyblue', edgecolor='black')
                ax.set_xlabel('重现期（年）')
                ax.set_ylabel('风险等级')
                ax.set_title('洪水风险等级分布')
                ax.grid(True, alpha=0.3)
                # 设置y轴刻度和标签
                ax.set_yticks([1, 2, 3, 4])
                ax.set_yticklabels(['低风险', '中风险', '高风险', '极高风险'])
                
            elif map_type == 'risk_vs_depth':
                # 风险与水深关系图
                water_depths = [data['water_depth'] for data in risk_results]
                # 使用flood_risk_level字段，而不是risk_level
                risk_levels = [data['flood_risk_level'] for data in risk_results]
                
                # 将风险等级转换为数值，便于绘图
                risk_level_to_num = {
                    "低风险": 1,
                    "中风险": 2,
                    "高风险": 3,
                    "极高风险": 4
                }
                risk_level_nums = [risk_level_to_num[level] for level in risk_levels]
                
                ax.scatter(water_depths, risk_level_nums, color='red', s=100, alpha=0.7)
                ax.set_xlabel('水深（m）')
                ax.set_ylabel('风险等级')
                ax.set_title('洪水风险与水深关系')
                ax.grid(True, alpha=0.3)
                # 设置y轴刻度和标签
                ax.set_yticks([1, 2, 3, 4])
                ax.set_yticklabels(['低风险', '中风险', '高风险', '极高风险'])
                
                # 添加趋势线
                z = np.polyfit(water_depths, risk_level_nums, 1)
                p = np.poly1d(z)
                ax.plot(water_depths, p(water_depths), "r--", alpha=0.8)
                
            elif map_type == 'multi_return_period':
                # 多重现期对比图
                return_periods = [data['return_period'] for data in risk_results]
                # 使用flood_risk_level字段，而不是risk_level
                risk_levels = [data['flood_risk_level'] for data in risk_results]
                # 检查是否有inundation_area字段，否则使用估算值
                inundation_areas = [data.get('inundation_area', data['water_depth'] * 10) for data in risk_results]
                
                # 将风险等级转换为数值，便于绘图
                risk_level_to_num = {
                    "低风险": 1,
                    "中风险": 2,
                    "高风险": 3,
                    "极高风险": 4
                }
                risk_level_nums = [risk_level_to_num[level] for level in risk_levels]
                
                ax2 = ax.twinx()
                ax.bar(return_periods, risk_level_nums, color='skyblue', edgecolor='black', alpha=0.6, label='风险等级')
                ax2.plot(return_periods, inundation_areas, color='red', marker='o', linewidth=2, label='淹没面积')
                
                ax.set_xlabel('重现期（年）')
                ax.set_ylabel('风险等级')
                ax2.set_ylabel('淹没面积（km²）')
                ax.set_title('多重现期洪水风险对比')
                ax.grid(True, alpha=0.3)
                # 设置y轴刻度和标签
                ax.set_yticks([1, 2, 3, 4])
                ax.set_yticklabels(['低风险', '中风险', '高风险', '极高风险'])
                ax.legend(loc='upper left')
                ax2.legend(loc='upper right')
                
            elif map_type == 'risk_index':
                # 风险指数分布图
                return_periods = [data['return_period'] for data in risk_results]
                # 使用flood_risk_value字段，转换为0-100范围的风险指数
                risk_indices = [data['flood_risk_value'] * 100 for data in risk_results]
                
                ax.plot(return_periods, risk_indices, color='green', marker='s', linewidth=2, markersize=8)
                ax.fill_between(return_periods, risk_indices, alpha=0.3, color='green')
                ax.set_xlabel('重现期（年）')
                ax.set_ylabel('风险指数')
                ax.set_title('洪水风险指数分布')
                ax.grid(True, alpha=0.3)
            
            # 创建Canvas并显示图形
            canvas = FigureCanvasTkAgg(fig, master=self.risk_plot_scrollable_frame)
            canvas.draw()
            
            # 添加工具栏
            toolbar = NavigationToolbar2Tk(canvas, self.risk_plot_scrollable_frame)
            toolbar.update()
            
            # 布局图形
            canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
            
        except Exception as e:
            messagebox.showerror("错误", f"绘制洪水风险图失败: {str(e)}")
    
    def export_flood_risk_map(self):
        """导出洪水风险图"""
        try:
            # 检查是否已绘制风险图
            if len(self.risk_plot_scrollable_frame.winfo_children()) <= 1:  # 只包含标签
                messagebox.showwarning("警告", "请先绘制洪水风险图")
                return
            
            # 选择保存文件路径
            file_path = filedialog.asksaveasfilename(
                defaultextension=".png",
                filetypes=[("PNG文件", "*.png"), ("PDF文件", "*.pdf"), ("SVG文件", "*.svg")],
                title="保存洪水风险图"
            )
            
            if not file_path:
                return  # 用户取消保存
            
            # 获取Canvas并保存图形
            canvas = None
            for widget in self.risk_plot_scrollable_frame.winfo_children():
                if isinstance(widget, tk.Canvas):
                    # 查找FigureCanvasTkAgg实例
                    parent = widget.master
                    if hasattr(parent, 'figure'):
                        canvas = parent
                        break
            
            if canvas:
                canvas.figure.savefig(file_path, dpi=300, bbox_inches='tight')
                messagebox.showinfo("成功", f"洪水风险图已保存到: {file_path}")
            else:
                messagebox.showerror("错误", "未找到图形对象")
                
        except Exception as e:
            messagebox.showerror("错误", f"导出洪水风险图失败: {str(e)}")
    
    def init_realtime_warning_tab(self):
        """初始化实时洪水预警标签页"""
        # 创建主布局框架
        main_frame = ttk.Frame(self.extended_tab10, padding="10")
        main_frame.pack(fill=tk.BOTH, expand=True)
        
        # 使用Grid布局
        main_frame.columnconfigure(0, minsize=350, weight=0)
        main_frame.columnconfigure(1, weight=1)
        main_frame.rowconfigure(0, weight=1)
        
        # 左侧输入面板容器（带滚动条）
        input_container = ttk.Frame(main_frame)
        input_container.grid(row=0, column=0, sticky="nsew", padx=5, pady=5)
        
        # 创建Canvas和滚动条
        canvas = tk.Canvas(input_container, width=350, bg=self.style.configure('.')['background'])
        scrollbar = ttk.Scrollbar(input_container, orient="vertical", command=canvas.yview)
        scrollable_frame = ttk.Frame(canvas)
        
        # 配置Canvas
        scrollable_frame.bind(
            "<Configure>",
            lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
        )
        
        canvas.create_window((0, 0), window=scrollable_frame, anchor="nw", width=350)
        canvas.configure(yscrollcommand=scrollbar.set)
        
        # 布局Canvas和滚动条
        canvas.pack(side="left", fill="both", expand=True)
        scrollbar.pack(side="right", fill="y")
        
        # 左侧输入面板
        input_frame = ttk.LabelFrame(scrollable_frame, text="输入参数", padding="10")
        input_frame.pack(fill=tk.BOTH, expand=True, pady=5)
        
        # 水位监测参数
        ttk.Label(input_frame, text="水位监测", font=('SimHei', 10, 'bold')).grid(row=0, column=0, columnspan=2, sticky=tk.W, pady=(10, 5))
        
        ttk.Label(input_frame, text="当前水位（m）：").grid(row=1, column=0, sticky=tk.W, pady=(5, 2))
        self.warning_current_level_var = tk.StringVar(value="1917.5")
        ttk.Entry(input_frame, textvariable=self.warning_current_level_var, width=20).grid(row=1, column=1, pady=2)
        
        ttk.Label(input_frame, text="警戒水位（m）：").grid(row=2, column=0, sticky=tk.W, pady=5)
        self.warning_level_var = tk.StringVar(value="1918.0")
        ttk.Entry(input_frame, textvariable=self.warning_level_var, width=20).grid(row=2, column=1, pady=2)
        
        ttk.Label(input_frame, text="保证水位（m）：").grid(row=3, column=0, sticky=tk.W, pady=5)
        self.warning_guarantee_level_var = tk.StringVar(value="1919.0")
        ttk.Entry(input_frame, textvariable=self.warning_guarantee_level_var, width=20).grid(row=3, column=1, pady=2)
        
        # 流量监测参数
        ttk.Separator(input_frame, orient=tk.HORIZONTAL).grid(row=4, column=0, columnspan=2, sticky="ew", pady=15)
        
        ttk.Label(input_frame, text="流量监测", font=('SimHei', 10, 'bold')).grid(row=5, column=0, columnspan=2, sticky=tk.W, pady=(10, 5))
        
        ttk.Label(input_frame, text="当前流量（m³/s）：").grid(row=6, column=0, sticky=tk.W, pady=(5, 2))
        self.warning_current_flow_var = tk.StringVar(value="150")
        ttk.Entry(input_frame, textvariable=self.warning_current_flow_var, width=20).grid(row=6, column=1, pady=2)
        
        ttk.Label(input_frame, text="警戒流量（m³/s）：").grid(row=7, column=0, sticky=tk.W, pady=5)
        self.warning_flow_var = tk.StringVar(value="200")
        ttk.Entry(input_frame, textvariable=self.warning_flow_var, width=20).grid(row=7, column=1, pady=2)
        
        # 预报参数
        ttk.Separator(input_frame, orient=tk.HORIZONTAL).grid(row=8, column=0, columnspan=2, sticky="ew", pady=15)
        
        ttk.Label(input_frame, text="洪水预报", font=('SimHei', 10, 'bold')).grid(row=9, column=0, columnspan=2, sticky=tk.W, pady=(10, 5))
        
        ttk.Label(input_frame, text="预报洪峰流量（m³/s）：").grid(row=10, column=0, sticky=tk.W, pady=(5, 2))
        self.warning_peak_flow_var = tk.StringVar(value="220")
        ttk.Entry(input_frame, textvariable=self.warning_peak_flow_var, width=20).grid(row=10, column=1, pady=2)
        
        ttk.Label(input_frame, text="预报洪峰水位（m）：").grid(row=11, column=0, sticky=tk.W, pady=5)
        self.warning_peak_level_var = tk.StringVar(value="1919.5")
        ttk.Entry(input_frame, textvariable=self.warning_peak_level_var, width=20).grid(row=11, column=1, pady=2)
        
        ttk.Label(input_frame, text="预报洪峰时间（h）：").grid(row=12, column=0, sticky=tk.W, pady=5)
        self.warning_peak_time_var = tk.StringVar(value="6")
        ttk.Entry(input_frame, textvariable=self.warning_peak_time_var, width=20).grid(row=12, column=1, pady=2)
        
        # 按钮框架
        button_frame = ttk.Frame(input_frame)
        button_frame.grid(row=13, column=0, columnspan=2, pady=15)
        
        # 计算预警等级按钮
        calculate_btn = ttk.Button(button_frame, text="计算预警等级", command=self.calculate_warning_level)
        calculate_btn.pack(fill=tk.X, pady=5)
        
        # 生成预警图表按钮
        plot_btn = ttk.Button(button_frame, text="生成预警图表", command=self.plot_warning_chart)
        plot_btn.pack(fill=tk.X, pady=5)
        
        # 导出预警数据按钮
        export_btn = ttk.Button(button_frame, text="导出预警数据", command=self.export_warning_data)
        export_btn.pack(fill=tk.X, pady=5)
        
        # 右侧结果面板
        result_frame = ttk.LabelFrame(main_frame, text="预警结果", padding="10")
        result_frame.grid(row=0, column=1, sticky="nsew", padx=5, pady=5)
        
        # 预警等级显示
        self.warning_level_display_var = tk.StringVar()
        ttk.Label(result_frame, text="当前预警等级：").pack(anchor=tk.W, pady=(10, 5))
        warning_label = ttk.Label(result_frame, textvariable=self.warning_level_display_var, font=('SimHei', 16, 'bold'))
        warning_label.pack(anchor=tk.W, pady=5)
        
        # 预警信息显示
        self.warning_info_var = tk.StringVar()
        ttk.Label(result_frame, text="预警信息：").pack(anchor=tk.W, pady=(10, 5))
        info_label = ttk.Label(result_frame, textvariable=self.warning_info_var, font=('SimHei', 10), wraplength=500)
        info_label.pack(anchor=tk.W, pady=5)
        
        # 创建图表区域
        self.create_warning_plot(result_frame)
    
    def create_warning_plot(self, parent):
        """创建实时洪水预警图表绘制区域"""
        # 创建Figure对象
        self.warning_fig = Figure(figsize=(10, 8), dpi=100)
        self.warning_ax1 = self.warning_fig.add_subplot(211)
        self.warning_ax2 = self.warning_fig.add_subplot(212)
        
        # 创建Canvas对象
        self.warning_canvas = FigureCanvasTkAgg(self.warning_fig, master=parent)
        self.warning_canvas.draw()
        self.warning_canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
        
        # 添加Matplotlib工具栏
        self.warning_toolbar = NavigationToolbar2Tk(self.warning_canvas, parent)
        self.warning_toolbar.update()
        
        # 初始显示提示信息
        self.warning_ax1.text(0.5, 0.5, "请在左侧输入参数并点击'计算预警等级'按钮", ha='center', va='center', fontsize=12)
        self.warning_ax2.text(0.5, 0.5, "请在左侧输入参数并点击'计算预警等级'按钮", ha='center', va='center', fontsize=12)
        self.warning_canvas.draw()
    
    def calculate_warning_level(self):
        """计算洪水预警等级"""
        try:
            # 获取输入参数
            current_level = float(self.warning_current_level_var.get())
            warning_level = float(self.warning_level_var.get())
            guarantee_level = float(self.warning_guarantee_level_var.get())
            current_flow = float(self.warning_current_flow_var.get())
            warning_flow = float(self.warning_flow_var.get())
            peak_flow = float(self.warning_peak_flow_var.get())
            peak_level = float(self.warning_peak_level_var.get())
            peak_time = float(self.warning_peak_time_var.get())
            
            # 计算预警等级
            warning_data = self._calculate_warning_model(
                current_level, warning_level, guarantee_level,
                current_flow, warning_flow, peak_flow, peak_level, peak_time
            )
            
            # 存储计算结果
            self.warning_data = warning_data
            
            # 更新预警等级显示
            self.warning_level_display_var.set(warning_data['warning_level'])
            
            # 根据预警等级设置颜色
            if warning_data['warning_level'] == "蓝色预警":
                warning_label_color = "#3498db"
            elif warning_data['warning_level'] == "黄色预警":
                warning_label_color = "#f1c40f"
            elif warning_data['warning_level'] == "橙色预警":
                warning_label_color = "#e67e22"
            elif warning_data['warning_level'] == "红色预警":
                warning_label_color = "#e74c3c"
            else:
                warning_label_color = "#2ecc71"
            
            # 更新预警信息显示
            self.warning_info_var.set(
                f"当前水位：{current_level:.2f} m | 当前流量：{current_flow:.2f} m³/s\n"
                f"预报洪峰流量：{peak_flow:.2f} m³/s | 预报洪峰水位：{peak_level:.2f} m\n"
                f"洪峰到达时间：{peak_time:.1f} 小时后\n"
                f"水位距警戒：{warning_data['distance_to_warning']:.2f} m\n"
                f"水位距保证：{warning_data['distance_to_guarantee']:.2f} m"
            )
            
            # 绘制预警图表
            self.plot_warning_chart()
            
        except ValueError as e:
            messagebox.showerror("计算错误", f"输入参数错误：{e}")
        except Exception as e:
            messagebox.showerror("计算错误", f"计算过程中发生错误：{e}")
    
    def _calculate_warning_model(self, current_level, warning_level, guarantee_level, 
                                current_flow, warning_flow, peak_flow, peak_level, peak_time):
        """计算预警等级模型"""
        # 计算水位距离
        distance_to_warning = current_level - warning_level
        distance_to_guarantee = current_level - guarantee_level
        
        # 计算流量距离
        distance_to_warning_flow = current_flow - warning_flow
        
        # 计算预报洪峰距离
        peak_distance_to_warning = peak_level - warning_level
        peak_distance_to_guarantee = peak_level - guarantee_level
        
        # 确定预警等级
        if current_level >= guarantee_level or peak_level >= guarantee_level:
            warning_level_str = "红色预警"
            warning_description = "洪水已达到保证水位，启动一级应急响应"
        elif current_level >= warning_level or peak_level >= warning_level:
            warning_level_str = "橙色预警"
            warning_description = "洪水已达到警戒水位，启动二级应急响应"
        elif distance_to_warning >= -0.5 or peak_distance_to_warning >= -0.5:
            warning_level_str = "黄色预警"
            warning_description = "洪水接近警戒水位，启动三级应急响应"
        elif distance_to_warning >= -1.0 or peak_distance_to_warning >= -1.0:
            warning_level_str = "蓝色预警"
            warning_description = "洪水水位上涨，加强监测"
        else:
            warning_level_str = "正常"
            warning_description = "当前水位正常"
        
        return {
            'warning_level': warning_level_str,
            'warning_description': warning_description,
            'distance_to_warning': distance_to_warning,
            'distance_to_guarantee': distance_to_guarantee,
            'current_level': current_level,
            'warning_level_value': warning_level,
            'guarantee_level': guarantee_level,
            'current_flow': current_flow,
            'warning_flow': warning_flow,
            'peak_flow': peak_flow,
            'peak_level': peak_level,
            'peak_time': peak_time
        }
    
    def plot_warning_chart(self):
        """绘制实时洪水预警图表"""
        try:
            if not hasattr(self, 'warning_data') or not self.warning_data:
                messagebox.showwarning("警告", "请先计算预警等级！")
                return
            
            data = self.warning_data
            
            # 清除现有图表
            self.warning_ax1.clear()
            self.warning_ax2.clear()
            
            # 绘制水位预警图
            levels = ['当前水位', '警戒水位', '保证水位', '预报洪峰']
            level_values = [data['current_level'], data['warning_level_value'], 
                           data['guarantee_level'], data['peak_level']]
            level_colors = ['#3498db', '#f1c40f', '#e74c3c', '#9b59b6']
            
            bars = self.warning_ax1.bar(levels, level_values, color=level_colors, alpha=0.7, edgecolor='black', linewidth=1.5)
            
            # 添加数值标签
            for bar, value in zip(bars, level_values):
                height = bar.get_height()
                self.warning_ax1.text(bar.get_x() + bar.get_width()/2., height,
                                     f'{value:.2f}', ha='center', va='bottom', fontsize=10, fontweight='bold')
            
            # 绘制警戒水位线
            self.warning_ax1.axhline(y=data['warning_level_value'], color='#f1c40f', linestyle='--', linewidth=2, label='警戒水位')
            self.warning_ax1.axhline(y=data['guarantee_level'], color='#e74c3c', linestyle='--', linewidth=2, label='保证水位')
            
            # 设置标题和标签
            self.warning_ax1.set_title('水位预警图', fontdict={'fontsize': 14, 'fontweight': 'bold'}, pad=15)
            self.warning_ax1.set_ylabel('水位 (m)', fontsize=12)
            self.warning_ax1.legend(fontsize=10, loc='upper left')
            self.warning_ax1.grid(True, alpha=0.3, linestyle='--')
            
            # 绘制流量预警图
            flow_labels = ['当前流量', '警戒流量', '预报洪峰流量']
            flow_values = [data['current_flow'], data['warning_flow'], data['peak_flow']]
            flow_colors = ['#3498db', '#f1c40f', '#9b59b6']
            
            bars2 = self.warning_ax2.bar(flow_labels, flow_values, color=flow_colors, alpha=0.7, edgecolor='black', linewidth=1.5)
            
            # 添加数值标签
            for bar, value in zip(bars2, flow_values):
                height = bar.get_height()
                self.warning_ax2.text(bar.get_x() + bar.get_width()/2., height,
                                     f'{value:.2f}', ha='center', va='bottom', fontsize=10, fontweight='bold')
            
            # 绘制警戒流量线
            self.warning_ax2.axhline(y=data['warning_flow'], color='#f1c40f', linestyle='--', linewidth=2, label='警戒流量')
            
            # 设置标题和标签
            self.warning_ax2.set_title('流量预警图', fontdict={'fontsize': 14, 'fontweight': 'bold'}, pad=15)
            self.warning_ax2.set_ylabel('流量 (m³/s)', fontsize=12)
            self.warning_ax2.legend(fontsize=10, loc='upper left')
            self.warning_ax2.grid(True, alpha=0.3, linestyle='--')
            
            # 紧凑布局
            self.warning_fig.tight_layout()
            
            # 更新Canvas
            self.warning_canvas.draw()
            
        except Exception as e:
            messagebox.showerror("绘图错误", f"绘制预警图表失败：{e}")
    
    def export_warning_data(self):
        """导出实时洪水预警数据"""
        try:
            if not hasattr(self, 'warning_data') or not self.warning_data:
                messagebox.showwarning("警告", "请先计算预警等级！")
                return
            
            # 选择保存文件路径
            file_path = filedialog.asksaveasfilename(
                defaultextension=".xlsx",
                filetypes=[("Excel文件", "*.xlsx"), ("CSV文件", "*.csv"), ("所有文件", "*.*")],
                title="导出实时洪水预警数据"
            )
            
            if not file_path:
                return
            
            # 准备数据
            data = self.warning_data
            export_data = {
                '预警等级': [data['warning_level']],
                '预警描述': [data['warning_description']],
                '当前水位(m)': [data['current_level']],
                '警戒水位(m)': [data['warning_level_value']],
                '保证水位(m)': [data['guarantee_level']],
                '水位距警戒(m)': [data['distance_to_warning']],
                '水位距保证(m)': [data['distance_to_guarantee']],
                '当前流量(m³/s)': [data['current_flow']],
                '警戒流量(m³/s)': [data['warning_flow']],
                '预报洪峰流量(m³/s)': [data['peak_flow']],
                '预报洪峰水位(m)': [data['peak_level']],
                '洪峰到达时间(h)': [data['peak_time']]
            }
            
            # 导出数据
            df = pd.DataFrame(export_data)
            if file_path.endswith('.xlsx'):
                df.to_excel(file_path, index=False)
            elif file_path.endswith('.csv'):
                df.to_csv(file_path, index=False, encoding='utf-8-sig')
            else:
                df.to_excel(file_path, index=False)
            
            messagebox.showinfo("成功", f"实时洪水预警数据已导出到：{file_path}")
            
        except Exception as e:
            messagebox.showerror("错误", f"导出数据失败：{e}")
    
    def init_backwater_analysis_tab(self):
        """初始化壅水分析计算标签页"""
        # 创建主布局框架
        main_frame = ttk.Frame(self.tab5, padding="10")
        main_frame.pack(fill=tk.BOTH, expand=True)
        
        # 使用Grid布局替代Pack布局，提高响应式能力
        main_frame.columnconfigure(0, minsize=300, weight=0)  # 输入面板固定宽度
        main_frame.columnconfigure(1, weight=1)  # 结果面板自适应扩展
        main_frame.rowconfigure(0, weight=1)
        
        # 左侧输入面板容器（带滚动条）
        input_container = ttk.Frame(main_frame)
        input_container.grid(row=0, column=0, sticky="nsew", padx=5, pady=5)
        
        # 创建Canvas和滚动条
        canvas = tk.Canvas(input_container, width=300)
        scrollbar = ttk.Scrollbar(input_container, orient="vertical", command=canvas.yview)
        scrollable_frame = ttk.Frame(canvas)
        
        # 配置Canvas
        scrollable_frame.bind(
            "<Configure>",
            lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
        )
        
        canvas.create_window((0, 0), window=scrollable_frame, anchor="nw", width=300)
        canvas.configure(yscrollcommand=scrollbar.set)
        
        # 布局Canvas和滚动条
        canvas.pack(side="left", fill="both", expand=True)
        scrollbar.pack(side="right", fill="y")
        
        # 左侧输入面板
        input_frame = ttk.LabelFrame(scrollable_frame, text="输入参数", padding="10")
        input_frame.pack(fill=tk.BOTH, expand=True)
        
        # 右侧结果面板容器
        result_container = ttk.Frame(main_frame)
        result_container.grid(row=0, column=1, sticky="nsew", padx=5, pady=5)
        
        # 创建Canvas和滚动条
        result_canvas = tk.Canvas(result_container)
        result_scrollbar = ttk.Scrollbar(result_container, orient="vertical", command=result_canvas.yview)
        result_scrollable_frame = ttk.Frame(result_canvas)
        
        # 配置Canvas
        result_scrollable_frame.bind(
            "<Configure>",
            lambda e: result_canvas.configure(scrollregion=result_canvas.bbox("all"))
        )
        
        result_canvas.create_window((0, 0), window=result_scrollable_frame, anchor="nw")
        result_canvas.configure(yscrollcommand=result_scrollbar.set)
        
        # 布局Canvas和滚动条
        result_canvas.pack(side="left", fill="both", expand=True)
        result_scrollbar.pack(side="right", fill="y")
        
        # 右侧结果面板
        result_frame = ttk.LabelFrame(result_scrollable_frame, text="计算结果", padding="10")
        result_frame.pack(fill=tk.BOTH, expand=True)
        
        # 输入面板内容
        self.create_backwater_analysis_input(input_frame)
        
        # 结果面板内容
        self.create_backwater_analysis_result(result_frame)
    
    def create_backwater_analysis_input(self, parent):
        """创建壅水分析计算输入表单"""
        # 创建验证变量和函数
        vcmd_float = (self.root.register(self.validate_float), '%P', '%W')
        vcmd_float_positive = (self.root.register(self.validate_float_positive), '%P', '%W')
        vcmd_float_non_negative = (self.root.register(self.validate_float_non_negative), '%P', '%W')
        invcmd = (self.root.register(self.invalid_input), '%W')
        
        # -------------------------- 第一部分：基础参数 --------------------------
        basic_frame = ttk.LabelFrame(parent, text="1. 基础参数（计算η系数和ω）", padding="10")
        basic_frame.pack(fill=tk.X, pady=10)
        
        # 河流类型选择
        ttk.Label(basic_frame, text="河流类型：").pack(anchor=tk.W, pady=(10, 5))
        self.river_type_var = tk.StringVar(value="山区河流")
        river_types = ["山区河流", "半山区河流", "平原河流", "低洼区河流"]
        river_type_combobox = ttk.Combobox(basic_frame, textvariable=self.river_type_var, values=river_types, width=30)
        river_type_combobox.pack(fill=tk.X, pady=2)
        
        # 河滩路堤阻挡流量比例
        ttk.Label(basic_frame, text="河滩路堤阻挡流量比例（%）：").pack(anchor=tk.W, pady=(15, 5))
        self.flow_ratio_entry = ttk.Entry(basic_frame, width=30, validate="key", validatecommand=vcmd_float_non_negative, invalidcommand=invcmd)
        self.flow_ratio_entry.pack(fill=tk.X, pady=2)
        self.flow_ratio_entry.insert(0, "10")
        
        # 设计流量Qp
        ttk.Label(basic_frame, text="设计流量Qp（m³/s）：").pack(anchor=tk.W, pady=(15, 5))
        self.qp_entry = ttk.Entry(basic_frame, width=30, validate="key", validatecommand=vcmd_float_positive, invalidcommand=invcmd)
        self.qp_entry.pack(fill=tk.X, pady=2)
        self.qp_entry.insert(0, "100")
        
        # 设计流速Vp
        ttk.Label(basic_frame, text="设计流速Vp（m/s）：").pack(anchor=tk.W, pady=(15, 5))
        self.vp_entry = ttk.Entry(basic_frame, width=30, validate="key", validatecommand=vcmd_float_positive, invalidcommand=invcmd)
        self.vp_entry.pack(fill=tk.X, pady=2)
        self.vp_entry.insert(0, "2.0")
        
        # 水流方向与桥梁轴线之法线间的交角α
        ttk.Label(basic_frame, text="水流方向与桥梁轴线之法线间的交角α（°）：").pack(anchor=tk.W, pady=(15, 5))
        self.alpha_entry = ttk.Entry(basic_frame, width=30, validate="key", validatecommand=vcmd_float_non_negative, invalidcommand=invcmd)
        self.alpha_entry.pack(fill=tk.X, pady=2)
        self.alpha_entry.insert(0, "0")
        
        # -------------------------- 第二部分：过水断面参数 --------------------------
        section_frame = ttk.LabelFrame(parent, text="2. 过水断面参数（计算冲刷系数P）", padding="10")
        section_frame.pack(fill=tk.X, pady=10)
        
        # 桥下实际过水断面面积
        ttk.Label(section_frame, text="桥下实际过水断面面积（m²）：").pack(anchor=tk.W, pady=(10, 5))
        self.omega_actual_entry = ttk.Entry(section_frame, width=30, validate="key", validatecommand=vcmd_float_positive, invalidcommand=invcmd)
        self.omega_actual_entry.pack(fill=tk.X, pady=2)
        self.omega_actual_entry.insert(0, "50")
        
        # -------------------------- 第三部分：流速参数 --------------------------
        velocity_frame = ttk.LabelFrame(parent, text="3. 流速参数（计算VM和壅水高度）", padding="10")
        velocity_frame.pack(fill=tk.X, pady=10)
        
        # 土质类型
        ttk.Label(velocity_frame, text="土质类型：").pack(anchor=tk.W, pady=(10, 5))
        self.soil_type_var = tk.StringVar(value="中等土")
        soil_types = ["松软土", "中等土", "密实土"]
        soil_type_combobox = ttk.Combobox(velocity_frame, textvariable=self.soil_type_var, values=soil_types, width=30)
        soil_type_combobox.pack(fill=tk.X, pady=2)
        
        # 断面平均流速V
        ttk.Label(velocity_frame, text="断面平均流速V（m/s）：").pack(anchor=tk.W, pady=(15, 5))
        self.v_entry = ttk.Entry(velocity_frame, width=30, validate="key", validatecommand=vcmd_float_positive, invalidcommand=invcmd)
        self.v_entry.pack(fill=tk.X, pady=2)
        self.v_entry.insert(0, "1.2")
        
        # -------------------------- 第四部分：河道参数 --------------------------
        river_frame = ttk.LabelFrame(parent, text="4. 河道参数（计算壅水曲线长度）", padding="10")
        river_frame.pack(fill=tk.X, pady=10)
        
        # 河段天然水面坡度I0
        ttk.Label(river_frame, text="河段天然水面坡度I0：").pack(anchor=tk.W, pady=(10, 5))
        self.i0_entry = ttk.Entry(river_frame, width=30, validate="key", validatecommand=vcmd_float_positive, invalidcommand=invcmd)
        self.i0_entry.pack(fill=tk.X, pady=2)
        self.i0_entry.insert(0, "0.001")
        
        # -------------------------- 操作按钮区 --------------------------
        button_frame = ttk.Frame(parent)
        button_frame.pack(fill=tk.X, pady=20)
        
        # 计算按钮
        ttk.Button(button_frame, text="开始计算", command=self.calculate_backwater_analysis, style='TButton').pack(fill=tk.X, pady=5)
        
        # 重置按钮
        ttk.Button(button_frame, text="重置", command=self.reset_backwater_analysis_input, style='TButton').pack(fill=tk.X, pady=5)
        
        # -------------------------- 计算公式说明 --------------------------
        formula_frame = ttk.LabelFrame(parent, text="计算公式说明", padding="10")
        formula_frame.pack(fill=tk.X, pady=10)
        
        formula_text = """
1. 壅水系数η：根据河流类型和河滩路堤阻挡流量比例确定

2. 桥下设计过水断面面积：ω = Q_P / (V_P cosα)

3. 冲刷系数：P = ω_design / ω_actual

4. 桥下平均流速：
   - 松软土：VM = V_P
   - 中等土：VM = V_P × 2P/(P+1)
   - 密实土：VM = P × V_P

5. 桥前最大壅水高度：ΔZ = η(VM² - V²)

6. 壅水曲线长度：L = 2ΔZ / I₀
        """
        ttk.Label(formula_frame, text=formula_text, justify=tk.LEFT, font=('SimHei', 10)).pack(fill=tk.X)
    
    def create_design_flood_result(self, parent):
        """创建设计洪水计算结果显示区域"""
        self.design_flood_result_frame = ttk.LabelFrame(parent, text="设计洪水计算结果", padding="10")
        self.design_flood_result_frame.pack(fill=tk.BOTH, expand=True)
        
        # 初始提示
        ttk.Label(self.design_flood_result_frame, text="请在左侧输入参数并点击'开始计算'按钮进行计算", font=('SimHei', 12), justify=tk.CENTER).pack(fill=tk.BOTH, expand=True, pady=50)
    
    def create_flood_level_result(self, parent):
        """创建洪水位计算结果显示区域"""
        self.flood_level_result_frame = ttk.LabelFrame(parent, text="洪水位计算结果", padding="10")
        self.flood_level_result_frame.pack(fill=tk.BOTH, expand=True)
        
        # 初始提示
        ttk.Label(self.flood_level_result_frame, text="请在左侧输入参数并点击'开始计算'按钮进行计算", font=('SimHei', 12), justify=tk.CENTER).pack(fill=tk.BOTH, expand=True, pady=50)
    
    def create_water_level_discharge_plot(self, parent):
        """创建水位流量关系图绘制区域"""
        # 使用更现代的Matplotlib样式
        plt.style.use('ggplot')
        
        # 创建Figure对象，优化尺寸比例
        self.wld_fig = Figure(figsize=(10, 7), dpi=100)
        self.wld_ax = self.wld_fig.add_subplot(111)
        
        # 设置图表背景和网格样式
        self.wld_fig.patch.set_facecolor('#f0f4f8')
        self.wld_ax.set_facecolor('#ffffff')
        self.wld_ax.grid(True, linestyle='--', alpha=0.7, color='#e2e8f0')
        
        # 创建Canvas对象
        self.wld_canvas = FigureCanvasTkAgg(self.wld_fig, master=parent)
        self.wld_canvas.draw()
        self.wld_canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
        
        # 添加Matplotlib工具栏，支持缩放、平移等交互式操作
        self.wld_toolbar = NavigationToolbar2Tk(self.wld_canvas, parent)
        self.wld_toolbar.update()
        
        # 初始显示提示信息 - 使用更现代化的样式
        self.wld_ax.text(0.5, 0.5, "请在左侧输入参数并点击'绘制图表'按钮", 
                         ha='center', va='center', fontsize=14, 
                         color='#64748b', fontweight='bold', 
                         transform=self.wld_ax.transAxes)
        
        # 设置图表标题和标签的字体样式
        self.wld_ax.set_title('水位流量关系图', fontdict={'fontsize': 16, 'fontweight': 'bold', 'color': '#1e293b'})
        self.wld_ax.set_xlabel('流量 (m³/s)', fontdict={'fontsize': 12, 'fontweight': 'bold', 'color': '#1e293b'})
        self.wld_ax.set_ylabel('水位 (m)', fontdict={'fontsize': 12, 'fontweight': 'bold', 'color': '#1e293b'})
        
        # 优化坐标轴刻度样式
        self.wld_ax.tick_params(axis='both', which='major', labelsize=10, colors='#475569')
        self.wld_ax.tick_params(axis='both', which='minor', labelsize=8, colors='#94a3b8')
        
        # 调整图表布局
        self.wld_fig.tight_layout()
    
    def add_flood_visual_elements(self):
        """添加洪水相关的视觉元素"""
        # 已在create_tab_control方法中添加了视觉元素，此处不再重复添加
        pass
    
    def create_status_bar(self):
        """创建状态栏"""
        # 创建状态栏框架
        self.status_bar = ttk.Frame(self.root, relief=tk.SUNKEN, height=25, style='StatusBar.TFrame')
        self.status_bar.pack(side=tk.BOTTOM, fill=tk.X)
        
        # 左侧状态信息
        self.status_var = tk.StringVar(value="准备就绪")
        status_label = ttk.Label(self.status_bar, textvariable=self.status_var, font=('Microsoft YaHei', 9), anchor=tk.W, padding=5)
        status_label.pack(side=tk.LEFT, fill=tk.X, expand=True)
        
        # 中间进度条（默认隐藏）
        self.progress_var = tk.DoubleVar(value=0)
        self.progress_bar = ttk.Progressbar(self.status_bar, variable=self.progress_var, orient=tk.HORIZONTAL, length=200, mode='determinate')
        self.progress_bar.pack(side=tk.LEFT, padx=10, pady=3)
        self.progress_bar.pack_forget()  # 默认隐藏
        
        # 右侧信息：当前时间
        self.time_var = tk.StringVar()
        time_label = ttk.Label(self.status_bar, textvariable=self.time_var, font=('Microsoft YaHei', 9), anchor=tk.E, padding=5)
        time_label.pack(side=tk.RIGHT)
        
        # 更新时间
        self.update_time()
    
    def update_time(self):
        """更新状态栏时间"""
        from datetime import datetime
        self.time_var.set(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
        # 每秒更新一次
        self.root.after(1000, self.update_time)
    
    def update_status(self, message, progress=None):
        """更新状态栏信息"""
        self.status_var.set(message)
        if progress is not None:
            self.progress_var.set(progress)
            if not self.progress_bar.winfo_ismapped():
                self.progress_bar.pack(side=tk.LEFT, padx=10, pady=3)
        else:
            if self.progress_bar.winfo_ismapped():
                self.progress_bar.pack_forget()
    
    def on_tab_changed(self, event):
        """标签页切换事件处理"""
        current_tab = self.tab_control.select()
        tab_index = self.tab_control.index(current_tab)
        tab_names = ['设计洪水计算', '洪水位计算', '水位流量关系图', '壅水分析计算', '历史洪水对比', '计算结果']
        if 0 <= tab_index < len(tab_names):
            self.update_status(f"当前页面：{tab_names[tab_index]}")
    
    def on_tree_select(self, event):
        """表格选择事件处理"""
        selected_items = self.results_tree.selection()
        if selected_items:
            self.update_status(f"已选择 {len(selected_items)} 条记录")
    
    def show_context_menu(self, event):
        """显示右键菜单"""
        pass  # 可根据需要实现右键菜单功能
    
    def on_window_resize(self, event):
        """窗口大小变化事件处理"""
        # 只处理主窗口大小变化，忽略其他窗口
        if event.widget == self.root:
            # 更新状态栏信息
            self.update_status(f"窗口大小：{self.root.winfo_width()}x{self.root.winfo_height()}")
            # 可以在这里添加其他响应式调整逻辑
            # 例如调整图表大小、重新排列控件等
    
    def bind_shortcuts(self):
        """绑定快捷键"""
        # 计算相关快捷键
        self.root.bind("<Control-c>", lambda e: self.calculate_design_flood() if hasattr(self, 'calculate_design_flood') else None)
        self.root.bind("<Control-f>", lambda e: self.calculate_flood_level() if hasattr(self, 'calculate_flood_level') else None)
        
        # 保存/加载快捷键
        self.root.bind("<Control-s>", lambda e: self.save_params("design_flood") if hasattr(self, 'save_params') else None)
        self.root.bind("<Control-l>", lambda e: self.load_params("design_flood") if hasattr(self, 'load_params') else None)
        
        # 导出快捷键
        self.root.bind("<Control-e>", lambda e: self.export_results() if hasattr(self, 'export_results') else None)
        
        # 重置快捷键
        self.root.bind("<Control-r>", lambda e: self.reset_design_flood_input() if hasattr(self, 'reset_design_flood_input') else None)
        
        # 退出快捷键
        self.root.bind("<Control-q>", lambda e: self.root.quit())
    
    def create_results_table(self, parent):
        """创建结果表格"""
        # 创建表格框架
        table_frame = ttk.Frame(parent)
        table_frame.pack(fill=tk.BOTH, expand=True, pady=10)
        
        # 创建滚动条
        scrollbar_x = ttk.Scrollbar(table_frame, orient=tk.HORIZONTAL)
        scrollbar_y = ttk.Scrollbar(table_frame, orient=tk.VERTICAL)
        
        # 创建表格 - 改进样式
        self.results_tree = ttk.Treeview(table_frame, columns=[], show='headings', 
                                        xscrollcommand=scrollbar_x.set, yscrollcommand=scrollbar_y.set, 
                                        style='Modern.Treeview')
        
        # 配置滚动条
        scrollbar_x.config(command=self.results_tree.xview)
        scrollbar_y.config(command=self.results_tree.yview)
        
        # 布局 - 更紧凑的布局
        self.results_tree.grid(row=0, column=0, sticky=tk.NSEW)
        scrollbar_y.grid(row=0, column=1, sticky=tk.NS)
        scrollbar_x.grid(row=1, column=0, sticky=tk.EW)
        
        # 配置表格框架的网格权重
        table_frame.rowconfigure(0, weight=1)
        table_frame.columnconfigure(0, weight=1)
        
        # 添加表格点击事件
        self.results_tree.bind("<<TreeviewSelect>>", self.on_tree_select)
        
        # 添加右键菜单支持
        self.results_tree.bind("<Button-3>", self.show_context_menu)
    
    def create_backwater_analysis_result(self, parent):
        """创建壅水分析计算结果显示区域"""
        self.backwater_analysis_result_frame = ttk.LabelFrame(parent, text="壅水分析计算结果", padding="10")
        self.backwater_analysis_result_frame.pack(fill=tk.BOTH, expand=True)
        
        # 初始提示
        ttk.Label(self.backwater_analysis_result_frame, text="请在左侧输入参数并点击'开始计算'按钮进行计算", font=('SimHei', 12), justify=tk.CENTER).pack(fill=tk.BOTH, expand=True, pady=50)
    
    def toggle_section_type(self):
        """切换断面类型时显示/隐藏相应控件"""
        if self.section_type_var.get() == 'rectangle':
            self.m_frame.pack_forget()
        else:
            self.m_frame.pack(fill=tk.X, pady=2)
    
    def reset_design_flood_input(self):
        """重置设计洪水计算输入"""
        try:
            # 重置方法选择
            self.traditional_method_var.set(True)
            self.unit_hydrograph_method_var.set(False)
            self.toggle_method_frames()
            
            # 重置传统方法参数
            flood_type_options = list(FLOOD_TYPE_PARAMS.keys())
            self.flood_type_var.set(flood_type_options[1])  # 默认选择泼机河型
            
            self.area_entry.delete(0, tk.END)
            self.area_entry.insert(0, str(DEFAULT_PARAMS['design_flood']['area']))
            
            self.pd24_entry.delete(0, tk.END)
            self.pd24_entry.insert(0, str(DEFAULT_PARAMS['design_flood']['pd24']))
            
            self.eta_entry.delete(0, tk.END)
            self.eta_entry.insert(0, str(DEFAULT_PARAMS['design_flood']['eta']))
            
            self.c_entry.delete(0, tk.END)
            self.c_entry.insert(0, str(DEFAULT_PARAMS['design_flood']['c']))
            
            self.n_exp_entry.delete(0, tk.END)
            self.n_exp_entry.insert(0, str(DEFAULT_PARAMS['design_flood']['n_exp']))
            
            self.cv_q_entry.delete(0, tk.END)
            self.cv_q_entry.insert(0, str(DEFAULT_PARAMS['design_flood']['cv_q']))
            
            self.cv_w24_entry.delete(0, tk.END)
            self.cv_w24_entry.insert(0, str(DEFAULT_PARAMS['design_flood']['cv_w24']))
            
            self.frequencies_entry.delete(0, tk.END)
            self.frequencies_entry.insert(0, DEFAULT_PARAMS['design_flood']['frequencies'])
            
            # 重置单位线法参数
            self.unit_area_entry.delete(0, tk.END)
            self.unit_area_entry.insert(0, str(DEFAULT_PARAMS['design_flood']['area']))
            
            self.unit_L_entry.delete(0, tk.END)
            self.unit_L_entry.insert(0, "10.0")
            
            self.unit_J_entry.delete(0, tk.END)
            self.unit_J_entry.insert(0, "10.0")
            
            self.unit_H24_entry.delete(0, tk.END)
            self.unit_H24_entry.insert(0, str(DEFAULT_PARAMS['design_flood']['pd24']))
            
            self.unit_Cv_entry.delete(0, tk.END)
            self.unit_Cv_entry.insert(0, "0.35")
            
            self.unit_Cs_entry.delete(0, tk.END)
            self.unit_Cs_entry.insert(0, "3.5")
            
            self.unit_frequencies_entry.delete(0, tk.END)
            self.unit_frequencies_entry.insert(0, DEFAULT_PARAMS['design_flood']['frequencies'])
            

        except Exception as e:
            messagebox.showerror("错误", f"重置输入失败：{str(e)}")
    
    def reset_flood_level_input(self):
        """重置洪水位计算输入"""
        try:
            # 重置断面类型
            self.section_type_var.set("trapezoid")
            self.toggle_section_type()
            
            # 重置梯形断面参数：边坡系数m
            self.m_entry.delete(0, tk.END)
            self.m_entry.insert(0, str(DEFAULT_PARAMS['flood_level']['m']))
            
            # 重置河底宽度b
            self.b_entry.delete(0, tk.END)
            self.b_entry.insert(0, str(DEFAULT_PARAMS['flood_level']['b']))
            
            # 重置河底高程
            self.bed_elevation_entry.delete(0, tk.END)
            self.bed_elevation_entry.insert(0, str(DEFAULT_PARAMS['flood_level']['bed_elevation']))
            
            # 重置河岸高程
            self.bank_elevation_entry.delete(0, tk.END)
            self.bank_elevation_entry.insert(0, str(DEFAULT_PARAMS['flood_level']['bank_elevation']))
            
            # 重置曼宁糙率系数n
            self.n_entry.delete(0, tk.END)
            self.n_entry.insert(0, str(DEFAULT_PARAMS['flood_level']['n']))
            
            # 重置水面比降s
            self.s_entry.delete(0, tk.END)
            self.s_entry.insert(0, str(DEFAULT_PARAMS['flood_level']['s']))
            
            # 重置设计流量
            self.q_list_entry.delete(0, tk.END)
            self.q_list_entry.insert(0, DEFAULT_PARAMS['flood_level']['q_list'])
            

        except Exception as e:
            messagebox.showerror("错误", f"重置输入失败：{str(e)}")
    
    def reset_water_level_discharge_input(self):
        """重置水位流量关系图输入"""
        try:
            # 重置桥梁名称
            self.bridge_name_entry.delete(0, tk.END)
            self.bridge_name_entry.insert(0, DEFAULT_PARAMS['water_level_discharge']['bridge_name'])
            
            # 重置河岸高程
            self.wld_bank_elevation_entry.delete(0, tk.END)
            self.wld_bank_elevation_entry.insert(0, str(DEFAULT_PARAMS['water_level_discharge']['bank_elevation']))
            
            # 重置桥底设计高程
            self.wld_bridge_bottom_elevation_entry.delete(0, tk.END)
            self.wld_bridge_bottom_elevation_entry.insert(0, str(DEFAULT_PARAMS['water_level_discharge']['bridge_bottom_elevation']))
            
            # 重置数据来源选择
            self.data_source_var.set("manual")
            
            # 重置手动输入数据
            self.wld_discharges_entry.delete(0, tk.END)
            self.wld_discharges_entry.insert(0, DEFAULT_PARAMS['water_level_discharge']['discharges'])
            
            self.wld_water_levels_entry.delete(0, tk.END)
            self.wld_water_levels_entry.insert(0, DEFAULT_PARAMS['water_level_discharge']['water_levels'])
            
            self.wld_return_periods_entry.delete(0, tk.END)
            self.wld_return_periods_entry.insert(0, DEFAULT_PARAMS['water_level_discharge']['return_periods'])
            

        except Exception as e:
            messagebox.showerror("错误", f"重置输入失败：{str(e)}")
    
    def reset_flood_hydrograph_input(self):
        """重置洪水过程线输入"""
        try:
            # 重置过程线类型选择
            self.hydrograph_type_var.set(DEFAULT_PARAMS['flood_hydrograph']['hydrograph_type'])
            
            # 重置三角形过程线参数
            self.hydrograph_qp_var.set(str(DEFAULT_PARAMS['flood_hydrograph']['qp']))
            self.hydrograph_t_base_var.set(str(DEFAULT_PARAMS['flood_hydrograph']['t_base']))
            
            # 重置单位线过程线参数
            self.hydrograph_rainfall_var.set(DEFAULT_PARAMS['flood_hydrograph']['rainfall'])
            self.hydrograph_unit_var.set(DEFAULT_PARAMS['flood_hydrograph']['unit'])
            
            # 重置综合单位线参数
            self.synthetic_f_var.set(str(DEFAULT_PARAMS['flood_hydrograph']['f']))
            self.synthetic_l_var.set(str(DEFAULT_PARAMS['flood_hydrograph']['l']))
            self.synthetic_j_var.set(str(DEFAULT_PARAMS['flood_hydrograph']['j']))
            self.synthetic_dt_var.set(str(DEFAULT_PARAMS['flood_hydrograph']['dt']))
            
            # 切换回三角形过程线参数显示
            self.toggle_hydrograph_inputs()
            

        except Exception as e:
            messagebox.showerror("错误", f"重置输入失败：{str(e)}")
    
    def reset_dike_design_input(self):
        """重置堤防设计输入"""
        try:
            # 重置设计洪水位
            self.dike_flood_level_var.set(str(DEFAULT_PARAMS['dike_design']['flood_level']))
            
            # 重置堤基地面高程
            self.dike_ground_elevation_var.set(str(DEFAULT_PARAMS['dike_design']['ground_elevation']))
            
            # 重置结果显示
            self.dike_safety_height_var.set("")
            self.dike_design_elevation_var.set("")
            

        except Exception as e:
            messagebox.showerror("错误", f"重置输入失败：{str(e)}")
    
    def reset_backwater_analysis_input(self):
        """重置壅水分析输入"""
        try:
            # 重置河流类型
            self.river_type_var.set("山区河流")
            
            # 重置河滩路堤阻挡流量比例
            self.flow_ratio_entry.delete(0, tk.END)
            self.flow_ratio_entry.insert(0, "10")
            
            # 重置设计流量Qp
            self.qp_entry.delete(0, tk.END)
            self.qp_entry.insert(0, "100")
            
            # 重置设计流速Vp
            self.vp_entry.delete(0, tk.END)
            self.vp_entry.insert(0, "2.0")
            
            # 重置水流交角
            self.alpha_entry.delete(0, tk.END)
            self.alpha_entry.insert(0, "0")
            
            # 重置桥下实际过水断面面积
            self.omega_actual_entry.delete(0, tk.END)
            self.omega_actual_entry.insert(0, "50")
            
            # 重置土质类型
            self.soil_type_var.set("中等土")
            
            # 重置断面平均流速
            self.v_entry.delete(0, tk.END)
            self.v_entry.insert(0, "1.2")
            
            # 重置河段天然水面坡度
            self.i0_entry.delete(0, tk.END)
            self.i0_entry.insert(0, "0.001")

        except Exception as e:
            messagebox.showerror("错误", f"重置输入失败：{str(e)}")

    def calculate_design_flood(self):
        """执行设计洪水计算，根据复选框选择执行不同方法"""
        try:
            # 检查是否选择了计算方法
            if not any([self.traditional_method_var.get(), 
                       self.unit_hydrograph_method_var.get()]):
                messagebox.showwarning("选择错误", "请至少选择一种计算方法")
                return
            
            # 清空之前的结果
            self.design_flood_data = {
                'basic_params': {},
                'intermediate_results': {},
                'design_results': []
            }
            
            # 执行传统方法计算
            if self.traditional_method_var.get():
                self.calculate_traditional_design_flood()
            
            # 执行单位线法计算
            if self.unit_hydrograph_method_var.get():
                self.calculate_unit_hydrograph_design_flood()
            
            # 更新结果显示
            self.update_design_flood_result_display()
            
            # 显示成功消息
            messagebox.showinfo("计算完成", "设计洪水计算已完成！")

        except Exception as e:
            messagebox.showerror("计算错误", f"计算过程中发生错误：{e}")
            self.close_progress_window()
    
    def calculate_traditional_design_flood(self):
        """执行传统方法设计洪水计算"""
        try:
            # 创建进度窗口
            self.create_progress_window("设计洪水计算")
            
            # 更新进度
            self.update_progress(10, "获取输入参数...")
            
            # 使用配置文件中的洪水类型参数
            flood_type_params = FLOOD_TYPE_PARAMS
            
            # 获取输入参数
            flood_type_name = self.flood_type_var.get()
            selected_flood_type = flood_type_params[flood_type_name]
            a = selected_flood_type["a"]
            alpha = selected_flood_type["alpha"]
            
            # 输入验证
            is_valid, area, error_msg = validate_numeric_input(self.area_entry.get(), min_value=0, field_name="流域面积")
            if not is_valid:
                messagebox.showerror("输入错误", error_msg)
                self.close_progress_window()
                return
            
            is_valid, pd24, error_msg = validate_numeric_input(self.pd24_entry.get(), min_value=0, field_name="24h点暴雨均值")
            if not is_valid:
                messagebox.showerror("输入错误", error_msg)
                self.close_progress_window()
                return
            
            # 点面折减系数η输入验证
            is_valid, eta, error_msg = validate_numeric_input(self.eta_entry.get(), min_value=0, max_value=1, field_name="点面折减系数η")
            if not is_valid:
                messagebox.showerror("输入错误", error_msg)
                self.close_progress_window()
                return
            
            is_valid, c, error_msg = validate_numeric_input(self.c_entry.get(), min_value=0, field_name="地理参数C")
            if not is_valid:
                messagebox.showerror("输入错误", error_msg)
                self.close_progress_window()
                return
            
            is_valid, n_exp, error_msg = validate_numeric_input(self.n_exp_entry.get(), min_value=0, field_name="指数n")
            if not is_valid:
                messagebox.showerror("输入错误", error_msg)
                self.close_progress_window()
                return
            
            is_valid, cv_q, error_msg = validate_numeric_input(self.cv_q_entry.get(), min_value=0, field_name="洪峰流量变差系数Cv_q")
            if not is_valid:
                messagebox.showerror("输入错误", error_msg)
                self.close_progress_window()
                return
            
            is_valid, cv_w24, error_msg = validate_numeric_input(self.cv_w24_entry.get(), min_value=0, field_name="24小时洪量变差系数Cv_w24")
            if not is_valid:
                messagebox.showerror("输入错误", error_msg)
                self.close_progress_window()
                return
            
            is_valid, frequencies, error_msg = parse_float_list(self.frequencies_entry.get(), field_name="设计频率")
            if not is_valid:
                messagebox.showerror("输入错误", error_msg)
                self.close_progress_window()
                return
            
            # 更新进度
            self.update_progress(25, "计算中间参数...")
            
            # 自动计算Cs值
            cs_q = 4.0 * cv_q  # 洪峰流量Cs=4.0Cv
            cs_w24 = 3.5 * cv_w24  # 24小时洪量Cs=3.5Cv
            
            # 计算面暴雨均值Pd,0
            pd0 = calculate_pd0(eta, pd24)
            
            # 计算多年平均洪峰流量Qm0
            qm0 = calculate_qm0(c, pd0, area, n_exp)
            
            # 计算24小时洪量W24,0（单位：万m³）
            w240 = calculate_w240(a, qm0, alpha)
            
            # 更新进度
            self.update_progress(50, "计算各频率设计值...")
            
            # 计算各频率的设计洪峰流量和24小时洪量
            design_results = []
            for i, freq in enumerate(frequencies):
                # 计算洪峰流量的离均系数Φ和模比系数Kp
                phi_q = calculate_phi(freq, cs_q)
                kp_q = calculate_kp(cv_q, cs_q, freq)
                # 计算设计洪峰流量Qp
                qp = calculate_qp(qm0, cv_q, cs_q, freq)
                
                # 计算24小时洪量的离均系数Φ和模比系数Kp
                phi_w24 = calculate_phi(freq, cs_w24)
                kp_w24 = calculate_kp(cv_w24, cs_w24, freq)
                # 计算设计24小时洪量W24,p（单位：万m³）
                w24p = calculate_w24p(w240, kp_w24)
                
                design_results.append({
                    'frequency': freq,
                    'return_period': 100 / freq,
                    'phi': phi_q,
                    'kp': kp_q,
                    'phi_w24': phi_w24,
                    'kp_w24': kp_w24,
                    'qp': qp,
                    'w24p': w24p
                })
                
                # 更新进度
                progress = 50 + (40 / len(frequencies)) * (i + 1)
                self.update_progress(progress, f"计算频率 {freq}%...")
            
            # 保存计算结果
            if not self.design_flood_data['basic_params']:
                self.design_flood_data['basic_params'] = {
                    'area': area,
                    'pd24': pd24,
                    'c': c,
                    'n_exp': n_exp,
                    'cv_q': cv_q,
                    'cv_w24': cv_w24,
                    'cs_q': cs_q,
                    'cs_w24': cs_w24,
                    'eta': eta,
                    'flood_type_name': flood_type_name,
                    'a': a,
                    'alpha': alpha
                }
            
            if not self.design_flood_data['intermediate_results']:
                self.design_flood_data['intermediate_results'] = {
                    'pd0': pd0,
                    'qm0': qm0,
                    'w240': w240
                }
            
            # 为每个结果添加计算方法标识
            for result in design_results:
                result['method'] = '地区综合法'
            
            # 扩展设计结果列表
            self.design_flood_data['design_results'].extend(design_results)
            
            # 更新进度
            self.update_progress(95, "更新结果显示...")
            
            # 显示结果
            self.update_design_flood_result_display()
            
            # 更新计算结果标签页显示
            self.update_results_display()
            
            # 更新壅水分析计算参数
            self.update_backwater_params_by_frequency()
            
            # 更新进度
            self.update_progress(100, "计算完成！")
            
            # 关闭进度窗口
            self.close_progress_window()
            
            messagebox.showinfo("计算完成", "设计洪水计算已完成！")
        except Exception as e:
            self.close_progress_window()
            messagebox.showerror("计算错误", f"计算过程中发生错误：{e}")
            import traceback
            traceback.print_exc()
    
    def create_progress_window(self, title):
        """创建进度窗口"""
        self.progress_window = tk.Toplevel(self.root)
        self.progress_window.title(title)
        self.progress_window.geometry("400x120")
        self.progress_window.resizable(False, False)
        self.progress_window.grab_set()  # 模态窗口
        
        # 居中显示
        self.progress_window.update_idletasks()
        width = self.progress_window.winfo_width()
        height = self.progress_window.winfo_height()
        x = (self.progress_window.winfo_screenwidth() // 2) - (width // 2)
        y = (self.progress_window.winfo_screenheight() // 2) - (height // 2)
        self.progress_window.geometry('{}x{}+{}+{}'.format(width, height, x, y))
        
        # 进度标签
        self.progress_label = ttk.Label(self.progress_window, text="准备计算...")
        self.progress_label.pack(pady=10)
        
        # 进度条
        self.progress_bar = ttk.Progressbar(self.progress_window, length=300, mode='determinate')
        self.progress_bar.pack(pady=10)
        
        # 取消按钮
        cancel_button = ttk.Button(self.progress_window, text="取消", command=self.cancel_calculation)
        cancel_button.pack(pady=10)
        
        self.calculation_cancelled = False
    
    def update_progress(self, value, message):
        """更新进度"""
        if hasattr(self, 'progress_window') and self.progress_window:
            self.progress_bar['value'] = value
            self.progress_label.config(text=message)
            self.progress_window.update()
    
    def close_progress_window(self):
        """关闭进度窗口"""
        if hasattr(self, 'progress_window') and self.progress_window:
            self.progress_window.destroy()
            self.progress_window = None
    
    def cancel_calculation(self):
        """取消计算"""
        self.calculation_cancelled = True
        self.close_progress_window()
    
    def calculate_flood_level(self):
        """执行洪水位计算"""
        try:
            # 创建进度窗口
            self.create_progress_window("洪水位计算")
            
            # 更新进度
            self.update_progress(10, "获取输入参数...")
            
            # 获取输入参数
            section_choice = self.section_type_var.get()
            
            # 输入验证
            is_valid, b, error_msg = validate_numeric_input(self.b_entry.get(), min_value=0, field_name="河道宽度")
            if not is_valid:
                messagebox.showerror("输入错误", error_msg)
                self.close_progress_window()
                return
            
            m = 0
            if section_choice != 'rectangle':
                is_valid, m, error_msg = validate_numeric_input(self.m_entry.get(), min_value=0, field_name="边坡系数m")
                if not is_valid:
                    messagebox.showerror("输入错误", error_msg)
                    self.close_progress_window()
                    return
            
            is_valid, bed_elevation, error_msg = validate_numeric_input(self.bed_elevation_entry.get(), field_name="河床高程")
            if not is_valid:
                messagebox.showerror("输入错误", error_msg)
                self.close_progress_window()
                return
            
            is_valid, bank_elevation, error_msg = validate_numeric_input(self.bank_elevation_entry.get(), field_name="河岸高程")
            if not is_valid:
                messagebox.showerror("输入错误", error_msg)
                self.close_progress_window()
                return
            if bank_elevation <= bed_elevation:
                messagebox.showerror("输入错误", "河岸高程必须大于河床高程")
                self.close_progress_window()
                return
            
            is_valid, n, error_msg = validate_numeric_input(self.n_entry.get(), min_value=0, field_name="曼宁糙率n")
            if not is_valid:
                messagebox.showerror("输入错误", error_msg)
                self.close_progress_window()
                return
            
            is_valid, s, error_msg = validate_numeric_input(self.s_entry.get(), min_value=0, field_name="水面比降S")
            if not is_valid:
                messagebox.showerror("输入错误", error_msg)
                self.close_progress_window()
                return
            
            is_valid, q_list, error_msg = parse_float_list(self.q_list_entry.get(), field_name="设计洪峰流量")
            if not is_valid:
                messagebox.showerror("输入错误", error_msg)
                self.close_progress_window()
                return
            
            for q in q_list:
                if q <= 0:
                    messagebox.showerror("输入错误", "设计洪峰流量必须大于0")
                    self.close_progress_window()
                    return
            
            section_type = section_choice
            
            # 计算参数
            params = {
                'section_type': section_type,
                'b': b,
                'm': m,
                'bed_elevation': bed_elevation,
                'bank_elevation': bank_elevation,
                'n': n,
                's': s
            }
            
            # 更新进度
            self.update_progress(40, "计算各流量对应的水深和洪水位...")
            
            # 计算各流量对应的水深和洪水位
            results = []
            for i, q in enumerate(q_list):
                water_depth = find_water_depth(params, q)
                flood_elevation = bed_elevation + water_depth
                distance = bank_elevation - flood_elevation
                
                # 验证计算结果
                if section_type == 'rectangle':
                    a = b * water_depth
                    p = b + 2 * water_depth
                else:
                    a = (b + m * water_depth) * water_depth
                    p = b + 2 * water_depth * np.sqrt(1 + m ** 2)
                r = a / p
                v = (1 / n) * (r ** (2/3)) * (s ** (1/2))
                calculated_q = v * a
                # 判断是否溢出：1. 计算过流能力小于设计流量 或 2. 洪水高程超过河岸高程
                is_overflow = calculated_q < q - 0.1 or flood_elevation > bank_elevation
                
                # 获取对应的频率和重现期（如果有）
                frequency = None
                return_period = None
                if hasattr(self, 'design_flood_frequencies') and len(self.design_flood_frequencies) > i:
                    frequency = self.design_flood_frequencies[i]
                    return_period = self.design_flood_return_periods[i]
                
                results.append({
                    'q': q,
                    'frequency': frequency,
                    'return_period': return_period,
                    'water_depth': water_depth,
                    'flood_elevation': flood_elevation,
                    'distance': distance,
                    'calculated_q': calculated_q,
                    'is_overflow': is_overflow
                })
                
                # 更新进度
                progress = 40 + (50 / len(q_list)) * (i + 1)
                self.update_progress(progress, f"计算流量 {q} m³/s...")
            
            # 保存计算结果
            self.flood_level_data = {
                'params': params,
                'results': results
            }
            
            # 更新进度
            self.update_progress(95, "更新结果显示...")
            
            # 更新结果显示
            self.update_flood_level_result_display()
            
            # 更新计算结果标签页显示
            self.update_results_display()
            
            # 更新壅水分析计算参数
            self.update_backwater_params_by_frequency()
            
            # 更新进度
            self.update_progress(100, "计算完成！")
            
            # 关闭进度窗口
            self.close_progress_window()
            
            messagebox.showinfo("计算完成", "洪水位计算已完成！")
        except Exception as e:
            self.close_progress_window()
            messagebox.showerror("计算错误", f"计算过程中发生错误：{e}")
            import traceback
            traceback.print_exc()
    
    def plot_water_level_discharge(self):
        """绘制水位流量关系图"""
        try:
            # 清空当前图形
            self.wld_ax.clear()
            
            # 获取数据
            if self.data_source_var.get() == 'calculated':
                # 从计算结果获取数据
                if not self.flood_level_data['results']:
                    messagebox.showwarning("数据不足", "请先进行洪水位计算！")
                    return
                
                results = self.flood_level_data['results']
                discharges = [result['q'] for result in results]
                water_levels = [result['flood_elevation'] for result in results]
                return_periods = [str(i+1) for i in range(len(discharges))]
                bank_elevation = self.flood_level_data['params']['bank_elevation']
                bridge_name = self.bridge_name_entry.get()
            else:
                # 手动输入数据
                is_valid, discharges, error_msg = parse_float_list(self.wld_discharges_entry.get(), field_name="洪峰流量")
                if not is_valid:
                    messagebox.showerror("输入错误", error_msg)
                    return
                
                is_valid, water_levels, error_msg = parse_float_list(self.wld_water_levels_entry.get(), field_name="水位高程")
                if not is_valid:
                    messagebox.showerror("输入错误", error_msg)
                    return
                
                return_periods_input = self.wld_return_periods_entry.get().split()
                return_periods = return_periods_input if return_periods_input else [str(i+1) for i in range(len(discharges))]
                
                is_valid, bank_elevation, error_msg = validate_numeric_input(self.wld_bank_elevation_entry.get(), field_name="河岸高程")
                if not is_valid:
                    messagebox.showerror("输入错误", error_msg)
                    return
                
                # 获取桥底设计高程
                bridge_bottom_elevation_input = self.wld_bridge_bottom_elevation_entry.get().strip()
                bridge_bottom_elevation = None
                if bridge_bottom_elevation_input:
                    is_valid, bridge_bottom_elevation, error_msg = validate_numeric_input(bridge_bottom_elevation_input, field_name="桥底设计高程")
                    if not is_valid:
                        messagebox.showerror("输入错误", error_msg)
                        return
                
                bridge_name = self.bridge_name_entry.get()
            
            # 确保重现期数量与数据点数量一致
            if len(return_periods) != len(discharges):
                return_periods = [str(i+1) for i in range(len(discharges))]
            
            # 多种拟合模型定义
            def power_func(Q, a, b, c):
                return a * Q**b + c
            
            def linear_func(Q, a, b):
                return a * Q + b
            
            def exponential_func(Q, a, b, c):
                return a * np.exp(b * Q) + c
            
            def logarithmic_func(Q, a, b):
                return a * np.log(Q + 1e-10) + b
            
            def quadratic_func(Q, a, b, c):
                return a * Q**2 + b * Q + c
            
            # 选择拟合模型（默认为幂函数）
            fit_models = {
                'power': ('幂函数拟合', power_func),
                'linear': ('线性拟合', linear_func),
                'exponential': ('指数拟合', exponential_func),
                'logarithmic': ('对数拟合', logarithmic_func),
                'quadratic': ('二次函数拟合', quadratic_func)
            }
            
            # 默认为幂函数拟合
            selected_model_name = 'power'
            model_name, fit_func = fit_models[selected_model_name]
            
            # 转换为numpy数组
            discharges = np.array(discharges)
            water_levels = np.array(water_levels)
            
            # 使用配置文件中的颜色方案
            from config import CHART_CONFIG
            
            # 计算数据范围，确保图表有足够的显示空间
            if len(discharges) > 0:
                # 至少有一个数据点
                Q_min = max(0, np.min(discharges) - 5)
                Q_max = np.max(discharges) + 5
                Z_min = min(water_levels) - 0.3
                Z_max = max(water_levels) + 0.3
            else:
                # 特殊情况：没有数据点
                Q_min, Q_max = 0, 100
                Z_min, Z_max = 1900, 1920
            
            # 绘制河岸线
            # 使用中文标签
            self.wld_ax.axhline(y=bank_elevation, 
                               color=CHART_CONFIG['colors']['bank_elevation'], 
                               linestyle=CHART_CONFIG['line_styles']['bank_elevation'], 
                               linewidth=CHART_CONFIG['line_widths']['bank_elevation'], 
                               label=f'河岸顶高程: {bank_elevation:.2f}m', 
                               zorder=2)
            # 如果河岸顶高程不在当前范围，扩展Y轴范围
            if bank_elevation < Z_min:
                Z_min = bank_elevation - 0.5
            if bank_elevation > Z_max:
                Z_max = bank_elevation + 0.5
            
            # 绘制桥底设计高程线（如果有输入）
            if 'bridge_bottom_elevation' in locals() and bridge_bottom_elevation is not None:
                self.wld_ax.axhline(y=bridge_bottom_elevation, 
                                   color=CHART_CONFIG['colors']['bridge_bottom_elevation'], 
                                   linestyle=CHART_CONFIG['line_styles']['bridge_bottom_elevation'], 
                                   linewidth=CHART_CONFIG['line_widths']['bridge_bottom_elevation'], 
                                   label=f'桥底设计高程: {bridge_bottom_elevation:.2f}m', 
                                   zorder=2)
                # 如果桥底高程不在当前范围，扩展Y轴范围
                if bridge_bottom_elevation < Z_min:
                    Z_min = bridge_bottom_elevation - 0.5
                if bridge_bottom_elevation > Z_max:
                    Z_max = bridge_bottom_elevation + 0.5
            
            # 根据SLT808-2025规范改进洪水风险等级区域划分
            # 1. 安全区（低于河岸顶高程0.5m）
            safe_level = bank_elevation - 0.5
            if safe_level > Z_min:
                self.wld_ax.axhspan(Z_min, safe_level, alpha=0.2, color='#27ae60', label='安全区', zorder=0)
            
            # 2. 警戒区（河岸顶高程-0.5m至河岸顶高程）
            warning_level = bank_elevation
            if warning_level > safe_level:
                self.wld_ax.axhspan(safe_level, warning_level, alpha=0.2, color='#f39c12', label='警戒区', zorder=0)
            
            # 3. 危险区（高于河岸顶高程）
            if Z_max > warning_level:
                self.wld_ax.axhspan(warning_level, Z_max, alpha=0.2, color='#e74c3c', label='危险区', zorder=0)
            
            # 使用配置文件中的颜色方案
            from config import CHART_CONFIG
            
            # 生成颜色序列
            color_sequence = ['#0088FF', '#FFAA00', '#FF5555', '#99FF99', '#FF99FF', '#8888FF', '#FF8888', '#88FF88']
            colors = [color_sequence[i % len(color_sequence)] for i in range(len(discharges))]
            
            # 绘制数据点和标注（统一管理所有标注位置）
            for i, (Q, Z, period) in enumerate(zip(discharges, water_levels, return_periods)):
                color = colors[i]  # 使用颜色序列
                # 绘制数据点，设置zorder确保在拟合曲线之上
                # 使用中文标签并添加流量值
                period_zh = get_return_period_label(period)
                # 在图例中添加对应流量值和重现期
                scatter = self.wld_ax.scatter(Q, Z, s=120, c=[color], label=f'{period_zh} ({Q:.1f} m³/s)', edgecolors='black', linewidth=1.5, zorder=3, marker='o')
                
                # 标注改为显示完整信息：重现期、流量、水位
                point_label = f'{period_zh}\nQ={Q:.1f} m³/s\nZ={Z:.2f}m'
                
                # 根据点的位置动态调整标注位置，避免重叠
                if i % 2 == 0:
                    ha = 'left' if Q < Q_max * 0.8 else 'right'
                    va = 'bottom' if Z < Z_max * 0.9 else 'top'
                    xytext = (10, 5) if ha == 'left' else (-10, -5)
                else:
                    ha = 'right' if Q > Q_min * 0.2 else 'left'
                    va = 'top' if Z > Z_min * 1.01 else 'bottom'
                    xytext = (-10, -5) if ha == 'right' else (10, 5)
                
                # 绘制标注，使用更清晰的样式
                self.wld_ax.annotate(point_label, 
                               xy=(Q, Z), 
                               xytext=xytext, 
                               textcoords='offset points',
                               fontsize=9,
                               fontweight='bold',
                               color='#2c3e50',
                               bbox=dict(boxstyle='round,pad=0.5', facecolor='white', alpha=0.9, edgecolor='gray', linewidth=1),
                               ha=ha,
                               va=va,
                               zorder=4)
            
            # 检查数据点数量，只有当数据点数量足够时才进行拟合
            if len(discharges) >= 3:
                # 拟合曲线参数求解
                try:
                    # 根据不同模型设置初始值和边界
                    if selected_model_name == 'power':
                        p0 = [0.001, 1.0, min(water_levels) - 0.2]
                        bounds = ((0, 0.5, min(water_levels) - 1), (0.1, 3, max(water_levels)))
                    elif selected_model_name == 'linear':
                        p0 = [0.01, min(water_levels) - 0.2]
                        bounds = ((-np.inf, -np.inf), (np.inf, np.inf))
                    elif selected_model_name == 'exponential':
                        p0 = [0.1, 0.01, min(water_levels) - 0.2]
                        bounds = ((0, -np.inf, -np.inf), (np.inf, np.inf, np.inf))
                    elif selected_model_name == 'logarithmic':
                        p0 = [0.1, min(water_levels) - 0.2]
                        bounds = ((-np.inf, -np.inf), (np.inf, np.inf))
                    elif selected_model_name == 'quadratic':
                        p0 = [0.0001, 0.01, min(water_levels) - 0.2]
                        bounds = ((-np.inf, -np.inf, -np.inf), (np.inf, np.inf, np.inf))
                    else:
                        p0 = [0.001, 1.0, min(water_levels) - 0.2]
                        bounds = ((0, 0.5, min(water_levels) - 1), (0.1, 3, max(water_levels)))
                    
                    popt, pcov = curve_fit(
                        fit_func, 
                        discharges, 
                        water_levels, 
                        p0=p0,
                        maxfev=2000,
                        bounds=bounds
                    )
                    
                    # 计算R²
                    Z_pred = fit_func(discharges, *popt)
                    residuals = water_levels - Z_pred
                    ss_res = np.sum(residuals**2)
                    ss_tot = np.sum((water_levels - np.mean(water_levels))**2)
                    r_squared = 1 - (ss_res / ss_tot)
                    
                    # 绘制拟合曲线（延长曲线两端，增强可读性）
                    Q_fit = np.linspace(Q_min, Q_max, 100)  # 流量拟合范围
                    Z_fit = fit_func(Q_fit, *popt)
                    
                    # 根据模型类型生成不同的图例文本
                    if selected_model_name == 'power':
                        a, b, c = popt
                        fit_label = f'{model_name}: Z={a:.4f}*Q^{b:.2f}+{c:.2f} (R²={r_squared:.4f})'
                    elif selected_model_name == 'linear':
                        a, b = popt
                        fit_label = f'{model_name}: Z={a:.4f}*Q+{b:.2f} (R²={r_squared:.4f})'
                    elif selected_model_name == 'exponential':
                        a, b, c = popt
                        fit_label = f'{model_name}: Z={a:.4f}*e^({b:.4f}*Q)+{c:.2f} (R²={r_squared:.4f})'
                    elif selected_model_name == 'logarithmic':
                        a, b = popt
                        fit_label = f'{model_name}: Z={a:.4f}*ln(Q+1e-10)+{b:.2f} (R²={r_squared:.4f})'
                    elif selected_model_name == 'quadratic':
                        a, b, c = popt
                        fit_label = f'{model_name}: Z={a:.6f}*Q²+{b:.4f}*Q+{c:.2f} (R²={r_squared:.4f})'
                    else:
                        fit_label = f'{model_name} (R²={r_squared:.4f})'
                    
                    # 绘制拟合曲线
                    self.wld_ax.plot(Q_fit, Z_fit, 
                                   color='#3498db', 
                                   linewidth=2.5, 
                                   label=fit_label, 
                                   zorder=1, 
                                   linestyle='-')
                    
                    # 移除拟合信息框，简化图表
                    
                    # 添加多种拟合模型曲线对比
                    # 只对幂函数和二次函数进行对比
                    if selected_model_name == 'power':
                        # 同时绘制二次函数拟合曲线用于对比
                        try:
                            quad_popt, quad_pcov = curve_fit(
                                quadratic_func, 
                                discharges, 
                                water_levels, 
                                p0=[0.0001, 0.01, min(water_levels) - 0.2],
                                maxfev=2000,
                                bounds=((-np.inf, -np.inf, -np.inf), (np.inf, np.inf, np.inf))
                            )
                            Z_pred_quad = quadratic_func(discharges, *quad_popt)
                            residuals_quad = water_levels - Z_pred_quad
                            ss_res_quad = np.sum(residuals_quad**2)
                            r_squared_quad = 1 - (ss_res_quad / ss_tot)
                            
                            Z_fit_quad = quadratic_func(Q_fit, *quad_popt)
                            a_quad, b_quad, c_quad = quad_popt
                            quad_label = f'二次函数拟合: Z={a_quad:.6f}*Q²+{b_quad:.4f}*Q+{c_quad:.2f} (R²={r_squared_quad:.4f})'
                            
                            self.wld_ax.plot(Q_fit, Z_fit_quad, 
                                           color='#e74c3c', 
                                           linewidth=1.5, 
                                           label=quad_label, 
                                           zorder=1, 
                                           linestyle='--')
                        except Exception as e:
                            print(f"\n二次函数拟合失败：{e}")
                    
                except Exception as e:
                    print(f"\n拟合曲线绘制失败：{e}")
            elif len(discharges) == 2:
                # 只有2个数据点，绘制直线连接
                self.wld_ax.plot(discharges, water_levels, color='#000000', linewidth=2.5, label='两点连线', zorder=1, linestyle='-')
            elif len(discharges) == 1:
                # 只有1个数据点，绘制垂直线和水平线标记
                Q = discharges[0]
                Z = water_levels[0]
                self.wld_ax.axvline(x=Q, color='gray', linestyle='--', alpha=0.7, zorder=1, label=f'洪峰流量: {Q:.1f} m³/s')
                self.wld_ax.axhline(y=Z, color='gray', linestyle='--', alpha=0.7, zorder=1, label=f'水位: {Z:.2f}m')
            
            # 添加设计流量的垂直线，与示例图保持一致
            # 取中间的流量值作为设计流量示例
            if len(discharges) > 0:
                middle_idx = len(discharges) // 2
                design_q = discharges[middle_idx]
                design_z = water_levels[middle_idx]
                period_zh = get_return_period_label(return_periods[middle_idx])
                self.wld_ax.axvline(x=design_q, 
                                   color='#9b59b6', 
                                   linestyle='--', 
                                   linewidth=1.5, 
                                   label=f'{period_zh}设计流量: {design_q:.1f} m³/s', 
                                   zorder=1)
            
            # 添加数据来源说明
            self.wld_ax.text(0.5, -0.15, f'数据来源：{"计算结果" if self.data_source_var.get() == "calculated" else "手动输入"}', 
                           transform=self.wld_ax.transAxes,
                           fontsize=9, 
                           color='#7f8c8d',
                           ha='center',
                           bbox=dict(boxstyle='round,pad=0.3', facecolor='white', alpha=0.8, edgecolor='gray'))
            
            # 设置坐标轴，使用中文标签，使用正确的立方米符号
            self.wld_ax.set_xlabel('洪峰流量 Q (m³/s)', fontsize=14, fontweight='bold', labelpad=10, color='#2c3e50')
            self.wld_ax.set_ylabel('高程 Z (m)', fontsize=14, fontweight='bold', labelpad=10, color='#2c3e50')
            self.wld_ax.set_title(f'{bridge_name}水位流量关系图', fontsize=18, fontweight='bold', pad=20, color='#2c3e50')
            
            # 设置刻度标签字体
            self.wld_ax.tick_params(axis='both', which='major', labelsize=12, width=1, length=6, direction='out', colors='#2c3e50')
            
            # 调整坐标轴范围和刻度，增加边距避免数据被截断
            self.wld_ax.set_xlim(Q_min - (Q_max - Q_min) * 0.05, Q_max + (Q_max - Q_min) * 0.05)
            self.wld_ax.set_ylim(Z_min - (Z_max - Z_min) * 0.05, Z_max + (Z_max - Z_min) * 0.05)
            
            # 设置合理的刻度间隔
            x_range = Q_max - Q_min
            y_range = Z_max - Z_min
            
            # 根据数据范围动态调整刻度间隔，确保刻度数量合理（4-8个刻度为宜）
            if x_range > 0:
                # 调整刻度数量，确保可读性
                x_tick_count = min(8, max(4, int(x_range / 10) + 1))
                x_tick_step = round(x_range / x_tick_count, -1) if x_range > 10 else round(x_range / x_tick_count, 1)
                x_tick_step = max(1, x_tick_step)  # 确保最小步长为1
            else:
                x_tick_step = 10
            
            if y_range > 0:
                # 增加更多的高程刻度，使图表更美观
                # 目标：大约15-20个刻度，显示更详细的高程信息
                y_tick_count = min(20, max(10, int(y_range / 0.1) + 1))
                y_tick_step = round(y_range / y_tick_count, 2)
                y_tick_step = max(0.05, y_tick_step)  # 确保最小步长为0.05，显示更多高程
            else:
                y_tick_step = 0.1
            
            # 确保刻度间隔合理，避免过多或过少的刻度
            self.wld_ax.set_xticks(np.arange(Q_min, Q_max + x_tick_step, x_tick_step))
            self.wld_ax.set_yticks(np.arange(Z_min, Z_max + y_tick_step, y_tick_step))
            
            # 设置Y轴刻度为固定间隔，确保高程显示均匀
            # 四舍五入到最接近的0.05或0.1，使刻度更加美观
            y_ticks = np.arange(np.floor(Z_min*20)/20, np.ceil(Z_max*20)/20 + y_tick_step, y_tick_step)
            self.wld_ax.set_yticks(y_ticks)
            
            # 设置坐标轴刻度字体和样式
            self.wld_ax.tick_params(axis='both', which='major', labelsize=12, width=1, length=6, direction='out', colors='#2c3e50')
            self.wld_ax.tick_params(axis='both', which='minor', width=0.5, length=3, direction='out', colors='#7f8c8d')
            
            # 添加次要刻度
            self.wld_ax.minorticks_on()
            
            # 设置网格，与示例图保持一致，使用实线网格
            self.wld_ax.grid(True, which='major', alpha=0.3, linestyle='-', linewidth=0.8, color='#bdc3c7')
            self.wld_ax.grid(True, which='minor', alpha=0.1, linestyle='--', linewidth=0.4, color='#bdc3c7')
            
            # 设置坐标轴边框样式
            for spine in self.wld_ax.spines.values():
                spine.set_linewidth(1.5)
                spine.set_color('#2c3e50')
            
            # 添加图例，优化位置和样式
            # 将图例移到图表左侧，缩小比例
            self.wld_ax.legend(loc='upper left', fontsize=6, framealpha=0.95, 
                             frameon=True, borderpad=0.15, labelspacing=0.08, ncol=1, fancybox=True, 
                             handlelength=1.0, handletextpad=0.3, edgecolor='#7f8c8d', title='图例',
                             title_fontsize=7, bbox_transform=self.wld_ax.transAxes, 
                             bbox_to_anchor=(0.02, 0.98))
            
            # 添加图表背景色，提高对比度
            self.wld_ax.set_facecolor('#ffffff')
            self.wld_fig.patch.set_facecolor('#f8f9fa')
            
            # 调整图表布局，增加左边距，确保图例完整显示
            self.wld_fig.subplots_adjust(left=0.18, right=0.95, top=0.92, bottom=0.15, wspace=0.2, hspace=0.2)
            
            # 保存水位流量关系图数据
            self.water_level_discharge_data = {
                'discharges': discharges.tolist() if hasattr(discharges, 'tolist') else discharges,
                'water_levels': water_levels.tolist() if hasattr(water_levels, 'tolist') else water_levels,
                'return_periods': return_periods,
                'bank_elevation': bank_elevation,
                'bridge_bottom_elevation': bridge_bottom_elevation,
                'bridge_name': bridge_name
            }
            
            # 更新图表
            self.wld_canvas.draw()
            
            # 更新壅水分析计算参数
            self.update_backwater_params_by_frequency()
        except Exception as e:
            messagebox.showerror("绘图错误", f"绘图过程中发生错误：{e}")
    
    def export_water_level_discharge_plot(self):
        """导出水位流量关系图"""
        try:
            # 确保output/plots目录存在
            import os
            os.makedirs('output/plots', exist_ok=True)
            
            file_path = filedialog.asksaveasfilename(
                defaultextension=".png",
                filetypes=[
                    ("PNG图片", "*.png"), 
                    ("JPEG图片", "*.jpg"), 
                    ("PDF文件", "*.pdf"),
                    ("SVG矢量图", "*.svg"),
                    ("EPS矢量图", "*.eps"),
                    ("TIFF图片", "*.tiff")
                ],
                initialdir="output/plots"
            )
            if file_path:
                # 直接使用matplotlib的savefig方法，支持更多格式
                self.wld_fig.savefig(
                    file_path, 
                    dpi=300, 
                    bbox_inches='tight', 
                    pad_inches=0.1,
                    facecolor='white',
                    edgecolor='none'
                )
                messagebox.showinfo("导出成功", f"图表已成功导出到 {file_path}！")
        except Exception as e:
            messagebox.showerror("导出错误", f"导出过程中发生错误：{e}")
    
    def update_design_flood_result_display(self):
        """更新设计洪水计算结果显示"""
        # 清除现有内容
        for widget in self.design_flood_result_frame.winfo_children():
            widget.destroy()
        
        # 检查是否有计算结果
        if not self.design_flood_data['design_results']:
            no_result_label = ttk.Label(self.design_flood_result_frame, text="暂无计算结果，请先进行计算", font=('SimHei', 12), foreground='#666')
            no_result_label.pack(pady=20)
            return
        
        # 显示基本参数（如果存在）
        params = self.design_flood_data['basic_params']
        if params:
            basic_params_frame = ttk.LabelFrame(self.design_flood_result_frame, text="基本参数", padding="5")
            basic_params_frame.pack(fill=tk.X, pady=5)
            
            info_text = f"""
暴雨分区：滇东北暴雨区（昭通市地区）
流域面积：{params.get('area', 'N/A')} km²
24h点暴雨均值：{params.get('pd24', 'N/A')} mm
点面折减系数η：{params.get('eta', 'N/A')}
地理参数C：{params.get('c', 'N/A')}
指数n：{params.get('n_exp', 'N/A')}
洪峰流量变差系数Cv_q：{params.get('cv_q', 'N/A')}
洪峰流量偏态系数Cs_q：{params.get('cs_q', 'N/A')}
24小时洪量变差系数Cv_w24：{params.get('cv_w24', 'N/A')}
24小时洪量偏态系数Cs_w24：{params.get('cs_w24', 'N/A')}
洪水类型：{params.get('flood_type_name', 'N/A')}（系数a={params.get('a', 'N/A')}）
指数α：{params.get('alpha', 'N/A')}
"""
            ttk.Label(basic_params_frame, text=info_text, justify=tk.LEFT).pack(fill=tk.X)
        
        # 显示中间计算结果（如果存在）
        intermediate = self.design_flood_data['intermediate_results']
        if intermediate:
            intermediate_frame = ttk.LabelFrame(self.design_flood_result_frame, text="中间计算结果", padding="5")
            intermediate_frame.pack(fill=tk.X, pady=5)
            
            intermediate_text = f"""
面暴雨均值Pd,0：{intermediate.get('pd0', 0):.1f} mm
多年平均洪峰流量Qm0：{intermediate.get('qm0', 0):.1f} m³/s
24小时平均洪水量W24h：{intermediate.get('w240', 0):.1f} 万m³
"""
            ttk.Label(intermediate_frame, text=intermediate_text, justify=tk.LEFT).pack(fill=tk.X)
        
        # 显示设计洪水计算结果表格
        design_results_frame = ttk.LabelFrame(self.design_flood_result_frame, text="设计洪水计算结果", padding="10")
        design_results_frame.pack(fill=tk.BOTH, expand=True, pady=5)
        
        # 创建带滚动条的表格
        table_container = ttk.Frame(design_results_frame)
        table_container.pack(fill=tk.BOTH, expand=True)
        
        # 创建滚动条
        scrollbar_y = ttk.Scrollbar(table_container, orient=tk.VERTICAL)
        scrollbar_x = ttk.Scrollbar(table_container, orient=tk.HORIZONTAL)
        
        # 创建表格，增加计算方法列
        columns = ['method', 'frequency', 'return_period', 'qp', 'w24p']
        column_names = ['计算方法', '频率(%)', '重现期(年)', '设计流量(m³/s)', 'W24h (万m³)']
        column_widths = [100, 80, 90, 120, 120]  # 优化列宽
        
        tree = ttk.Treeview(table_container, 
                           columns=columns, 
                           show='headings',
                           yscrollcommand=scrollbar_y.set,
                           xscrollcommand=scrollbar_x.set)
        
        # 配置滚动条
        scrollbar_y.config(command=tree.yview)
        scrollbar_x.config(command=tree.xview)
        
        # 设置表头和列宽
        for col, name, width in zip(columns, column_names, column_widths):
            tree.heading(col, text=name)
            tree.column(col, width=width, anchor=tk.CENTER)
        
        # 添加数据并设置交替行颜色
        for i, result in enumerate(self.design_flood_data['design_results']):
            item = tree.insert('', tk.END, values=(
                result.get('method', 'N/A'),
                f"{result['frequency']:.1f}",
                f"{result['return_period']:.1f}",
                f"{result['qp']:.1f}",
                f"{result['w24p']:.1f}"
            ))
            # 设置交替行颜色
            if i % 2 == 1:
                tree.item(item, tags=('oddrow',))
        
        # 添加标签样式
        tree.tag_configure('oddrow', background='#f1f3f4')
        
        # 布局表格和滚动条
        tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        scrollbar_y.pack(side=tk.RIGHT, fill=tk.Y)
        scrollbar_x.pack(side=tk.BOTTOM, fill=tk.X)
    
    def update_flood_level_result_display(self):
        """更新洪水位计算结果显示"""
        # 清除现有内容
        for widget in self.flood_level_result_frame.winfo_children():
            widget.destroy()
        
        # 显示基本参数
        params = self.flood_level_data['params']
        basic_params_frame = ttk.LabelFrame(self.flood_level_result_frame, text="基本参数", padding="5")
        basic_params_frame.pack(fill=tk.X, pady=5)
        
        params_text = f"""
断面类型: {'矩形' if params['section_type'] == 'rectangle' else '梯形'}
河道宽度: {params['b']} m
{'边坡系数: ' + str(params['m']) + '\n' if params['section_type'] == 'trapezoid' else ''}河床高程: {params['bed_elevation']} m
河岸高程: {params['bank_elevation']} m
曼宁糙率n: {params['n']}
水面比降S: {params['s']}
"""
        ttk.Label(basic_params_frame, text=params_text, justify=tk.LEFT).pack(fill=tk.X)
        
        # 显示计算结果表格
        results_frame = ttk.LabelFrame(self.flood_level_result_frame, text="洪水位计算结果", padding="10")
        results_frame.pack(fill=tk.BOTH, expand=True, pady=5)
        
        # 创建带滚动条的表格
        table_container = ttk.Frame(results_frame)
        table_container.pack(fill=tk.BOTH, expand=True)
        
        # 创建滚动条
        scrollbar_y = ttk.Scrollbar(table_container, orient=tk.VERTICAL)
        scrollbar_x = ttk.Scrollbar(table_container, orient=tk.HORIZONTAL)
        
        # 创建表格
        columns = ['frequency', 'return_period', 'q', 'water_depth', 'flood_elevation', 'distance', 'calculated_q', 'is_overflow']
        column_names = ['设计频率(%)', '重现期(年)', '设计流量(m³/s)', '计算水深(m)', '洪水位高程(m)', '与河岸距离(m)', '实际过流能力(m³/s)', '流量验证']
        column_widths = [100, 90, 100, 100, 110, 110, 120, 90]  # 优化列宽
        
        tree = ttk.Treeview(table_container, 
                           columns=columns, 
                           show='headings',
                           yscrollcommand=scrollbar_y.set,
                           xscrollcommand=scrollbar_x.set)
        
        # 配置滚动条
        scrollbar_y.config(command=tree.yview)
        scrollbar_x.config(command=tree.xview)
        
        # 设置表头和列宽
        for col, name, width in zip(columns, column_names, column_widths):
            tree.heading(col, text=name)
            tree.column(col, width=width, anchor=tk.CENTER)
        
        # 添加数据并设置交替行颜色
        for i, result in enumerate(self.flood_level_data['results']):
            frequency = f"{result['frequency']}%" if result['frequency'] is not None else "-"
            return_period = f"{result['return_period']}年" if result['return_period'] is not None else "-"
            flow_verification = "✅ 满足" if not result['is_overflow'] else "⚠️  不满足"
            item = tree.insert('', tk.END, values=(
                frequency,
                return_period,
                f"{result['q']:.1f}",
                f"{result['water_depth']:.3f}",
                f"{result['flood_elevation']:.3f}",
                f"{result['distance']:.3f}",
                f"{result['calculated_q']:.1f}",
                flow_verification
            ))
            # 设置交替行颜色
            if i % 2 == 1:
                tree.item(item, tags=('oddrow',))
        
        # 添加标签样式
        tree.tag_configure('oddrow', background='#f1f3f4')
        
        # 布局表格和滚动条
        tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        scrollbar_y.pack(side=tk.RIGHT, fill=tk.Y)
        scrollbar_x.pack(side=tk.BOTTOM, fill=tk.X)
    
    def update_results_display(self):
        """更新结果显示"""
        # 清空现有表格中的所有行
        for item in self.results_tree.get_children():
            self.results_tree.delete(item)
        
        # 重置列配置
        self.results_tree['columns'] = []
        
        # 重新设置列标题
        self.results_tree.heading('#0', text='')
        
        # 清空叙述文本
        self.results_narrative.delete(1.0, tk.END)
        
        if self.result_type_var.get() == 'design_flood':
            self.display_design_flood_results()
            self.update_design_flood_narrative()
        elif self.result_type_var.get() == 'flood_level':
            self.display_flood_level_results()
            self.update_flood_level_narrative()
        else:
            self.display_backwater_analysis_results()
            self.update_backwater_analysis_narrative()
    
    def update_design_flood_narrative(self):
        """更新设计洪水计算结果叙述"""
        if not self.design_flood_data['design_results']:
            self.results_narrative.insert(tk.END, "暂无设计洪水计算结果，请先进行计算！")
            return
        
        # 构建详细叙述
        narrative = "# 设计洪水计算结果详细叙述\n\n"
        narrative += "## 一、基本参数\n"
        basic_params = self.design_flood_data.get('basic_params', {})
        narrative += f"- 洪水类型：{basic_params.get('flood_type_name', '未知')}\n"
        narrative += f"- 流域面积：{basic_params.get('area', 0)} km²\n"
        narrative += f"- 24h点暴雨均值：{basic_params.get('pd24', 0)} mm\n"
        narrative += f"- 点面折减系数η：{basic_params.get('eta', 0)}\n"
        narrative += f"- 地理参数C：{basic_params.get('c', 0)}\n"
        narrative += f"- 指数n：{basic_params.get('n_exp', 0)}\n"
        narrative += f"- 洪峰流量变差系数Cv_q：{basic_params.get('cv_q', 0)}\n"
        narrative += f"- 24小时洪量变差系数Cv_w24：{basic_params.get('cv_w24', 0)}\n\n"
        
        narrative += "## 二、中间计算结果\n"
        intermediate_results = self.design_flood_data.get('intermediate_results', {})
        narrative += f"- 面暴雨均值Pd,0：{intermediate_results.get('pd0', 0):.2f} mm\n"
        narrative += f"- 多年平均洪峰流量Qm0：{intermediate_results.get('qm0', 0):.2f} m³/s\n"
        narrative += f"- 24小时洪量W24,0：{intermediate_results.get('w240', 0):.2f} 万m³\n\n"
        
        narrative += "## 三、设计洪水计算结果\n"
        design_results = self.design_flood_data.get('design_results', [])
        for result in design_results:
            narrative += f"### 重现期 {result['return_period']:.1f} 年（频率 {result['frequency']:.1f}%）\n"
            narrative += f"- 离均系数Φ：{result['phi']:.2f}\n"
            narrative += f"- 模比系数Kp：{result['kp']:.4f}\n"
            narrative += f"- 设计流量Qp：{result['qp']:.1f} m³/s\n"
            narrative += f"- 24小时设计洪量W24p：{result['w24p']:.1f} 万m³\n\n"
        
        narrative += "## 四、计算依据\n"
        narrative += "计算严格遵循《水利水电工程设计洪水计算规范》(SL 44-2006)和《洪水影响评价技术导则》(SLT808-2025)的要求，\n"
        narrative += "结合云南昭通地区的水文特性和地理条件，采用适合本地区的计算参数和方法。\n\n"
        
        narrative += "## 五、结论与建议\n"
        narrative += "设计洪水计算结果合理可靠，可作为防洪工程设计的依据。\n"
        narrative += "建议根据设计洪水计算结果进行防洪工程设计，并结合实际地形条件进行洪水风险评估。\n"
        
        self.results_narrative.insert(tk.END, narrative)
    
    def update_flood_level_narrative(self):
        """更新洪水位计算结果叙述"""
        if not self.flood_level_data['results']:
            self.results_narrative.insert(tk.END, "暂无洪水位计算结果，请先进行计算！")
            return
        
        # 构建详细叙述
        narrative = "# 洪水位计算结果详细叙述\n\n"
        narrative += "## 一、基本参数\n"
        params = self.flood_level_data.get('params', {})
        section_type = params.get('section_type', 'rectangle')
        narrative += f"- 断面类型：{'矩形' if section_type == 'rectangle' else '梯形'}\n"
        narrative += f"- 河底高程：{params.get('river_bottom_elevation', 0)} m\n"
        if section_type == 'rectangle':
            narrative += f"- 河宽B：{params.get('b', 0)} m\n"
        else:
            narrative += f"- 河宽B：{params.get('b', 0)} m\n"
            narrative += f"- 边坡系数m：{params.get('m', 0)}\n"
        narrative += f"- 糙率n：{params.get('n', 0)}\n"
        narrative += f"- 比降i：{params.get('i', 0)}\n\n"
        
        narrative += "## 二、计算结果\n"
        results = self.flood_level_data.get('results', [])
        for result in results:
            narrative += f"### 重现期 {result['return_period']:.1f} 年（频率 {result['frequency']:.1f}%）\n"
            narrative += f"- 设计流量Q：{result['q']:.1f} m³/s\n"
            narrative += f"- 计算水深：{result['water_depth']:.3f} m\n"
            narrative += f"- 洪水位高程：{result['flood_elevation']:.3f} m\n"
            narrative += f"- 与河岸距离：{result['distance']:.3f} m\n"
            narrative += f"- 实际过流能力：{result['calculated_q']:.1f} m³/s\n"
            narrative += f"- 流量验证：{'✅ 满足' if not result['is_overflow'] else '⚠️  不满足'}\n\n"
        
        narrative += "## 三、计算依据\n"
        narrative += "采用曼宁公式进行洪水位计算，公式为：\n"
        narrative += "V = (1/n) * R^(2/3) * i^(1/2)\n"
        narrative += "Q = V * A\n"
        narrative += "其中：V-平均流速，n-糙率，R-水力半径，i-比降，Q-流量，A-过水断面面积\n\n"
        
        narrative += "## 四、结论与建议\n"
        narrative += "洪水位计算结果合理，可作为防洪工程设计和洪水风险评估的依据。\n"
        narrative += "建议结合实际地形条件和防护要求，合理确定防洪标准和工程措施。\n"
        
        self.results_narrative.insert(tk.END, narrative)
    
    def update_backwater_analysis_narrative(self):
        """更新壅水分析计算结果叙述"""
        if not self.backwater_analysis_data['results']:
            self.results_narrative.insert(tk.END, "暂无壅水分析计算结果，请先进行计算！")
            return
        
        # 构建详细叙述
        narrative = "# 壅水分析计算结果详细叙述\n\n"
        narrative += "## 一、基本参数\n"
        params = self.backwater_analysis_data.get('params', {})
        narrative += f"- 河流类型：{params.get('river_type', '未知')}\n"
        narrative += f"- 设计流量Qp：{params.get('qp', 0)} m³/s\n"
        narrative += f"- 设计流速Vp：{params.get('vp', 0)} m/s\n"
        narrative += f"- 实际过水断面面积：{params.get('omega_actual', 0)} m²\n"
        narrative += f"- 水流交角α：{params.get('alpha', 0)}°\n"
        narrative += f"- 土质类型：{params.get('soil_type', '未知')}\n"
        narrative += f"- 断面流速：{params.get('v', 0)} m/s\n"
        narrative += f"- 天然坡度i0：{params.get('i0', 0)}\n\n"
        
        narrative += "## 二、计算结果\n"
        results = self.backwater_analysis_data.get('results', [])
        for result in results:
            narrative += f"### 计算结果\n"
            narrative += f"- 流量比例：{result['flow_ratio']:.1f}%\n"
            narrative += f"- η系数：{result['eta_coefficient']:.3f}\n"
            narrative += f"- 设计过水断面面积：{result['omega_design']:.2f} m²\n"
            narrative += f"- 冲刷系数：{result['scour_coefficient']:.3f}\n"
            narrative += f"- 桥下流速：{result['bridge_velocity']:.3f} m/s\n"
            narrative += f"- 最大壅水高度：{result['max_backwater_height']:.4f} m\n"
            narrative += f"- 壅水曲线长度：{result['backwater_curve_length']:.1f} m\n\n"
        
        narrative += "## 三、计算依据\n"
        narrative += "壅水分析计算严格按照《水力计算手册》和相关规范进行，\n"
        narrative += "考虑了桥梁对水流的阻碍作用和局部冲刷影响。\n\n"
        
        narrative += "## 四、结论与建议\n"
        narrative += "壅水分析结果表明，桥梁建设对水流的阻碍作用在允许范围内。\n"
        narrative += "建议根据计算结果合理确定桥梁孔径和防护措施，以减少对水流的影响。\n"
        
        self.results_narrative.insert(tk.END, narrative)
    
    def export_results_as_word(self):
        """导出结果为Word文件"""
        try:
            # 确保output/results目录存在
            import os
            os.makedirs('output/results', exist_ok=True)
            
            file_path = filedialog.asksaveasfilename(
                defaultextension=".docx",
                filetypes=[("Word文件", "*.docx")],
                initialdir="output/results"
            )
            if not file_path:
                return
            
            # 导入报告生成模块
            from utils import generate_report
            
            if self.result_type_var.get() == 'design_flood':
                success, message = generate_report('design_flood', self.design_flood_data, file_path)
            elif self.result_type_var.get() == 'flood_level':
                success, message = generate_report('flood_level', self.flood_level_data, file_path)
            else:
                success, message = generate_report('backwater_analysis', self.backwater_analysis_data, file_path)
            
            if success:
                messagebox.showinfo("导出成功", message)
            else:
                messagebox.showerror("导出错误", message)
        except Exception as e:
            messagebox.showerror("导出错误", f"导出过程中发生错误：{e}")
    
    def display_design_flood_results(self):
        """显示设计洪水计算结果"""
        if not self.design_flood_data['design_results']:
            self.results_tree.insert('', tk.END, values=["暂无设计洪水计算结果，请先进行计算！"])
            return
        
        # 设置表格列
        columns = ['frequency', 'return_period', 'phi', 'kp', 'qp', 'w24p']
        column_names = ['频率(%)', '重现期(年)', '离均系数Φ', '模比系数Kp', '设计流量(m³/s)', 'W24h (万m³)']
        self.results_tree['columns'] = columns
        
        for col, name in zip(columns, column_names):
            self.results_tree.heading(col, text=name)
            self.results_tree.column(col, width=100, anchor=tk.CENTER)
        
        # 添加数据
        for result in self.design_flood_data['design_results']:
            self.results_tree.insert('', tk.END, values=(
                f"{result['frequency']:.1f}",
                f"{result['return_period']:.1f}",
                f"{result['phi']:.2f}",
                f"{result['kp']:.4f}",
                f"{result['qp']:.1f}",
                f"{result['w24p']:.1f}"
            ))
    
    def display_flood_level_results(self):
        """显示洪水位计算结果"""
        if not self.flood_level_data['results']:
            self.results_tree.insert('', tk.END, values=["暂无洪水位计算结果，请先进行计算！"])
            return
        
        # 设置表格列
        columns = ['frequency', 'return_period', 'q', 'water_depth', 'flood_elevation', 'distance', 'calculated_q', 'is_overflow']
        column_names = ['设计频率(%)', '重现期(年)', '设计流量(m³/s)', '计算水深(m)', '洪水位高程(m)', '与河岸距离(m)', '实际过流能力(m³/s)', '流量验证']
        self.results_tree['columns'] = columns
        
        for col, name in zip(columns, column_names):
            self.results_tree.heading(col, text=name)
            self.results_tree.column(col, width=100, anchor=tk.CENTER)
        
        # 添加数据
        for result in self.flood_level_data['results']:
            frequency = f"{result['frequency']:.1f}" if result['frequency'] is not None else "-"
            return_period = f"{result['return_period']:.1f}" if result['return_period'] is not None else "-"
            flow_verification = "✅ 满足" if not result['is_overflow'] else "⚠️  不满足"
            self.results_tree.insert('', tk.END, values=(
                frequency,
                return_period,
                f"{result['q']:.1f}",
                f"{result['water_depth']:.3f}",
                f"{result['flood_elevation']:.3f}",
                f"{result['distance']:.3f}",
                f"{result['calculated_q']:.1f}",
                flow_verification
            ))
    
    def display_backwater_analysis_results(self):
        """显示壅水分析计算结果"""
        if not self.backwater_analysis_data['results']:
            self.results_tree.insert('', tk.END, values=["暂无壅水分析计算结果，请先进行计算！"])
            return
        
        # 设置表格列
        columns = ['river_type', 'flow_ratio', 'qp', 'vp', 'omega_actual', 'alpha', 'soil_type', 'v', 'i0', 'eta_coefficient', 'omega_design', 'scour_coefficient', 'bridge_velocity', 'max_backwater_height', 'backwater_curve_length']
        column_names = ['河流类型', '流量比例(%)', '设计流量(m³/s)', '设计流速(m/s)', '实际过水断面面积(m²)', '水流交角(°)', '土质类型', '断面流速(m/s)', '天然坡度', 'η系数', '设计过水断面面积(m²)', '冲刷系数', '桥下流速(m/s)', '最大壅水高度(m)', '壅水曲线长度(m)']
        self.results_tree['columns'] = columns
        
        for col, name in zip(columns, column_names):
            self.results_tree.heading(col, text=name)
            self.results_tree.column(col, width=120, anchor=tk.CENTER)
        
        # 添加数据
        for result in self.backwater_analysis_data['results']:
            # 处理土质类型，只显示核心类型
            soil_type_display = result['soil_type']
            if "松软土" in result['soil_type']:
                soil_type_display = "松软土"
            elif "中等土" in result['soil_type']:
                soil_type_display = "中等土"
            elif "密实土" in result['soil_type']:
                soil_type_display = "密实土"
                
            self.results_tree.insert('', tk.END, values=(
                result['river_type'],
                f"{result['flow_ratio']:.1f}",
                f"{result['qp']:.2f}",
                f"{result['vp']:.3f}",
                f"{result['omega_actual']:.2f}",
                f"{result['alpha']:.1f}",
                soil_type_display,
                f"{result['v']:.3f}",
                f"{result['i0']:.6f}",
                f"{result['eta_coefficient']:.3f}",
                f"{result['omega_design']:.2f}",
                f"{result['scour_coefficient']:.3f}",
                f"{result['bridge_velocity']:.3f}",
                f"{result['max_backwater_height']:.4f}",
                f"{result['backwater_curve_length']:.1f}"
            ))
    
    def export_results(self):
        """导出结果为Excel文件"""
        try:
            # 确保output/results目录存在
            import os
            os.makedirs('output/results', exist_ok=True)
            
            file_path = filedialog.asksaveasfilename(
                defaultextension=".xlsx",
                filetypes=[("Excel文件", "*.xlsx"), ("CSV文件", "*.csv")],
                initialdir="output/results"
            )
            if not file_path:
                return
            
            if self.result_type_var.get() == 'design_flood':
                self.export_design_flood_results(file_path)
            elif self.result_type_var.get() == 'flood_level':
                self.export_flood_level_results(file_path)
            else:
                self.export_backwater_analysis_results(file_path)
            
            messagebox.showinfo("导出成功", f"结果已成功导出到 {file_path}！")
        except Exception as e:
            messagebox.showerror("导出错误", f"导出过程中发生错误：{e}")
    
    def export_design_flood_results(self, file_path):
        """导出设计洪水计算结果"""
        # 创建Excel writer对象，支持多工作表
        if file_path.endswith('.xlsx'):
            writer = pd.ExcelWriter(file_path, engine='xlsxwriter')
            
            # 1. 导出计算结果工作表
            df = pd.DataFrame(self.design_flood_data['design_results'])
            
            # 重命名列
            df.rename(columns={
                'frequency': '频率(%)',
                'return_period': '重现期(年)',
                'phi': '离均系数Φ',
                'kp': '模比系数Kp',
                'qp': '设计流量(m³/s)',
                'w24p': 'W24h (万m³)'
            }, inplace=True)
            
            df.to_excel(writer, sheet_name='计算结果', index=False)
            
            # 2. 导出计算分析过程工作表
            basic_params = self.design_flood_data['basic_params']
            intermediate_results = self.design_flood_data['intermediate_results']
            
            # 创建分析过程数据
            analysis_data = {
                '分析项目': [
                    '流域面积',
                    '24h点暴雨均值',
                    '点面折减系数η',
                    '面暴雨均值Pd,0',
                    '地理参数C',
                    '指数n',
                    '多年平均洪峰流量Qm0',
                    '24小时平均洪水量W24,0',
                    '洪峰流量变差系数Cv_q',
                    '24小时洪量变差系数Cv_w24',
                    '洪峰流量偏态系数Cs_q',
                    '24小时洪量偏态系数Cs_w24'
                ],
                '数值': [
                    f"{basic_params['area']} km²",
                    f"{basic_params['pd24']} mm",
                    f"{basic_params['eta']}",
                    f"{intermediate_results['pd0']:.1f} mm",
                    f"{basic_params['c']}",
                    f"{basic_params['n_exp']}",
                    f"{intermediate_results['qm0']:.1f} m³/s",
                    f"{intermediate_results['w240']:.1f} 万m³",
                    f"{basic_params['cv_q']}",
                    f"{basic_params['cv_w24']}",
                    f"{basic_params['cs_q']}",
                    f"{basic_params['cs_w24']}"
                ],
                '计算公式': [
                    '直接输入',
                    '直接输入',
                    '直接输入',
                    'Pd,0 = η × pd24',
                    '直接输入',
                    '直接输入',
                    'Qm0 = C × Pd,0 × 面积^n',
                    'W24,0 = a × Qm0^α',
                    '直接输入',
                    '直接输入',
                    'Cs_q = 4.0 × Cv_q',
                    'Cs_w24 = 3.5 × Cv_w24'
                ]
            }
            
            analysis_df = pd.DataFrame(analysis_data)
            analysis_df.to_excel(writer, sheet_name='计算分析过程', index=False)
            
            # 3. 导出计算说明工作表
            explanation_data = {
                '说明项': [
                    '计算方法',
                    '暴雨分区',
                    '洪水类型',
                    '计算依据',
                    '计算精度'
                ],
                '内容': [
                    '采用云南省昭通市地区洪水计算公式',
                    '滇东北暴雨区',
                    f"{basic_params['flood_type_name']}",
                    'SL 44-2006 水利水电工程设计洪水计算规范',
                    '结果保留一位小数'
                ]
            }
            
            explanation_df = pd.DataFrame(explanation_data)
            explanation_df.to_excel(writer, sheet_name='计算说明', index=False)
            
            # 保存Excel文件
            writer.close()
        else:
            # 导出为CSV文件，只包含计算结果
            df = pd.DataFrame(self.design_flood_data['design_results'])
            
            # 重命名列
            df.rename(columns={
                'frequency': '频率(%)',
                'return_period': '重现期(年)',
                'phi': '离均系数Φ',
                'kp': '模比系数Kp',
                'qp': '设计流量(m³/s)',
                'w24p': 'W24h (万m³)'
            }, inplace=True)
            
            df.to_csv(file_path, index=False, encoding='utf-8-sig')
    
    def export_flood_level_results(self, file_path):
        """导出洪水位计算结果"""
        # 创建Excel writer对象，支持多工作表
        if file_path.endswith('.xlsx'):
            writer = pd.ExcelWriter(file_path, engine='xlsxwriter')
            
            # 1. 导出计算结果工作表
            df = pd.DataFrame(self.flood_level_data['results'])
            
            # 添加流量验证列
            df['流量验证'] = df['is_overflow'].apply(lambda x: "✅ 满足" if not x else "⚠️  不满足")
            
            # 重命名列
            df.rename(columns={
                'q': '设计流量(m³/s)',
                'water_depth': '计算水深(m)',
                'flood_elevation': '洪水位高程(m)',
                'distance': '与河岸距离(m)',
                'calculated_q': '实际过流能力(m³/s)'
            }, inplace=True)
            
            # 删除不需要的列
            df.drop(['is_overflow'], axis=1, inplace=True)
            
            df.to_excel(writer, sheet_name='计算结果', index=False)
            
            # 2. 导出计算分析过程工作表
            params = self.flood_level_data['params']
            
            # 创建分析过程数据
            analysis_data = {
                '分析项目': [
                    '断面类型',
                    '河道宽度',
                    '边坡系数m',
                    '河床高程',
                    '河岸高程',
                    '曼宁糙率n',
                    '水面比降S'
                ],
                '数值': [
                    '矩形' if params['section_type'] == 'rectangle' else '梯形',
                    f"{params['b']} m",
                    f"{params['m']}" if params['section_type'] == 'trapezoid' else '-',
                    f"{params['bed_elevation']} m",
                    f"{params['bank_elevation']} m",
                    f"{params['n']}",
                    f"{params['s']}"
                ],
                '计算公式': [
                    '直接输入',
                    '直接输入',
                    '直接输入（仅梯形断面）',
                    '直接输入',
                    '直接输入',
                    '直接输入',
                    '直接输入'
                ]
            }
            
            analysis_df = pd.DataFrame(analysis_data)
            analysis_df.to_excel(writer, sheet_name='计算分析过程', index=False)
            
            # 3. 导出计算说明工作表
            explanation_data = {
                '说明项': [
                    '计算方法',
                    '断面类型',
                    '计算依据',
                    '计算精度',
                    '流量验证说明'
                ],
                '内容': [
                    '采用谢才公式结合二分法求解',
                    '矩形' if params['section_type'] == 'rectangle' else '梯形',
                    'SL 171-2005 水利水电工程设计洪水计算规范',
                    '结果保留三位小数',
                    '✅ 满足：实际过流能力≥设计流量；⚠️ 不满足：实际过流能力＜设计流量'
                ]
            }
            
            explanation_df = pd.DataFrame(explanation_data)
            explanation_df.to_excel(writer, sheet_name='计算说明', index=False)
            
            # 保存Excel文件
            writer.close()
        else:
            # 导出为CSV文件，只包含计算结果
            df = pd.DataFrame(self.flood_level_data['results'])
            
            # 添加流量验证列
            df['流量验证'] = df['is_overflow'].apply(lambda x: "✅ 满足" if not x else "⚠️  不满足")
            
            # 重命名列
            df.rename(columns={
                'q': '设计流量(m³/s)',
                'water_depth': '计算水深(m)',
                'flood_elevation': '洪水位高程(m)',
                'distance': '与河岸距离(m)',
                'calculated_q': '实际过流能力(m³/s)'
            }, inplace=True)
            
            # 删除不需要的列
            df.drop(['is_overflow'], axis=1, inplace=True)
            
            df.to_csv(file_path, index=False, encoding='utf-8-sig')
    
    def export_backwater_analysis_results(self, file_path):
        """导出壅水分析计算结果"""
        # 创建Excel writer对象，支持多工作表
        if file_path.endswith('.xlsx'):
            writer = pd.ExcelWriter(file_path, engine='xlsxwriter')
            
            # 1. 导出计算结果工作表
            df = pd.DataFrame(self.backwater_analysis_data['results'])
            
            # 重命名列
            df.rename(columns={
                'river_type': '河流类型',
                'flow_ratio': '流量比例(%)',
                'qp': '设计流量(m³/s)',
                'vp': '设计流速(m/s)',
                'omega_actual': '实际过水断面面积(m²)',
                'alpha': '水流交角(°)',
                'soil_type': '土质类型',
                'v': '断面流速(m/s)',
                'i0': '天然坡度',
                'eta_coefficient': 'η系数',
                'omega_design': '设计过水断面面积(m²)',
                'scour_coefficient': '冲刷系数',
                'bridge_velocity': '桥下流速(m/s)',
                'max_backwater_height': '最大壅水高度(m)',
                'backwater_curve_length': '壅水曲线长度(m)'
            }, inplace=True)
            
            df.to_excel(writer, sheet_name='计算结果', index=False)
            
            # 2. 导出计算分析过程工作表
            params = self.backwater_analysis_data['params']
            result = self.backwater_analysis_data['results'][0]
            
            # 创建分析过程数据
            analysis_data = {
                '分析项目': [
                    '河流类型',
                    '河滩路堤阻挡流量比例',
                    '设计流量Qp',
                    '设计流速Vp',
                    '桥下实际过水断面面积ω_actual',
                    '桥下设计过水断面面积ω_design',
                    '水流方向与桥梁轴线之法线间的交角α',
                    '土质类型',
                    '断面平均流速V',
                    '河段天然水面坡度I0',
                    '冲刷系数P',
                    'η系数',
                    '桥下平均流速VM',
                    '桥前最大壅水高度ΔZ',
                    '壅水曲线长度L'
                ],
                '数值': [
                    f"{params['river_type']}",
                    f"{params['flow_ratio']} %",
                    f"{params['qp']} m³/s",
                    f"{params['vp']} m/s",
                    f"{params['omega_actual']} m²",
                    f"{result['omega_design']:.2f} m²",
                    f"{params['alpha']} °",
                    f"{params['soil_type']}",
                    f"{params['v']} m/s",
                    f"{params['i0']}",
                    f"{result['scour_coefficient']:.3f}",
                    f"{result['eta_coefficient']:.3f}",
                    f"{result['bridge_velocity']:.3f} m/s",
                    f"{result['max_backwater_height']:.4f} m",
                    f"{result['backwater_curve_length']:.1f} m"
                ],
                '计算公式': [
                    '直接输入',
                    '直接输入',
                    '直接输入',
                    '直接输入',
                    '直接输入',
                    'ω_design = Q_P / (V_P cosα)',
                    '直接输入',
                    '直接输入',
                    '直接输入',
                    '直接输入',
                    'P = ω_design / ω_actual',
                    '根据河流类型和流量比例确定',
                    '根据土质类型计算',
                    'ΔZ = η(VM² - V²)',
                    'L = 2ΔZ / I₀'
                ]
            }
            
            analysis_df = pd.DataFrame(analysis_data)
            analysis_df.to_excel(writer, sheet_name='计算分析过程', index=False)
            
            # 3. 导出计算说明工作表
            explanation_data = {
                '说明项': [
                    '计算方法',
                    '计算依据',
                    '计算精度',
                    '主要参数说明'
                ],
                '内容': [
                    '采用壅水分析计算公式（A.2.3-1至A.2.3-4）',
                    '公路桥涵水文勘测设计规范（JTG 3362-2020）',
                    '壅水高度保留四位小数，其余结果保留一至三位小数',
                    'η系数：根据河流特征和河滩路堤阻挡流量比例查表；冲刷系数P：桥下设计过水断面面积与实际过水断面面积之比；壅水曲线长度：表示壅水影响的范围'
                ]
            }
            
            explanation_df = pd.DataFrame(explanation_data)
            explanation_df.to_excel(writer, sheet_name='计算说明', index=False)
            
            # 保存Excel文件
            writer.close()
        else:
            # 导出为CSV文件，只包含计算结果
            df = pd.DataFrame(self.backwater_analysis_data['results'])
            
            # 重命名列
            df.rename(columns={
                'river_feature': '河流特征',
                'flow_ratio': '流量比例(%)',
                'vp': '设计流速(m/s)',
                'soil_type': '土质类型',
                'p': '冲刷系数',
                'eta': 'η系数',
                'vm': '桥下流速(m/s)',
                'v': '断面流速(m/s)',
                'delta_zm': '最大壅水高度(m)',
                'i0': '天然坡度',
                'ly': '壅水曲线长度(m)'
            }, inplace=True)
            
            df.to_csv(file_path, index=False, encoding='utf-8-sig')
    
    def import_flood_level_to_backwater(self):
        """导入洪水位计算结果到壅水分析计算"""
        try:
            # 检查是否有洪水位计算结果
            if not self.flood_level_data['results']:
                messagebox.showwarning("警告", "请先进行洪水位计算！")
                return
            
            # 获取洪水位计算参数
            flood_params = self.flood_level_data.get('params', {})
            if not flood_params:
                messagebox.showwarning("警告", "洪水位计算结果中没有可用的参数！")
                return
            
            # 从洪水位计算结果中获取数据
            q_list = [result['q'] for result in self.flood_level_data['results']]
            flood_elevations = [result['flood_elevation'] for result in self.flood_level_data['results']]
            
            # 计算平均流速（使用最大流量）
            max_q = max(q_list)
            
            # 从洪水位计算参数中获取断面参数
            b = flood_params.get('b', 0)
            m = flood_params.get('m', 0)
            bed_elevation = flood_params.get('bed_elevation', 0)
            s = flood_params.get('s', 0)  # 水面比降作为河段天然水面坡度
            
            # 计算过水断面面积（使用最大洪水位）
            max_flood_elevation = max(flood_elevations)
            water_depth = max_flood_elevation - bed_elevation
            
            if flood_params.get('section_type') == 'rectangle':
                area = b * water_depth
            else:  # trapezoid
                area = (b + m * water_depth) * water_depth
            
            # 计算平均流速
            avg_v = max_q / area if area > 0 else 0
            
            # 设置到壅水分析计算的输入框
            self.i0_entry.delete(0, tk.END)
            self.i0_entry.insert(0, f"{s:.4f}")
            
            self.v_entry.delete(0, tk.END)
            self.v_entry.insert(0, f"{avg_v:.2f}")
            
            # 设计流速Vp不应与断面平均流速相同，保持原有值
            # 计算并设置过水断面面积
            self.omega_g_entry.delete(0, tk.END)
            self.omega_g_entry.insert(0, f"{area:.2f}")
            
            # 桥下设计过水断面面积需要通过设计流量和设计流速重新计算
            # 保持原有值，等待用户计算或选择设计频率自动更新
            messagebox.showinfo("提示", "洪水位计算结果已导入部分参数！请使用'计算桥下设计过水断面面积'功能或选择设计频率自动更新完整参数。")
            
            messagebox.showinfo("成功", "洪水位计算结果已导入到壅水分析计算！")
        except Exception as e:
            messagebox.showerror("错误", f"导入洪水位计算结果失败：{e}")
    
    def import_design_flood_to_backwater(self):
        """导入设计洪水计算结果到壅水分析计算"""
        try:
            # 检查是否有设计洪水计算结果
            if not self.design_flood_data['design_results']:
                messagebox.showwarning("警告", "请先进行设计洪水计算！")
                return
            
            messagebox.showinfo("提示", "设计洪水计算结果已关联到壅水分析计算！请选择设计频率自动获取相关参数。")
            # 自动更新参数
            self.update_backwater_params_by_frequency()
        except Exception as e:
            messagebox.showerror("错误", f"导入设计洪水计算结果失败：{e}")
    
    def import_wld_to_backwater(self):
        """导入水位流量关系图数据到壅水分析计算"""
        try:
            # 检查是否有水位流量关系图数据
            if not self.water_level_discharge_data['discharges'] or not self.water_level_discharge_data['water_levels']:
                messagebox.showwarning("警告", "请先在水位流量关系图中输入数据！")
                return
            
            messagebox.showinfo("提示", "水位流量关系图数据已关联到壅水分析计算！")
        except Exception as e:
            messagebox.showerror("错误", f"导入水位流量关系图数据失败：{e}")
    
    def update_backwater_params_by_frequency(self):
        """根据设计频率更新壅水分析计算参数，建立全面的数据关联"""
        try:
            # 获取选择的设计频率
            if not hasattr(self, 'backwater_frequency_var'):
                return
            
            frequency_str = self.backwater_frequency_var.get()
            if not frequency_str:
                return
            
            frequency = float(frequency_str)
            return_period = 100 / frequency
            
            # -------------------- 1. 从设计洪水计算结果中获取数据 --------------------
            design_qp = None
            design_w24p = None
            if hasattr(self, 'design_flood_data') and self.design_flood_data.get('design_results'):
                for result in self.design_flood_data['design_results']:
                    if abs(result['frequency'] - frequency) < 0.01:
                        design_qp = result['qp']
                        design_w24p = result['w24p']
                        break
            
            # -------------------- 2. 从洪水位计算结果中获取数据 --------------------
            flood_level_area = None
            flood_level_v = None
            flood_level_params = None
            if hasattr(self, 'flood_level_data') and self.flood_level_data.get('results'):
                for result in self.flood_level_data['results']:
                    if result['frequency'] is not None and abs(result['frequency'] - frequency) < 0.01:
                        # 保存洪水位计算参数
                        flood_level_params = self.flood_level_data['params']
                        water_depth = result['water_depth']
                        
                        # 计算过水断面面积
                        if flood_level_params['section_type'] == 'rectangle':
                            flood_level_area = flood_level_params['b'] * water_depth
                        else:  # trapezoid
                            flood_level_area = (flood_level_params['b'] + flood_level_params['m'] * water_depth) * water_depth
                        
                        # 计算断面平均流速V = Q / A
                        if design_qp is None:
                            design_qp = result['q']
                        
                        flood_level_v = design_qp / flood_level_area if flood_level_area > 0 else 0
                        break
            
            # -------------------- 3. 从水位流量关系图数据中获取数据 --------------------
            wld_discharge = None
            wld_water_level = None
            if hasattr(self, 'water_level_discharge_data') and self.water_level_discharge_data.get('discharges'):
                # 根据频率或重现期查找匹配的数据
                discharges = self.water_level_discharge_data['discharges']
                water_levels = self.water_level_discharge_data['water_levels']
                return_periods = self.water_level_discharge_data['return_periods']
                
                # 优先按重现期匹配
                if return_periods:
                    for i, rp in enumerate(return_periods):
                        try:
                            rp_value = float(rp)
                            if abs(rp_value - return_period) < 0.1:
                                wld_discharge = discharges[i]
                                wld_water_level = water_levels[i]
                                break
                        except:
                            continue
                # 如果没有重现期数据，按流量大小估计
                elif discharges and design_qp:
                    # 找到最接近设计流量的流量值
                    closest_index = min(range(len(discharges)), key=lambda i: abs(discharges[i] - design_qp))
                    wld_discharge = discharges[closest_index]
                    wld_water_level = water_levels[closest_index]
            
            # -------------------- 4. 更新壅水分析计算参数 --------------------
            
            # 更新可用频率列表
            if hasattr(self, 'design_flood_data') and self.design_flood_data.get('design_results') and hasattr(self, 'frequency_combobox'):
                available_frequencies = [str(result['frequency']) for result in self.design_flood_data['design_results']]
                self.frequency_combobox['values'] = available_frequencies
            
            # 4.1 设置设计流速Vp
            if hasattr(self, 'vp_entry'):
                # 尝试自动计算设计流速Vp
                auto_vp = None
                
                # 方法1：根据洪水位计算结果和曼宁公式反推
                if flood_level_params and flood_level_area:
                    try:
                        # 曼宁公式：V = (1/n) * R^(2/3) * S^(1/2)
                        # 水力半径R = A / P
                        water_depth = result['water_depth']
                        if flood_level_params['section_type'] == 'rectangle':
                            p = flood_level_params['b'] + 2 * water_depth  # 湿周
                        else:  # trapezoid
                            p = flood_level_params['b'] + 2 * water_depth * np.sqrt(1 + flood_level_params['m'] ** 2)
                        r = flood_level_area / p if p > 0 else 0
                        auto_vp = (1 / flood_level_params['n']) * (r ** (2/3)) * (flood_level_params['s'] ** 0.5)
                    except:
                        pass
                
                # 方法2：使用洪水位计算的断面平均流速作为参考
                if auto_vp is None and flood_level_v:
                    auto_vp = flood_level_v * 1.2  # 设计流速通常比断面平均流速大
                
                # 方法3：如果有水位流量关系图数据，使用其计算
                if auto_vp is None and wld_discharge and wld_water_level and flood_level_params:
                    try:
                        # 根据水位计算过水断面面积
                        water_depth = wld_water_level - flood_level_params['bed_elevation']
                        if water_depth > 0:
                            if flood_level_params['section_type'] == 'rectangle':
                                area = flood_level_params['b'] * water_depth
                            else:  # trapezoid
                                area = (flood_level_params['b'] + flood_level_params['m'] * water_depth) * water_depth
                            auto_vp = wld_discharge / area if area > 0 else 0
                    except:
                        pass
                
                # 如果成功计算出自动Vp，更新输入框
                if auto_vp is not None and auto_vp > 0:
                    self.vp_entry.delete(0, tk.END)
                    self.vp_entry.insert(0, f"{auto_vp:.2f}")
            
            # 4.2 设置桥下实际过水断面面积ω_g
            if hasattr(self, 'omega_g_entry'):
                if flood_level_area:
                    self.omega_g_entry.delete(0, tk.END)
                    self.omega_g_entry.insert(0, f"{flood_level_area:.2f}")
                # 否则，尝试从水位流量关系图数据计算
                elif wld_water_level and flood_level_params:
                    try:
                        water_depth = wld_water_level - flood_level_params['bed_elevation']
                        if water_depth > 0:
                            if flood_level_params['section_type'] == 'rectangle':
                                area = flood_level_params['b'] * water_depth
                            else:  # trapezoid
                                area = (flood_level_params['b'] + flood_level_params['m'] * water_depth) * water_depth
                            self.omega_g_entry.delete(0, tk.END)
                            self.omega_g_entry.insert(0, f"{area:.2f}")
                    except:
                        pass
            
            # 4.3 设置断面平均流速V
            if hasattr(self, 'v_entry'):
                if flood_level_v:
                    self.v_entry.delete(0, tk.END)
                    self.v_entry.insert(0, f"{flood_level_v:.2f}")
            
            # 4.4 设置河段天然水面坡度I0
            if hasattr(self, 'i0_entry'):
                # 从洪水位计算结果中获取水面比降
                if flood_level_params:
                    self.i0_entry.delete(0, tk.END)
                    self.i0_entry.insert(0, f"{flood_level_params['s']:.6f}")
            
            # -------------------- 5. 自动计算衍生参数 --------------------
            
            # 5.1 计算桥下设计过水断面面积ω_x
            if (hasattr(self, 'vp_entry') and hasattr(self, 'alpha_entry') and 
                hasattr(self, 'omega_x_entry') and design_qp is not None):
                try:
                    vp = float(self.vp_entry.get())
                    alpha = float(self.alpha_entry.get())
                    
                    if vp > 0:
                        omega_x = calculate_omega_x(design_qp, vp, alpha)
                        if omega_x > 0:
                            self.omega_x_entry.delete(0, tk.END)
                            self.omega_x_entry.insert(0, f"{omega_x:.2f}")
                except Exception as ex:
                    print(f"计算桥下设计过水断面面积时发生警告：{ex}")
            
            # 5.2 计算桥下平均流速VM
            self.calculate_vm()
            
        except Exception as e:
            # 只在调试时显示错误信息，避免影响用户体验
            print(f"根据设计频率更新参数时发生警告：{e}")
    
    def calculate_vm(self):
        """根据设计流速Vp、冲刷系数P和土质类型计算桥下平均流速VM"""
        try:
            # 获取设计流速Vp
            is_valid, vp, error_msg = validate_numeric_input(self.vp_entry.get(), min_value=0, field_name="设计流速Vp")
            if not is_valid:
                return
            
            # 获取桥下设计过水断面面积ω_x
            is_valid, omega_x, error_msg = validate_numeric_input(self.omega_x_entry.get(), min_value=0, field_name="桥下设计过水断面面积ω_x")
            if not is_valid:
                return
            
            # 获取桥下实际过水断面面积ω_g
            is_valid, omega_g, error_msg = validate_numeric_input(self.omega_g_entry.get(), min_value=0, field_name="桥下实际过水断面面积ω_g")
            if not is_valid:
                return
            
            # 计算冲刷系数P
            p = calculate_scour_coefficient(omega_x, omega_g)
            
            # 获取土质类型
            soil_type = self.soil_type_var.get()
            # 提取核心土质类型
            soil_type_core = soil_type
            if "松软土" in soil_type:
                soil_type_core = "松软土"
            elif "中等土" in soil_type:
                soil_type_core = "中等土"
            elif "密实土" in soil_type:
                soil_type_core = "密实土"
            
            # 计算桥下平均流速VM
            vm = calculate_underbridge_velocity(vp, p, soil_type_core)
            
            # 设置到输入框
            if hasattr(self, 'vm_entry'):
                self.vm_entry.delete(0, tk.END)
                self.vm_entry.insert(0, f"{vm:.2f}")
        except Exception as e:
            # 如果计算失败，不影响其他功能
            print(f"计算桥下平均流速时发生警告：{e}")
    
    def calculate_omega_x(self, automatic=True):
        """根据设计流量、设计流速和交角计算桥下设计过水断面面积ω_x
        
        Args:
            automatic (bool): 是否为自动计算模式。自动模式下不弹出提示框，仅在手动计算时弹出
        """
        try:
            # 1. 尝试从设计洪水计算结果中获取设计流量（Qp）
            qp = None
            if hasattr(self, 'design_flood_data') and self.design_flood_data.get('design_results'):
                frequency_str = self.backwater_frequency_var.get()
                if frequency_str:
                    frequency = float(frequency_str)
                    for result in self.design_flood_data['design_results']:
                        if abs(result['frequency'] - frequency) < 0.01:
                            qp = result['qp']
                            break
            
            # 2. 如果没有找到且不是自动模式，提示用户
            if qp is None:
                if not automatic:
                    messagebox.showwarning("提示", "未找到设计洪水计算结果，请手动输入设计流量！")
                return
            
            # 3. 获取设计流速Vp（独立参数，不等于设计流量）
            is_valid, vp, error_msg = validate_numeric_input(self.vp_entry.get(), min_value=0, field_name="设计流速Vp")
            if not is_valid:
                if not automatic:
                    messagebox.showerror("输入错误", error_msg)
                return
            
            # 4. 获取水流方向与桥梁轴线之法线间的交角α
            is_valid, alpha, error_msg = validate_numeric_input(self.alpha_entry.get(), min_value=0, field_name="水流方向与桥梁轴线之法线间的交角α")
            if not is_valid:
                if not automatic:
                    messagebox.showerror("输入错误", error_msg)
                return
            
            # 5. 计算桥下设计过水断面面积ω_x = Qp / (Vp * cosα)（根据表A.2.3-3）
            omega_x = calculate_omega_x(qp, vp, alpha)
            
            if omega_x <= 0:
                if not automatic:
                    messagebox.showerror("计算错误", "桥下设计过水断面面积计算结果无效！")
                return
            
            # 6. 设置到输入框
            self.omega_x_entry.delete(0, tk.END)
            self.omega_x_entry.insert(0, f"{omega_x:.2f}")
            
            # 7. 自动计算桥下平均流速VM
            self.calculate_vm()
            
            # 8. 仅在手动计算时显示完成信息
            if not automatic:
                messagebox.showinfo("计算完成", "桥下设计过水断面面积计算完成！")
        except Exception as e:
            if not automatic:
                messagebox.showerror("计算错误", f"计算桥下设计过水断面面积失败：{e}")
    
    def calculate_backwater_analysis(self):
        """执行壅水分析计算"""
        try:
            # 获取输入参数
            river_type = self.river_type_var.get()
            
            # 输入验证
            is_valid, flow_ratio, error_msg = validate_numeric_input(self.flow_ratio_entry.get(), min_value=0, field_name="河滩路堤阻挡流量比例")
            if not is_valid:
                messagebox.showerror("输入错误", error_msg)
                return
            
            is_valid, qp, error_msg = validate_numeric_input(self.qp_entry.get(), min_value=0, field_name="设计流量Qp")
            if not is_valid:
                messagebox.showerror("输入错误", error_msg)
                return
            
            is_valid, vp, error_msg = validate_numeric_input(self.vp_entry.get(), min_value=0, field_name="设计流速Vp")
            if not is_valid:
                messagebox.showerror("输入错误", error_msg)
                return
            
            is_valid, omega_actual, error_msg = validate_numeric_input(self.omega_actual_entry.get(), min_value=0, field_name="桥下实际过水断面面积")
            if not is_valid:
                messagebox.showerror("输入错误", error_msg)
                return
            
            is_valid, alpha, error_msg = validate_numeric_input(self.alpha_entry.get(), field_name="水流方向与桥梁轴线之法线间的交角α")
            if not is_valid:
                messagebox.showerror("输入错误", error_msg)
                return
            
            soil_type = self.soil_type_var.get()
            
            is_valid, v, error_msg = validate_numeric_input(self.v_entry.get(), min_value=0, field_name="断面平均流速V")
            if not is_valid:
                messagebox.showerror("输入错误", error_msg)
                return
            
            is_valid, i0, error_msg = validate_numeric_input(self.i0_entry.get(), min_value=0, field_name="河段天然水面坡度I0")
            if not is_valid:
                messagebox.showerror("输入错误", error_msg)
                return
            
            # 调用业务逻辑进行计算
            params = {
                'river_type': river_type,
                'flow_ratio': flow_ratio,
                'qp': qp,
                'vp': vp,
                'omega_actual': omega_actual,
                'alpha': alpha,
                'soil_type': soil_type,
                'v': v,
                'i0': i0
            }
            
            result = self.flood_service.calculate_backwater_analysis(params)
            
            if not result['success']:
                messagebox.showerror("计算错误", result['message'])
                return
            
            # 保存计算结果
            self.backwater_analysis_data = result['data']
            
            # 更新结果显示
            self.update_backwater_analysis_result_display()
            
            # 更新计算结果标签页显示
            self.update_results_display()
            
            messagebox.showinfo("计算完成", "壅水分析计算已完成！")
        except Exception as e:
            messagebox.showerror("计算错误", f"计算过程中发生错误：{e}")
    
    def update_backwater_analysis_result_display(self):
        """更新壅水分析计算结果显示"""
        # 清除现有内容
        for widget in self.backwater_analysis_result_frame.winfo_children():
            widget.destroy()
        
        # 显示基本参数
        params = self.backwater_analysis_data['params']
        basic_params_frame = ttk.LabelFrame(self.backwater_analysis_result_frame, text="基本参数", padding="5")
        basic_params_frame.pack(fill=tk.X, pady=5)
        
        params_text = f"""
河流类型：{params['river_type']}
河滩路堤阻挡流量比例：{params['flow_ratio']} %
设计流量Qp：{params['qp']} m³/s
设计流速Vp：{params['vp']} m/s
桥下实际过水断面面积：{params['omega_actual']} m²
水流方向与桥梁轴线之法线间的交角α：{params['alpha']} °
土质类型：{params['soil_type']}
断面平均流速V：{params['v']} m/s
河段天然水面坡度I0：{params['i0']}
        """
        ttk.Label(basic_params_frame, text=params_text, justify=tk.LEFT).pack(fill=tk.X)
        
        # 显示计算结果
        result = self.backwater_analysis_data['results'][0]
        result_frame = ttk.LabelFrame(self.backwater_analysis_result_frame, text="计算结果", padding="5")
        result_frame.pack(fill=tk.X, pady=5)
        
        result_text = f"""
壅水系数η：{result['eta_coefficient']:.3f}
桥下设计过水断面面积：{result['omega_design']:.2f} m²
冲刷系数P：{result['scour_coefficient']:.3f}
桥下平均流速VM：{result['bridge_velocity']:.3f} m/s
桥前最大壅水高度ΔZ：{result['max_backwater_height']:.4f} m
壅水曲线长度L：{result['backwater_curve_length']:.1f} m
        """
        ttk.Label(result_frame, text=result_text, justify=tk.LEFT).pack(fill=tk.X)
        
        # 显示计算公式
        formula_frame = ttk.LabelFrame(self.backwater_analysis_result_frame, text="计算公式", padding="5")
        formula_frame.pack(fill=tk.X, pady=5)
        
        formula_text = f"""
1. 壅水系数η：根据河流类型和河滩路堤阻挡流量比例确定
   η = {result['eta_coefficient']:.3f}

2. 桥下设计过水断面面积：ω = Q_P / (V_P cosα)
   ω = {params['qp']:.2f} / ({params['vp']:.2f} × cos{params['alpha']}°) = {result['omega_design']:.2f} m²

3. 冲刷系数：P = ω_design / ω_actual
   P = {result['omega_design']:.2f} / {params['omega_actual']:.2f} = {result['scour_coefficient']:.3f}

4. 桥下平均流速VM：
   土质类型：{params['soil_type']}
   公式：
   {'VM = V_P' if params['soil_type'] == '松软土' else 'VM = V_P × 2P/(P+1)' if params['soil_type'] == '中等土' else 'VM = P × V_P'}
   VM = {params['vp']:.3f} {'× 1' if params['soil_type'] == '松软土' else f'× 2×{result["scour_coefficient"]:.3f}/({result["scour_coefficient"]:.3f}+1)' if params['soil_type'] == '中等土' else f'× {result["scour_coefficient"]:.3f}'} = {result['bridge_velocity']:.3f} m/s

5. 桥前最大壅水高度：ΔZ = η(VM² - V²)
   ΔZ = {result['eta_coefficient']:.3f} × ({result['bridge_velocity']:.3f}² - {params['v']:.3f}²) = {result['max_backwater_height']:.4f} m

6. 壅水曲线长度：L = 2ΔZ / I₀
   L = 2 × {result['max_backwater_height']:.4f} / {params['i0']:.6f} = {result['backwater_curve_length']:.1f} m
        """
        ttk.Label(formula_frame, text=formula_text, justify=tk.LEFT).pack(fill=tk.X)
    
    def validate_float(self, new_value, widget_name):
        """验证是否为有效的浮点数"""
        if new_value == "":
            return True
        try:
            float(new_value)
            return True
        except ValueError:
            return False
    
    def validate_float_positive(self, new_value, widget_name):
        """验证是否为有效的正浮点数，允许输入过程中的中间状态"""
        if new_value == "" or new_value == "0":
            return True
        # 允许输入过程中的中间状态，如"1."、"."等
        if new_value == "." or (new_value.startswith(".") and new_value.count(".") == 1) or (new_value.endswith(".") and new_value.count(".") == 1):
            return True
        # 允许输入负数符号（虽然函数名是positive，但实际验证在完成输入后）
        if new_value.startswith("-"):
            return True
        try:
            value = float(new_value)
            return value > 0
        except ValueError:
            return False
    
    def validate_float_non_negative(self, new_value, widget_name):
        """验证是否为有效的非负浮点数，允许输入过程中的中间状态"""
        if new_value == "" or new_value == "0":
            return True
        # 允许输入过程中的中间状态，如"1."、"."等
        if new_value == "." or (new_value.startswith(".") and new_value.count(".") == 1) or (new_value.endswith(".") and new_value.count(".") == 1):
            return True
        try:
            value = float(new_value)
            return value >= 0
        except ValueError:
            return False
    
    def validate_float_list(self, new_value, widget_name):
        """验证是否为有效的浮点数列表（空格分隔），允许输入过程中的中间状态"""
        if new_value == "":
            return True
        parts = new_value.split()
        if not parts:
            return True
        for part in parts:
            if part == "" or part == ".":
                continue
            # 允许输入过程中的中间状态，如"0."、".5"等
            if part.startswith(".") and part.count(".") == 1:
                continue
            if part.endswith(".") and part.count(".") == 1:
                continue
            # 允许输入过程中的负号
            if part.startswith("-") and len(part) == 1:
                continue
            try:
                float(part)
            except ValueError:
                return False
        return True
    
    def invalid_input(self, widget_name):
        """无效输入时的处理"""
        widget = self.root.nametowidget(widget_name)
        widget.config(foreground='red')
        self.root.after(1000, lambda: widget.config(foreground='black'))
    
    def init_terrain_3d_tab(self):
        """初始化流域地形三维可视化标签页"""
        # 创建主布局框架
        main_frame = ttk.Frame(self.extended_tab11, padding="10")
        main_frame.pack(fill=tk.BOTH, expand=True)
        
        # 使用Grid布局
        main_frame.columnconfigure(0, minsize=350, weight=0)
        main_frame.columnconfigure(1, weight=1)
        main_frame.rowconfigure(0, weight=1)
        
        # 左侧输入面板容器（带滚动条）
        input_container = ttk.Frame(main_frame)
        input_container.grid(row=0, column=0, sticky="nsew", padx=5, pady=5)
        
        # 创建Canvas和滚动条
        canvas = tk.Canvas(input_container, width=350, bg=self.style.configure('.')['background'])
        scrollbar = ttk.Scrollbar(input_container, orient="vertical", command=canvas.yview)
        scrollable_frame = ttk.Frame(canvas)
        
        # 配置Canvas
        scrollable_frame.bind(
            "<Configure>",
            lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
        )
        
        canvas.create_window((0, 0), window=scrollable_frame, anchor="nw", width=350)
        canvas.configure(yscrollcommand=scrollbar.set)
        
        # 布局Canvas和滚动条
        canvas.pack(side="left", fill="both", expand=True)
        scrollbar.pack(side="right", fill="y")
        
        # 左侧输入面板
        input_frame = ttk.LabelFrame(scrollable_frame, text="输入参数", padding="10")
        input_frame.pack(fill=tk.BOTH, expand=True, pady=5)
        
        # 流域基本参数
        ttk.Label(input_frame, text="流域基本参数", font=('SimHei', 10, 'bold')).grid(row=0, column=0, columnspan=2, sticky=tk.W, pady=(10, 5))
        
        ttk.Label(input_frame, text="流域长度（km）：").grid(row=1, column=0, sticky=tk.W, pady=(5, 2))
        self.terrain_length_var = tk.StringVar(value="50")
        ttk.Entry(input_frame, textvariable=self.terrain_length_var, width=20).grid(row=1, column=1, pady=2)
        
        ttk.Label(input_frame, text="流域宽度（km）：").grid(row=2, column=0, sticky=tk.W, pady=5)
        self.terrain_width_var = tk.StringVar(value="30")
        ttk.Entry(input_frame, textvariable=self.terrain_width_var, width=20).grid(row=2, column=1, pady=2)
        
        ttk.Label(input_frame, text="网格分辨率（km）：").grid(row=3, column=0, sticky=tk.W, pady=5)
        self.terrain_resolution_var = tk.StringVar(value="1.0")
        ttk.Entry(input_frame, textvariable=self.terrain_resolution_var, width=20).grid(row=3, column=1, pady=2)
        
        # 地形参数
        ttk.Separator(input_frame, orient=tk.HORIZONTAL).grid(row=4, column=0, columnspan=2, sticky="ew", pady=15)
        
        ttk.Label(input_frame, text="地形参数", font=('SimHei', 10, 'bold')).grid(row=5, column=0, columnspan=2, sticky=tk.W, pady=(10, 5))
        
        ttk.Label(input_frame, text="最低海拔（m）：").grid(row=6, column=0, sticky=tk.W, pady=(5, 2))
        self.terrain_min_elevation_var = tk.StringVar(value="1500")
        ttk.Entry(input_frame, textvariable=self.terrain_min_elevation_var, width=20).grid(row=6, column=1, pady=2)
        
        ttk.Label(input_frame, text="最高海拔（m）：").grid(row=7, column=0, sticky=tk.W, pady=5)
        self.terrain_max_elevation_var = tk.StringVar(value="2500")
        ttk.Entry(input_frame, textvariable=self.terrain_max_elevation_var, width=20).grid(row=7, column=1, pady=2)
        
        ttk.Label(input_frame, text="地形起伏度：").grid(row=8, column=0, sticky=tk.W, pady=5)
        self.terrain_roughness_var = tk.StringVar(value="0.5")
        ttk.Entry(input_frame, textvariable=self.terrain_roughness_var, width=20).grid(row=8, column=1, pady=2)
        
        # 河道参数
        ttk.Separator(input_frame, orient=tk.HORIZONTAL).grid(row=9, column=0, columnspan=2, sticky="ew", pady=15)
        
        ttk.Label(input_frame, text="河道参数", font=('SimHei', 10, 'bold')).grid(row=10, column=0, columnspan=2, sticky=tk.W, pady=(10, 5))
        
        ttk.Label(input_frame, text="河道位置X（km）：").grid(row=11, column=0, sticky=tk.W, pady=(5, 2))
        self.river_x_var = tk.StringVar(value="25")
        ttk.Entry(input_frame, textvariable=self.river_x_var, width=20).grid(row=11, column=1, pady=2)
        
        ttk.Label(input_frame, text="河道位置Y（km）：").grid(row=12, column=0, sticky=tk.W, pady=5)
        self.river_y_var = tk.StringVar(value="15")
        ttk.Entry(input_frame, textvariable=self.river_y_var, width=20).grid(row=12, column=1, pady=2)
        
        ttk.Label(input_frame, text="河道宽度（km）：").grid(row=13, column=0, sticky=tk.W, pady=5)
        self.river_width_var = tk.StringVar(value="2")
        ttk.Entry(input_frame, textvariable=self.river_width_var, width=20).grid(row=13, column=1, pady=2)
        
        # 洪水参数
        ttk.Separator(input_frame, orient=tk.HORIZONTAL).grid(row=14, column=0, columnspan=2, sticky="ew", pady=15)
        
        ttk.Label(input_frame, text="洪水参数", font=('SimHei', 10, 'bold')).grid(row=15, column=0, columnspan=2, sticky=tk.W, pady=(10, 5))
        
        ttk.Label(input_frame, text="洪水水位（m）：").grid(row=16, column=0, sticky=tk.W, pady=(5, 2))
        self.flood_water_level_var = tk.StringVar(value="1600")
        ttk.Entry(input_frame, textvariable=self.flood_water_level_var, width=20).grid(row=16, column=1, pady=2)
        
        ttk.Label(input_frame, text="显示洪水淹没：").grid(row=17, column=0, sticky=tk.W, pady=5)
        self.show_flood_var = tk.BooleanVar(value=True)
        ttk.Checkbutton(input_frame, variable=self.show_flood_var).grid(row=17, column=1, sticky=tk.W, pady=2)
        
        # 视图参数
        ttk.Separator(input_frame, orient=tk.HORIZONTAL).grid(row=18, column=0, columnspan=2, sticky="ew", pady=15)
        
        ttk.Label(input_frame, text="视图参数", font=('SimHei', 10, 'bold')).grid(row=19, column=0, columnspan=2, sticky=tk.W, pady=(10, 5))
        
        ttk.Label(input_frame, text="视角仰角（度）：").grid(row=20, column=0, sticky=tk.W, pady=(5, 2))
        self.view_elevation_var = tk.StringVar(value="30")
        ttk.Entry(input_frame, textvariable=self.view_elevation_var, width=20).grid(row=20, column=1, pady=2)
        
        ttk.Label(input_frame, text="视角方位角（度）：").grid(row=21, column=0, sticky=tk.W, pady=5)
        self.view_azimuth_var = tk.StringVar(value="45")
        ttk.Entry(input_frame, textvariable=self.view_azimuth_var, width=20).grid(row=21, column=1, pady=2)
        
        # 按钮框架
        button_frame = ttk.Frame(input_frame)
        button_frame.grid(row=22, column=0, columnspan=2, pady=15)
        
        # 生成地形按钮
        generate_btn = ttk.Button(button_frame, text="生成三维地形", command=self.generate_terrain_3d)
        generate_btn.pack(fill=tk.X, pady=5)
        
        # 旋转视图按钮
        rotate_btn = ttk.Button(button_frame, text="旋转视图", command=self.rotate_terrain_view)
        rotate_btn.pack(fill=tk.X, pady=5)
        
        # 导出图片按钮
        export_btn = ttk.Button(button_frame, text="导出图片", command=self.export_terrain_image)
        export_btn.pack(fill=tk.X, pady=5)
        
        # 右侧结果面板
        result_frame = ttk.LabelFrame(main_frame, text="三维地形可视化", padding="10")
        result_frame.grid(row=0, column=1, sticky="nsew", padx=5, pady=5)
        
        # 创建图表区域
        self.create_terrain_plot(result_frame)
    
    def create_terrain_plot(self, parent):
        """创建三维地形图表"""
        # 创建Figure
        self.terrain_fig = Figure(figsize=(10, 8), dpi=100)
        
        # 创建3D子图
        from mpl_toolkits.mplot3d import Axes3D
        self.terrain_ax = self.terrain_fig.add_subplot(111, projection='3d')
        
        # 设置标题
        self.terrain_ax.set_title('流域地形三维可视化', fontdict={'fontsize': 14, 'fontweight': 'bold'}, pad=20)
        self.terrain_ax.set_xlabel('X (km)', fontsize=12)
        self.terrain_ax.set_ylabel('Y (km)', fontsize=12)
        self.terrain_ax.set_zlabel('海拔 (m)', fontsize=12)
        
        # 创建Canvas
        self.terrain_canvas = FigureCanvasTkAgg(self.terrain_fig, parent)
        self.terrain_canvas.draw()
        self.terrain_canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
        
        # 添加工具栏
        toolbar = NavigationToolbar2Tk(self.terrain_canvas, parent)
        toolbar.update()
        self.terrain_canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
    
    def generate_terrain_3d(self):
        """生成三维地形"""
        try:
            # 获取参数
            length = float(self.terrain_length_var.get())
            width = float(self.terrain_width_var.get())
            resolution = float(self.terrain_resolution_var.get())
            min_elevation = float(self.terrain_min_elevation_var.get())
            max_elevation = float(self.terrain_max_elevation_var.get())
            roughness = float(self.terrain_roughness_var.get())
            river_x = float(self.river_x_var.get())
            river_y = float(self.river_y_var.get())
            river_width = float(self.river_width_var.get())
            flood_level = float(self.flood_water_level_var.get())
            show_flood = self.show_flood_var.get()
            view_elevation = float(self.view_elevation_var.get())
            view_azimuth = float(self.view_azimuth_var.get())
            
            # 生成网格
            x = np.arange(0, length + resolution, resolution)
            y = np.arange(0, width + resolution, resolution)
            X, Y = np.meshgrid(x, y)
            
            # 生成地形（使用Perlin噪声模拟自然地形）
            np.random.seed(42)
            base_elevation = min_elevation + (max_elevation - min_elevation) * 0.5
            
            # 生成多层噪声
            noise1 = np.sin(X * 0.1) * np.cos(Y * 0.1) * (max_elevation - min_elevation) * 0.3
            noise2 = np.sin(X * 0.3 + 1) * np.cos(Y * 0.2 + 1) * (max_elevation - min_elevation) * 0.15
            noise3 = np.sin(X * 0.5 + 2) * np.cos(Y * 0.4 + 2) * (max_elevation - min_elevation) * 0.05
            random_noise = np.random.randn(*X.shape) * (max_elevation - min_elevation) * roughness * 0.1
            
            # 组合地形
            Z = base_elevation + noise1 + noise2 + noise3 + random_noise
            
            # 添加河道（降低河道区域的高程）
            river_mask = ((X - river_x)**2 + (Y - river_y)**2) <= (river_width / 2)**2
            Z[river_mask] = min_elevation + (max_elevation - min_elevation) * 0.1
            
            # 清除现有图表
            self.terrain_ax.clear()
            
            # 绘制地形表面
            surf = self.terrain_ax.plot_surface(X, Y, Z, cmap='terrain', alpha=0.8, 
                                               linewidth=0, antialiased=True, edgecolor='none')
            
            # 添加等高线
            self.terrain_ax.contour(X, Y, Z, zdir='z', offset=min_elevation - 50, cmap='terrain', alpha=0.5)
            
            # 绘制河道
            if np.any(river_mask):
                river_x_coords = X[river_mask]
                river_y_coords = Y[river_mask]
                river_z_coords = Z[river_mask]
                self.terrain_ax.scatter(river_x_coords, river_y_coords, river_z_coords, 
                                       c='#1a73e8', s=10, alpha=0.6, label='河道')
            
            # 绘制洪水淹没区域
            if show_flood and flood_level > min_elevation:
                flood_mask = Z <= flood_level
                if np.any(flood_mask):
                    flood_x_coords = X[flood_mask]
                    flood_y_coords = Y[flood_mask]
                    flood_z_coords = np.full_like(flood_x_coords, flood_level)
                    self.terrain_ax.scatter(flood_x_coords, flood_y_coords, flood_z_coords, 
                                           c='#3498db', s=5, alpha=0.4, label='洪水淹没')
                    
                    # 绘制洪水水面
                    flood_surface = self.terrain_ax.plot_surface(X, Y, np.full_like(Z, flood_level), 
                                                                 color='#3498db', alpha=0.3)
            
            # 设置标题和标签
            self.terrain_ax.set_title('流域地形三维可视化', fontdict={'fontsize': 14, 'fontweight': 'bold'}, pad=20)
            self.terrain_ax.set_xlabel('X (km)', fontsize=12)
            self.terrain_ax.set_ylabel('Y (km)', fontsize=12)
            self.terrain_ax.set_zlabel('海拔 (m)', fontsize=12)
            
            # 设置视角
            self.terrain_ax.view_init(elev=view_elevation, azim=view_azimuth)
            
            # 设置Z轴范围
            self.terrain_ax.set_zlim(min_elevation - 50, max_elevation + 50)
            
            # 添加图例
            self.terrain_ax.legend(loc='upper right', fontsize=10)
            
            # 添加颜色条
            self.terrain_fig.colorbar(surf, ax=self.terrain_ax, shrink=0.5, aspect=10, label='海拔 (m)')
            
            # 紧凑布局
            self.terrain_fig.tight_layout()
            
            # 更新Canvas
            self.terrain_canvas.draw()
            
            # 保存数据
            self.terrain_data = {
                'X': X,
                'Y': Y,
                'Z': Z,
                'length': length,
                'width': width,
                'resolution': resolution,
                'min_elevation': min_elevation,
                'max_elevation': max_elevation,
                'river_x': river_x,
                'river_y': river_y,
                'river_width': river_width,
                'flood_level': flood_level,
                'show_flood': show_flood
            }
            
        except Exception as e:
            messagebox.showerror("绘图错误", f"生成三维地形失败：{e}")
    
    def rotate_terrain_view(self):
        """旋转地形视图"""
        try:
            if not hasattr(self, 'terrain_data'):
                messagebox.showwarning("警告", "请先生成三维地形！")
                return
            
            # 获取当前视角
            elev, azim = self.terrain_ax.elev, self.terrain_ax.azim
            
            # 旋转45度
            new_azim = azim + 45
            
            # 更新视角
            self.terrain_ax.view_init(elev=elev, azim=new_azim)
            
            # 更新输入框
            self.view_azimuth_var.set(str(new_azim % 360))
            
            # 更新Canvas
            self.terrain_canvas.draw()
            
        except Exception as e:
            messagebox.showerror("错误", f"旋转视图失败：{e}")
    
    def export_terrain_image(self):
        """导出地形图片"""
        try:
            if not hasattr(self, 'terrain_data'):
                messagebox.showwarning("警告", "请先生成三维地形！")
                return
            
            # 选择保存文件路径
            file_path = filedialog.asksaveasfilename(
                defaultextension=".png",
                filetypes=[("PNG图片", "*.png"), ("JPG图片", "*.jpg"), ("所有文件", "*.*")],
                title="导出地形图片"
            )
            
            if not file_path:
                return
            
            # 保存图片
            self.terrain_fig.savefig(file_path, dpi=300, bbox_inches='tight')
            
            messagebox.showinfo("成功", f"地形图片已导出到：{file_path}")
            
        except Exception as e:
            messagebox.showerror("错误", f"导出图片失败：{e}")
    
    def init_interactive_flood_simulation_tab(self):
        """初始化交互式洪水模拟标签页"""
        # 创建主布局框架
        main_frame = ttk.Frame(self.extended_tab12, padding="10")
        main_frame.pack(fill=tk.BOTH, expand=True)
        
        # 使用Grid布局
        main_frame.columnconfigure(0, minsize=350, weight=0)
        main_frame.columnconfigure(1, weight=1)
        main_frame.rowconfigure(0, weight=1)
        
        # 左侧输入面板容器（带滚动条）
        input_container = ttk.Frame(main_frame)
        input_container.grid(row=0, column=0, sticky="nsew", padx=5, pady=5)
        
        # 创建Canvas和滚动条
        canvas = tk.Canvas(input_container, width=350, bg=self.style.configure('.')['background'])
        scrollbar = ttk.Scrollbar(input_container, orient="vertical", command=canvas.yview)
        scrollable_frame = ttk.Frame(canvas)
        
        # 配置Canvas
        scrollable_frame.bind(
            "<Configure>",
            lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
        )
        
        canvas.create_window((0, 0), window=scrollable_frame, anchor="nw", width=350)
        canvas.configure(yscrollcommand=scrollbar.set)
        
        # 布局Canvas和滚动条
        canvas.pack(side="left", fill="both", expand=True)
        scrollbar.pack(side="right", fill="y")
        
        # 左侧输入面板
        input_frame = ttk.LabelFrame(scrollable_frame, text="模拟参数", padding="10")
        input_frame.pack(fill=tk.BOTH, expand=True, pady=5)
        
        # 流域参数
        ttk.Label(input_frame, text="流域参数", font=('SimHei', 10, 'bold')).grid(row=0, column=0, columnspan=2, sticky=tk.W, pady=(10, 5))
        
        ttk.Label(input_frame, text="流域面积（km²）：").grid(row=1, column=0, sticky=tk.W, pady=(5, 2))
        self.sim_area_var = tk.StringVar(value="100")
        ttk.Entry(input_frame, textvariable=self.sim_area_var, width=20).grid(row=1, column=1, pady=2)
        
        ttk.Label(input_frame, text="流域长度（km）：").grid(row=2, column=0, sticky=tk.W, pady=5)
        self.sim_length_var = tk.StringVar(value="20")
        ttk.Entry(input_frame, textvariable=self.sim_length_var, width=20).grid(row=2, column=1, pady=2)
        
        ttk.Label(input_frame, text="流域宽度（km）：").grid(row=3, column=0, sticky=tk.W, pady=5)
        self.sim_width_var = tk.StringVar(value="10")
        ttk.Entry(input_frame, textvariable=self.sim_width_var, width=20).grid(row=3, column=1, pady=2)
        
        # 降雨参数
        ttk.Separator(input_frame, orient=tk.HORIZONTAL).grid(row=4, column=0, columnspan=2, sticky="ew", pady=15)
        
        ttk.Label(input_frame, text="降雨参数", font=('SimHei', 10, 'bold')).grid(row=5, column=0, columnspan=2, sticky=tk.W, pady=(10, 5))
        
        ttk.Label(input_frame, text="降雨量（mm）：").grid(row=6, column=0, sticky=tk.W, pady=(5, 2))
        self.sim_rainfall_var = tk.StringVar(value="200")
        ttk.Entry(input_frame, textvariable=self.sim_rainfall_var, width=20).grid(row=6, column=1, pady=2)
        
        ttk.Label(input_frame, text="降雨历时（h）：").grid(row=7, column=0, sticky=tk.W, pady=5)
        self.sim_duration_var = tk.StringVar(value="24")
        ttk.Entry(input_frame, textvariable=self.sim_duration_var, width=20).grid(row=7, column=1, pady=2)
        
        ttk.Label(input_frame, text="降雨强度分布：").grid(row=8, column=0, sticky=tk.W, pady=5)
        self.sim_rainfall_pattern_var = tk.StringVar(value="均匀")
        rainfall_patterns = ["均匀", "前期集中", "后期集中", "中间集中"]
        ttk.Combobox(input_frame, textvariable=self.sim_rainfall_pattern_var, values=rainfall_patterns, width=18).grid(row=8, column=1, pady=2)
        
        # 地形参数
        ttk.Separator(input_frame, orient=tk.HORIZONTAL).grid(row=9, column=0, columnspan=2, sticky="ew", pady=15)
        
        ttk.Label(input_frame, text="地形参数", font=('SimHei', 10, 'bold')).grid(row=10, column=0, columnspan=2, sticky=tk.W, pady=(10, 5))
        
        ttk.Label(input_frame, text="地形坡度：").grid(row=11, column=0, sticky=tk.W, pady=(5, 2))
        self.sim_slope_var = tk.StringVar(value="0.05")
        ttk.Entry(input_frame, textvariable=self.sim_slope_var, width=20).grid(row=11, column=1, pady=2)
        
        ttk.Label(input_frame, text="土壤渗透系数：").grid(row=12, column=0, sticky=tk.W, pady=5)
        self.sim_infiltration_var = tk.StringVar(value="0.3")
        ttk.Entry(input_frame, textvariable=self.sim_infiltration_var, width=20).grid(row=12, column=1, pady=2)
        
        ttk.Label(input_frame, text="地表糙率：").grid(row=13, column=0, sticky=tk.W, pady=5)
        self.sim_roughness_var = tk.StringVar(value="0.035")
        ttk.Entry(input_frame, textvariable=self.sim_roughness_var, width=20).grid(row=13, column=1, pady=2)
        
        # 模拟控制
        ttk.Separator(input_frame, orient=tk.HORIZONTAL).grid(row=14, column=0, columnspan=2, sticky="ew", pady=15)
        
        ttk.Label(input_frame, text="模拟控制", font=('SimHei', 10, 'bold')).grid(row=15, column=0, columnspan=2, sticky=tk.W, pady=(10, 5))
        
        ttk.Label(input_frame, text="模拟时长（h）：").grid(row=16, column=0, sticky=tk.W, pady=(5, 2))
        self.sim_time_var = tk.StringVar(value="48")
        ttk.Entry(input_frame, textvariable=self.sim_time_var, width=20).grid(row=16, column=1, pady=2)
        
        ttk.Label(input_frame, text="时间步长（h）：").grid(row=17, column=0, sticky=tk.W, pady=5)
        self.sim_timestep_var = tk.StringVar(value="1")
        ttk.Entry(input_frame, textvariable=self.sim_timestep_var, width=20).grid(row=17, column=1, pady=2)
        
        ttk.Label(input_frame, text="动画速度：").grid(row=18, column=0, sticky=tk.W, pady=5)
        self.sim_speed_var = tk.StringVar(value="1")
        ttk.Entry(input_frame, textvariable=self.sim_speed_var, width=20).grid(row=18, column=1, pady=2)
        
        # 按钮框架
        button_frame = ttk.Frame(input_frame)
        button_frame.grid(row=19, column=0, columnspan=2, pady=15)
        
        # 开始模拟按钮
        start_btn = ttk.Button(button_frame, text="开始模拟", command=self.start_flood_simulation)
        start_btn.pack(fill=tk.X, pady=5)
        
        # 暂停/继续按钮
        self.pause_btn = ttk.Button(button_frame, text="暂停", command=self.pause_flood_simulation, state=tk.DISABLED)
        self.pause_btn.pack(fill=tk.X, pady=5)
        
        # 重置按钮
        reset_btn = ttk.Button(button_frame, text="重置", command=self.reset_flood_simulation)
        reset_btn.pack(fill=tk.X, pady=5)
        
        # 导出数据按钮
        export_btn = ttk.Button(button_frame, text="导出数据", command=self.export_simulation_data)
        export_btn.pack(fill=tk.X, pady=5)
        
        # 进度显示
        ttk.Separator(input_frame, orient=tk.HORIZONTAL).grid(row=20, column=0, columnspan=2, sticky="ew", pady=15)
        
        ttk.Label(input_frame, text="模拟进度", font=('SimHei', 10, 'bold')).grid(row=21, column=0, columnspan=2, sticky=tk.W, pady=(10, 5))
        
        self.sim_progress_var = tk.StringVar(value="0%")
        ttk.Label(input_frame, textvariable=self.sim_progress_var, font=('SimHei', 12, 'bold')).grid(row=22, column=0, columnspan=2, sticky=tk.W, pady=5)
        
        self.sim_time_display_var = tk.StringVar(value="时间：0 h")
        ttk.Label(input_frame, textvariable=self.sim_time_display_var).grid(row=23, column=0, columnspan=2, sticky=tk.W, pady=5)
        
        # 右侧结果面板
        result_frame = ttk.LabelFrame(main_frame, text="洪水模拟可视化", padding="10")
        result_frame.grid(row=0, column=1, sticky="nsew", padx=5, pady=5)
        
        # 创建图表区域
        self.create_simulation_plot(result_frame)
    
    def create_simulation_plot(self, parent):
        """创建洪水模拟图表"""
        # 创建Figure
        self.sim_fig = Figure(figsize=(10, 8), dpi=100)
        
        # 创建子图布局：上方为洪水传播图，下方为流量过程线
        self.sim_ax1 = self.sim_fig.add_subplot(211)
        self.sim_ax2 = self.sim_fig.add_subplot(212)
        
        # 设置标题
        self.sim_ax1.set_title('洪水传播模拟', fontdict={'fontsize': 14, 'fontweight': 'bold'}, pad=15)
        self.sim_ax1.set_xlabel('距离（km）', fontsize=12)
        self.sim_ax1.set_ylabel('水位（m）', fontsize=12)
        self.sim_ax1.grid(True, alpha=0.3, linestyle='--')
        
        self.sim_ax2.set_title('流量过程线', fontdict={'fontsize': 14, 'fontweight': 'bold'}, pad=15)
        self.sim_ax2.set_xlabel('时间（h）', fontsize=12)
        self.sim_ax2.set_ylabel('流量（m³/s）', fontsize=12)
        self.sim_ax2.grid(True, alpha=0.3, linestyle='--')
        
        # 创建Canvas
        self.sim_canvas = FigureCanvasTkAgg(self.sim_fig, parent)
        self.sim_canvas.draw()
        self.sim_canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
        
        # 添加工具栏
        toolbar = NavigationToolbar2Tk(self.sim_canvas, parent)
        toolbar.update()
        self.sim_canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
    
    def start_flood_simulation(self):
        """开始洪水模拟"""
        try:
            # 获取参数
            area = float(self.sim_area_var.get())
            length = float(self.sim_length_var.get())
            width = float(self.sim_width_var.get())
            rainfall = float(self.sim_rainfall_var.get())
            duration = float(self.sim_duration_var.get())
            rainfall_pattern = self.sim_rainfall_pattern_var.get()
            slope = float(self.sim_slope_var.get())
            infiltration = float(self.sim_infiltration_var.get())
            roughness = float(self.sim_roughness_var.get())
            sim_time = float(self.sim_time_var.get())
            timestep = float(self.sim_timestep_var.get())
            speed = float(self.sim_speed_var.get())
            
            # 初始化模拟数据
            self.simulation_data = {
                'area': area,
                'length': length,
                'width': width,
                'rainfall': rainfall,
                'duration': duration,
                'rainfall_pattern': rainfall_pattern,
                'slope': slope,
                'infiltration': infiltration,
                'roughness': roughness,
                'sim_time': sim_time,
                'timestep': timestep,
                'speed': speed,
                'current_time': 0,
                'is_paused': False,
                'is_running': True
            }
            
            # 生成降雨分布
            self.simulation_data['rainfall_distribution'] = self._generate_rainfall_distribution(rainfall, duration, rainfall_pattern)
            
            # 初始化水位和流量数组
            num_points = int(length) + 1
            num_steps = int(sim_time / timestep) + 1
            
            self.simulation_data['water_levels'] = np.zeros((num_steps, num_points))
            self.simulation_data['discharges'] = np.zeros(num_steps)
            self.simulation_data['distances'] = np.linspace(0, length, num_points)
            self.simulation_data['times'] = np.linspace(0, sim_time, num_steps)
            
            # 启用暂停按钮
            self.pause_btn.config(state=tk.NORMAL)
            
            # 开始模拟
            self._run_simulation_step()
            
        except Exception as e:
            messagebox.showerror("模拟错误", f"启动模拟失败：{e}")
    
    def _generate_rainfall_distribution(self, rainfall, duration, pattern):
        """生成降雨分布"""
        num_steps = int(duration) + 1
        time_points = np.linspace(0, duration, num_steps)
        
        if pattern == "均匀":
            distribution = np.ones(num_steps) * rainfall / duration
        elif pattern == "前期集中":
            peak_time = duration * 0.2
            distribution = rainfall * (1 / (duration * 0.4)) * np.exp(-((time_points - peak_time) / (duration * 0.2))**2)
        elif pattern == "后期集中":
            peak_time = duration * 0.8
            distribution = rainfall * (1 / (duration * 0.4)) * np.exp(-((time_points - peak_time) / (duration * 0.2))**2)
        else:
            peak_time = duration * 0.5
            distribution = rainfall * (1 / (duration * 0.4)) * np.exp(-((time_points - peak_time) / (duration * 0.2))**2)
        
        return distribution
    
    def _run_simulation_step(self):
        """运行模拟步骤"""
        try:
            if not self.simulation_data['is_running']:
                return
            
            if self.simulation_data['is_paused']:
                self.root.after(100, self._run_simulation_step)
                return
            
            current_step = int(self.simulation_data['current_time'] / self.simulation_data['timestep'])
            
            if current_step >= len(self.simulation_data['times']):
                self.simulation_data['is_running'] = False
                self.pause_btn.config(state=tk.DISABLED)
                messagebox.showinfo("完成", "洪水模拟完成！")
                return
            
            # 计算当前时刻的降雨强度
            rainfall_idx = min(current_step, len(self.simulation_data['rainfall_distribution']) - 1)
            rainfall_intensity = self.simulation_data['rainfall_distribution'][rainfall_idx]
            
            # 计算净雨（考虑渗透）
            net_rainfall = rainfall_intensity * (1 - self.simulation_data['infiltration'])
            
            # 计算水位传播
            for i in range(len(self.simulation_data['distances'])):
                distance = self.simulation_data['distances'][i]
                
                # 洪水传播速度（简化模型）
                wave_speed = np.sqrt(9.81 * self.simulation_data['slope'] * 10)
                
                # 洪水到达时间
                arrival_time = distance / wave_speed
                
                # 当前水位
                if self.simulation_data['current_time'] >= arrival_time:
                    time_since_arrival = self.simulation_data['current_time'] - arrival_time
                    water_level = net_rainfall * time_since_arrival * 0.1
                else:
                    water_level = 0
                
                self.simulation_data['water_levels'][current_step, i] = water_level
            
            # 计算出口断面流量
            max_water_level = np.max(self.simulation_data['water_levels'][current_step, :])
            discharge = self.simulation_data['area'] * max_water_level * np.sqrt(self.simulation_data['slope']) / self.simulation_data['roughness']
            self.simulation_data['discharges'][current_step] = discharge
            
            # 更新显示
            self._update_simulation_display(current_step)
            
            # 更新进度
            progress = (current_step + 1) / len(self.simulation_data['times']) * 100
            self.sim_progress_var.set(f"{progress:.1f}%")
            self.sim_time_display_var.set(f"时间：{self.simulation_data['current_time']:.1f} h")
            
            # 推进时间
            self.simulation_data['current_time'] += self.simulation_data['timestep']
            
            # 继续下一步
            delay = int(1000 / self.simulation_data['speed'])
            self.root.after(delay, self._run_simulation_step)
            
        except Exception as e:
            messagebox.showerror("模拟错误", f"模拟步骤失败：{e}")
    
    def _update_simulation_display(self, current_step):
        """更新模拟显示"""
        # 清除现有图表
        self.sim_ax1.clear()
        self.sim_ax2.clear()
        
        # 绘制洪水传播
        self.sim_ax1.plot(self.simulation_data['distances'], 
                         self.simulation_data['water_levels'][current_step, :],
                         color='#3498db', linewidth=2, label='水位')
        self.sim_ax1.fill_between(self.simulation_data['distances'],
                                  self.simulation_data['water_levels'][current_step, :],
                                  color='#3498db', alpha=0.3)
        self.sim_ax1.set_title(f'洪水传播模拟（t={self.simulation_data["current_time"]:.1f} h）',
                              fontdict={'fontsize': 14, 'fontweight': 'bold'}, pad=15)
        self.sim_ax1.set_xlabel('距离（km）', fontsize=12)
        self.sim_ax1.set_ylabel('水位（m）', fontsize=12)
        self.sim_ax1.grid(True, alpha=0.3, linestyle='--')
        self.sim_ax1.legend(fontsize=10)
        
        # 绘制流量过程线
        self.sim_ax2.plot(self.simulation_data['times'][:current_step+1],
                         self.simulation_data['discharges'][:current_step+1],
                         color='#e74c3c', linewidth=2, label='流量')
        self.sim_ax2.set_title('流量过程线', fontdict={'fontsize': 14, 'fontweight': 'bold'}, pad=15)
        self.sim_ax2.set_xlabel('时间（h）', fontsize=12)
        self.sim_ax2.set_ylabel('流量（m³/s）', fontsize=12)
        self.sim_ax2.grid(True, alpha=0.3, linestyle='--')
        self.sim_ax2.legend(fontsize=10)
        
        # 紧凑布局
        self.sim_fig.tight_layout()
        
        # 更新Canvas
        self.sim_canvas.draw()
    
    def pause_flood_simulation(self):
        """暂停/继续洪水模拟"""
        if self.simulation_data['is_paused']:
            self.simulation_data['is_paused'] = False
            self.pause_btn.config(text="暂停")
        else:
            self.simulation_data['is_paused'] = True
            self.pause_btn.config(text="继续")
    
    def reset_flood_simulation(self):
        """重置洪水模拟"""
        try:
            # 停止模拟
            if hasattr(self, 'simulation_data'):
                self.simulation_data['is_running'] = False
            
            # 清除图表
            self.sim_ax1.clear()
            self.sim_ax2.clear()
            
            # 重置标题
            self.sim_ax1.set_title('洪水传播模拟', fontdict={'fontsize': 14, 'fontweight': 'bold'}, pad=15)
            self.sim_ax1.set_xlabel('距离（km）', fontsize=12)
            self.sim_ax1.set_ylabel('水位（m）', fontsize=12)
            self.sim_ax1.grid(True, alpha=0.3, linestyle='--')
            
            self.sim_ax2.set_title('流量过程线', fontdict={'fontsize': 14, 'fontweight': 'bold'}, pad=15)
            self.sim_ax2.set_xlabel('时间（h）', fontsize=12)
            self.sim_ax2.set_ylabel('流量（m³/s）', fontsize=12)
            self.sim_ax2.grid(True, alpha=0.3, linestyle='--')
            
            # 紧凑布局
            self.sim_fig.tight_layout()
            
            # 更新Canvas
            self.sim_canvas.draw()
            
            # 重置进度显示
            self.sim_progress_var.set("0%")
            self.sim_time_display_var.set("时间：0 h")
            
            # 禁用暂停按钮
            self.pause_btn.config(text="暂停", state=tk.DISABLED)
            
        except Exception as e:
            messagebox.showerror("错误", f"重置模拟失败：{e}")
    
    def export_simulation_data(self):
        """导出模拟数据"""
        try:
            if not hasattr(self, 'simulation_data') or not self.simulation_data:
                messagebox.showwarning("警告", "请先运行洪水模拟！")
                return
            
            # 选择保存文件路径
            file_path = filedialog.asksaveasfilename(
                defaultextension=".xlsx",
                filetypes=[("Excel文件", "*.xlsx"), ("CSV文件", "*.csv"), ("所有文件", "*.*")],
                title="导出洪水模拟数据"
            )
            
            if not file_path:
                return
            
            # 准备数据
            export_data = {
                '时间（h）': self.simulation_data['times'],
                '流量（m³/s）': self.simulation_data['discharges']
            }
            
            # 添加各点水位数据
            for i, distance in enumerate(self.simulation_data['distances']):
                export_data[f'水位_{distance:.1f}km（m）'] = self.simulation_data['water_levels'][:, i]
            
            # 导出数据
            df = pd.DataFrame(export_data)
            if file_path.endswith('.xlsx'):
                df.to_excel(file_path, index=False)
            elif file_path.endswith('.csv'):
                df.to_csv(file_path, index=False, encoding='utf-8-sig')
            else:
                df.to_excel(file_path, index=False)
            
            messagebox.showinfo("成功", f"洪水模拟数据已导出到：{file_path}")
            
        except Exception as e:
            messagebox.showerror("错误", f"导出数据失败：{e}")
    
    def save_params(self, param_type):
        """保存参数到JSON文件"""
        try:
            # 获取参数
            if param_type == "design_flood":
                params = {
                    "flood_type": self.flood_type_var.get(),
                    "area": self.area_entry.get(),
                    "pd24": self.pd24_entry.get(),
                    "c": self.c_entry.get(),
                    "n_exp": self.n_exp_entry.get(),
                    "cv_q": self.cv_q_entry.get(),
                    "cv_w24": self.cv_w24_entry.get(),
                    "frequencies": self.frequencies_entry.get()
                }
            elif param_type == "flood_level":
                params = {
                    "section_type": self.section_type_var.get(),
                    "b": self.b_entry.get(),
                    "m": self.m_entry.get(),
                    "bed_elevation": self.bed_elevation_entry.get(),
                    "bank_elevation": self.bank_elevation_entry.get(),
                    "n": self.n_entry.get(),
                    "s": self.s_entry.get(),
                    "q_list": self.q_list_entry.get()
                }
            elif param_type == "water_level_discharge":
                params = {
                    "bridge_name": self.bridge_name_entry.get(),
                    "bank_elevation": self.wld_bank_elevation_entry.get(),
                    "bridge_bottom_elevation": self.wld_bridge_bottom_elevation_entry.get(),
                    "data_source": self.data_source_var.get(),
                    "discharges": self.wld_discharges_entry.get(),
                    "water_levels": self.wld_water_levels_entry.get(),
                    "return_periods": self.wld_return_periods_entry.get()
                }
            elif param_type == "backwater_analysis":
                params = {
                    "river_feature": self.river_feature_var.get(),
                    "flow_ratio": self.flow_ratio_entry.get(),
                    "vp": self.vp_entry.get(),
                    "soil_type": self.soil_type_var.get(),
                    "omega_g": self.omega_g_entry.get(),
                    "omega_x": self.omega_x_entry.get(),
                    "alpha": self.alpha_entry.get(),
                    "v": self.v_entry.get(),
                    "i0": self.i0_entry.get()
                }
            else:
                messagebox.showerror("错误", "未知的参数类型")
                return
            
            # 打开保存文件对话框
            # 确保output/params目录存在
            import os
            os.makedirs('output/params', exist_ok=True)
            
            file_path = filedialog.asksaveasfilename(
                defaultextension=".json",
                filetypes=[("JSON文件", "*.json"), ("所有文件", "*.*")],
                initialfile=f"{param_type}_params.json",
                initialdir="output/params"
            )
            
            if file_path:
                # 保存参数到JSON文件
                import json
                with open(file_path, "w", encoding="utf-8") as f:
                    json.dump(params, f, ensure_ascii=False, indent=2)
                messagebox.showinfo("成功", f"参数已保存到 {file_path}")
        except Exception as e:
            messagebox.showerror("错误", f"保存参数失败：{e}")
    
    def load_params(self, param_type):
        """从JSON文件加载参数"""
        try:
            # 打开打开文件对话框
            file_path = filedialog.askopenfilename(
                defaultextension=".json",
                filetypes=[("JSON文件", "*.json"), ("所有文件", "*.*")]
            )
            
            if file_path:
                # 加载参数
                import json
                with open(file_path, "r", encoding="utf-8") as f:
                    params = json.load(f)
                
                # 设置参数到相应的输入控件
                if param_type == "design_flood":
                    self.flood_type_var.set(params.get("flood_type", "泼机河型"))
                    self.area_entry.delete(0, tk.END)
                    self.area_entry.insert(0, params.get("area", ""))
                    self.pd24_entry.delete(0, tk.END)
                    self.pd24_entry.insert(0, params.get("pd24", ""))
                    self.c_entry.delete(0, tk.END)
                    self.c_entry.insert(0, params.get("c", ""))
                    self.n_exp_entry.delete(0, tk.END)
                    self.n_exp_entry.insert(0, params.get("n_exp", ""))
                    self.cv_q_entry.delete(0, tk.END)
                    self.cv_q_entry.insert(0, params.get("cv_q", ""))
                    self.cv_w24_entry.delete(0, tk.END)
                    self.cv_w24_entry.insert(0, params.get("cv_w24", ""))
                    self.frequencies_entry.delete(0, tk.END)
                    self.frequencies_entry.insert(0, params.get("frequencies", ""))
                elif param_type == "flood_level":
                    self.section_type_var.set(params.get("section_type", "trapezoid"))
                    self.b_entry.delete(0, tk.END)
                    self.b_entry.insert(0, params.get("b", ""))
                    self.m_entry.delete(0, tk.END)
                    self.m_entry.insert(0, params.get("m", ""))
                    self.bed_elevation_entry.delete(0, tk.END)
                    self.bed_elevation_entry.insert(0, params.get("bed_elevation", ""))
                    self.bank_elevation_entry.delete(0, tk.END)
                    self.bank_elevation_entry.insert(0, params.get("bank_elevation", ""))
                    self.n_entry.delete(0, tk.END)
                    self.n_entry.insert(0, params.get("n", ""))
                    self.s_entry.delete(0, tk.END)
                    self.s_entry.insert(0, params.get("s", ""))
                    self.q_list_entry.delete(0, tk.END)
                    self.q_list_entry.insert(0, params.get("q_list", ""))
                    # 更新界面显示
                    self.toggle_section_type()
                elif param_type == "water_level_discharge":
                    self.bridge_name_entry.delete(0, tk.END)
                    self.bridge_name_entry.insert(0, params.get("bridge_name", ""))
                    self.wld_bank_elevation_entry.delete(0, tk.END)
                    self.wld_bank_elevation_entry.insert(0, params.get("bank_elevation", ""))
                    self.wld_bridge_bottom_elevation_entry.delete(0, tk.END)
                    self.wld_bridge_bottom_elevation_entry.insert(0, params.get("bridge_bottom_elevation", ""))
                    self.data_source_var.set(params.get("data_source", "manual"))
                    self.wld_discharges_entry.delete(0, tk.END)
                    self.wld_discharges_entry.insert(0, params.get("discharges", ""))
                    self.wld_water_levels_entry.delete(0, tk.END)
                    self.wld_water_levels_entry.insert(0, params.get("water_levels", ""))
                    self.wld_return_periods_entry.delete(0, tk.END)
                    self.wld_return_periods_entry.insert(0, params.get("return_periods", ""))
                elif param_type == "backwater_analysis":
                    self.river_feature_var.set(params.get("river_feature", "山区河流"))
                    self.flow_ratio_entry.delete(0, tk.END)
                    self.flow_ratio_entry.insert(0, params.get("flow_ratio", ""))
                    self.vp_entry.delete(0, tk.END)
                    self.vp_entry.insert(0, params.get("vp", ""))
                    self.soil_type_var.set(params.get("soil_type", "中等土"))
                    self.omega_g_entry.delete(0, tk.END)
                    self.omega_g_entry.insert(0, params.get("omega_g", ""))
                    self.omega_x_entry.delete(0, tk.END)
                    self.omega_x_entry.insert(0, params.get("omega_x", ""))
                    self.alpha_entry.delete(0, tk.END)
                    self.alpha_entry.insert(0, params.get("alpha", ""))
                    self.v_entry.delete(0, tk.END)
                    self.v_entry.insert(0, params.get("v", ""))
                    self.i0_entry.delete(0, tk.END)
                    self.i0_entry.insert(0, params.get("i0", ""))
                
                messagebox.showinfo("成功", f"参数已从 {file_path} 加载")
        except Exception as e:
            messagebox.showerror("错误", f"加载参数失败：{e}")
    
    def show_progress(self, title, max_value):
        """显示进度条窗口"""
        # 创建进度条窗口
        self.progress_window = tk.Toplevel(self.root)
        self.progress_window.title(title)
        self.progress_window.geometry("300x100")
        self.progress_window.resizable(False, False)
        
        # 居中显示
        window_width = 300
        window_height = 100
        screen_width = self.progress_window.winfo_screenwidth()
        screen_height = self.progress_window.winfo_screenheight()
        x = (screen_width // 2) - (window_width // 2)
        y = (screen_height // 2) - (window_height // 2)
        self.progress_window.geometry(f"{window_width}x{window_height}+{x}+{y}")
        
        # 创建进度条
        progress_frame = ttk.Frame(self.progress_window, padding=10)
        progress_frame.pack(fill=tk.BOTH, expand=True)
        
        self.progress_label = ttk.Label(progress_frame, text="正在计算中...")
        self.progress_label.pack(pady=5)
        
        self.progress_bar = ttk.Progressbar(progress_frame, length=250, mode='determinate', maximum=max_value)
        self.progress_bar.pack(pady=10)
        
        # 禁止关闭窗口
        self.progress_window.protocol("WM_DELETE_WINDOW", lambda: None)
        
        # 更新窗口
        self.progress_window.update()
    
    def update_progress(self, value, message=None):
        """更新进度条"""
        if self.progress_bar and self.progress_window:
            self.progress_bar['value'] = value
            if message:
                self.progress_label.config(text=message)
            self.progress_window.update()
    
    def hide_progress(self):
        """隐藏进度条窗口"""
        if self.progress_window:
            self.progress_window.destroy()
            self.progress_window = None
            self.progress_bar = None
            self.progress_label = None
    
    def create_toolbar(self):
        """创建工具栏"""
        # 创建工具栏框架
        self.toolbar = ttk.Frame(self.root)
        self.toolbar.pack(side=tk.TOP, fill=tk.X)
        
        # 创建工具栏按钮
        style = ttk.Style()
        style.configure('Toolbutton.TButton', font=('SimHei', 9), padding=3)
        
        # 参数管理按钮
        ttk.Button(self.toolbar, text="保存参数", command=self.save_current_params, style='Toolbutton.TButton').pack(side=tk.LEFT, padx=2, pady=2)
        ttk.Button(self.toolbar, text="加载参数", command=self.load_current_params, style='Toolbutton.TButton').pack(side=tk.LEFT, padx=2, pady=2)
        
        # 分隔线
        ttk.Separator(self.toolbar, orient=tk.VERTICAL).pack(side=tk.LEFT, padx=5, pady=2, fill=tk.Y)
        
        # 计算相关按钮
        ttk.Button(self.toolbar, text="帮助", command=self.show_help, style='Toolbutton.TButton').pack(side=tk.RIGHT, padx=2, pady=2)
    
    def bind_shortcuts(self):
        """绑定快捷键"""
        # 标签页切换快捷键
        self.root.bind('<Alt-1>', lambda event: self.switch_to_design_flood())
        self.root.bind('<Alt-2>', lambda event: self.switch_to_flood_level())
        self.root.bind('<Alt-3>', lambda event: self.switch_to_water_level_discharge())
        self.root.bind('<Alt-4>', lambda event: self.switch_to_results())
        self.root.bind('<Alt-5>', lambda event: self.switch_to_backwater_analysis())
        self.root.bind('<Alt-6>', lambda event: self.switch_to_compare_charts())
        
        # 计算快捷键
        self.root.bind('<Control-c>', lambda event: self.calculate_current_tab())
        
        # 参数管理快捷键
        self.root.bind('<Control-s>', lambda event: self.save_current_params())
        self.root.bind('<Control-l>', lambda event: self.load_current_params())
        
        # 退出快捷键
        self.root.bind('<Alt-F4>', lambda event: self.root.quit())
    
    def switch_to_design_flood(self):
        """切换到设计洪水计算标签页"""
        self.tab_control.select(self.tab1)
    
    def switch_to_flood_level(self):
        """切换到洪水位计算标签页"""
        self.tab_control.select(self.tab2)
    
    def switch_to_water_level_discharge(self):
        """切换到水位流量关系图标签页"""
        self.tab_control.select(self.tab3)
    
    def switch_to_results(self):
        """切换到计算结果标签页"""
        self.tab_control.select(self.tab4)
    
    def switch_to_backwater_analysis(self):
        """切换到壅水分析计算标签页"""
        self.tab_control.select(self.tab5)
    
    def switch_to_compare_charts(self):
        """切换到历史洪水对比标签页"""
        self.tab_control.select(self.tab6)
    
    def toggle_method_frames(self):
        """根据选择的计算方法显示/隐藏对应的输入框架"""
        # 传统方法框架
        if self.traditional_method_var.get():
            self.traditional_method_frame.pack(fill=tk.X, expand=True, pady=5)
        else:
            self.traditional_method_frame.pack_forget()
        
        # 单位线法框架
        if self.unit_hydrograph_method_var.get():
            self.unit_hydrograph_method_frame.pack(fill=tk.X, expand=True, pady=5)
        else:
            self.unit_hydrograph_method_frame.pack_forget()
    
    def calculate_unit_hydrograph_design_flood(self):
        """执行单位线法设计洪水计算"""
        try:
            # 更新进度
            self.update_progress(60, "使用单位线法计算...")
            
            # 获取输入参数
            
            # 输入验证
            is_valid, area, error_msg = validate_numeric_input(self.unit_area_entry.get(), min_value=0, field_name="流域面积")
            if not is_valid:
                raise ValueError(error_msg)
            
            is_valid, L, error_msg = validate_numeric_input(self.unit_L_entry.get(), min_value=0, field_name="主河道长度")
            if not is_valid:
                raise ValueError(error_msg)
            
            is_valid, J, error_msg = validate_numeric_input(self.unit_J_entry.get(), min_value=0, field_name="主河道平均比降")
            if not is_valid:
                raise ValueError(error_msg)
            
            is_valid, H24, error_msg = validate_numeric_input(self.unit_H24_entry.get(), min_value=0, field_name="24h暴雨均值")
            if not is_valid:
                raise ValueError(error_msg)
            
            is_valid, Cv, error_msg = validate_numeric_input(self.unit_Cv_entry.get(), min_value=0, field_name="暴雨变差系数Cv")
            if not is_valid:
                raise ValueError(error_msg)
            
            is_valid, Cs, error_msg = validate_numeric_input(self.unit_Cs_entry.get(), min_value=0, field_name="暴雨偏态系数Cs")
            if not is_valid:
                raise ValueError(error_msg)
            
            is_valid, frequencies, error_msg = parse_float_list(self.unit_frequencies_entry.get(), field_name="设计频率")
            if not is_valid:
                raise ValueError(error_msg)
            
            # 计算各频率下的设计洪水成果
            design_results = []
            
            # 更新进度
            self.update_progress(75, "计算设计洪水成果...")
            
            for frequency in frequencies:
                # 使用单位线法计算设计洪水
                result = calculate_unit_hydrograph_design_flood(area, L, J, H24, Cv, Cs, frequency)
                
                # 保存结果
                design_results.append({
                    'frequency': result['frequency'],
                    'return_period': result['return_period'],
                    'qp': result['qp'],
                    'w24p': result['w24p'],
                    'method': '单位线法'
                })
            
            # 更新进度
            self.update_progress(90, "保存计算结果...")
            
            # 保存计算结果
            self.design_flood_data['design_results'].extend(design_results)
            
        except Exception as e:
            messagebox.showerror("计算错误", f"单位线法计算失败：{e}")
            self.close_progress_window()
            raise
    
    def save_current_params(self):
        """保存当前标签页的参数"""
        current_tab = self.tab_control.index(self.tab_control.select())
        if current_tab == 0:  # 设计洪水计算
            self.save_params("design_flood")
        elif current_tab == 1:  # 洪水位计算
            self.save_params("flood_level")
        elif current_tab == 2:  # 水位流量关系图
            self.save_params("water_level_discharge")
        elif current_tab == 4:  # 壅水分析计算
            self.save_params("backwater_analysis")
    
    def load_current_params(self):
        """加载当前标签页的参数"""
        current_tab = self.tab_control.index(self.tab_control.select())
        if current_tab == 0:  # 设计洪水计算
            self.load_params("design_flood")
        elif current_tab == 1:  # 洪水位计算
            self.load_params("flood_level")
        elif current_tab == 2:  # 水位流量关系图
            self.load_params("water_level_discharge")
        elif current_tab == 4:  # 壅水分析计算
            self.load_params("backwater_analysis")
    
    def calculate_current_tab(self):
        """计算当前标签页"""
        current_tab = self.tab_control.index(self.tab_control.select())
        if current_tab == 0:  # 设计洪水计算
            self.calculate_design_flood()
        elif current_tab == 1:  # 洪水位计算
            self.calculate_flood_level()
        elif current_tab == 2:  # 水位流量关系图
            self.plot_water_level_discharge()
        elif current_tab == 4:  # 壅水分析计算
            self.calculate_backwater_analysis()
    
    def show_help(self):
        """显示帮助信息"""
        help_text = """昭通洪水可视化集成程序使用说明：

标签页切换快捷键：
  Alt+1 - 设计洪水计算
  Alt+2 - 洪水位计算
  Alt+3 - 水位流量关系图
  Alt+4 - 计算结果
  Alt+5 - 壅水分析计算
  Alt+6 - 历史洪水对比

功能快捷键：
  Ctrl+C - 执行当前标签页计算
  Ctrl+S - 保存当前标签页参数
  Ctrl+L - 加载当前标签页参数
  Alt+F4 - 退出程序

使用说明：
1. 在各标签页输入相应参数
2. 点击计算按钮或使用Ctrl+C执行计算
3. 计算结果将显示在右侧结果面板
4. 可使用保存/加载功能保存或加载参数
5. 支持批量计算功能
6. 历史洪水对比功能：
   - 在历史洪水对比标签页输入历史洪水数据
   - 点击绘制对比图表查看历史洪水与设计洪水的对比效果
   - 支持导出对比图表
"""
        messagebox.showinfo("帮助信息", help_text)
    
    def add_current_chart_to_compare(self):
        """将当前图表添加到对比列表"""
        try:
            # 检查是否有绘制的图表数据
            if not hasattr(self, 'wld_ax') or len(self.wld_ax.lines) == 0 and len(self.wld_ax.collections) == 0:
                messagebox.showwarning("警告", "请先在水位流量关系图标签页绘制图表！")
                return
            
            # 获取当前图表数据
            current_data = {
                'discharges': self.water_level_discharge_data['discharges'],
                'water_levels': self.water_level_discharge_data['water_levels'],
                'return_periods': self.water_level_discharge_data['return_periods'],
                'bank_elevation': self.water_level_discharge_data['bank_elevation'],
                'bridge_bottom_elevation': self.water_level_discharge_data['bridge_bottom_elevation'],
                'bridge_name': self.water_level_discharge_data['bridge_name'],
                'title': f"图表{len(self.compare_charts_data) + 1}: {self.water_level_discharge_data['bridge_name']}"
            }
            
            # 添加到对比列表
            self.compare_charts_data.append(current_data)
            
            # 更新图表列表框
            self.chart_listbox.insert(tk.END, current_data['title'])
            
            messagebox.showinfo("成功", "图表已添加到对比列表！")
        except Exception as e:
            messagebox.showerror("错误", f"添加图表失败：{e}")
    
    def remove_selected_chart(self):
        """移除选中的图表"""
        try:
            selected_index = self.chart_listbox.curselection()
            if not selected_index:
                messagebox.showwarning("警告", "请先选择要移除的图表！")
                return
            
            # 移除选中的图表
            index = selected_index[0]
            self.chart_listbox.delete(index)
            del self.compare_charts_data[index]
            
            messagebox.showinfo("成功", "图表已移除！")
        except Exception as e:
            messagebox.showerror("错误", f"移除图表失败：{e}")
    
    def clear_chart_list(self):
        """清空图表列表"""
        try:
            self.chart_listbox.delete(0, tk.END)
            self.compare_charts_data.clear()
            messagebox.showinfo("成功", "图表列表已清空！")
        except Exception as e:
            messagebox.showerror("错误", f"清空图表列表失败：{e}")
    
    def plot_compare_charts(self):
        """绘制对比图表"""
        try:
            compare_type = self.compare_type_var.get()
            
            # 清空当前图表
            self.compare_ax.clear()
            
            if compare_type == "history":
                self._plot_history_comparison()
            elif compare_type == "hydrograph":
                self._plot_hydrograph_comparison()
            else:
                self._plot_flood_level_comparison()
            
            # 更新图表
            self.compare_canvas.draw()
        except Exception as e:
            messagebox.showerror("绘图错误", f"绘制对比图表失败：{e}")
    
    def _plot_flood_level_comparison(self):
        """绘制水位流量关系图对比"""
        if len(self.compare_charts_data) < 2:
            messagebox.showwarning("警告", "至少需要2个图表才能进行对比！")
            return
        
        # 设置颜色循环
        colors = plt.cm.viridis(np.linspace(0, 1, len(self.compare_charts_data)))
        
        # 绘制每个图表的数据
        for i, chart_data in enumerate(self.compare_charts_data):
            color = colors[i]
            
            # 绘制数据点
            if chart_data['discharges'] and chart_data['water_levels']:
                self.compare_ax.scatter(
                    chart_data['discharges'], 
                    chart_data['water_levels'], 
                    s=80, 
                    c=[color], 
                    label=chart_data['title'],
                    edgecolors='black',
                    linewidth=1.0,
                    zorder=3
                )
                
                # 绘制拟合曲线（如果有多个数据点）
                if len(chart_data['discharges']) >= 3:
                    def power_func(Q, a, b, c):
                        return a * Q**b + c
                    
                    try:
                        from scipy.optimize import curve_fit
                        popt, pcov = curve_fit(
                            power_func, 
                            chart_data['discharges'], 
                            chart_data['water_levels'],
                            p0=[0.001, 1.0, min(chart_data['water_levels']) - 0.2],
                            maxfev=2000
                        )
                        a, b, c = popt
                        
                        # 生成拟合曲线数据
                        Q_min = max(0, min(chart_data['discharges']) - 5)
                        Q_max = max(chart_data['discharges']) + 5
                        Q_fit = np.linspace(Q_min, Q_max, 100)
                        Z_fit = power_func(Q_fit, a, b, c)
                        
                        # 绘制拟合曲线
                        self.compare_ax.plot(
                            Q_fit, 
                            Z_fit, 
                            color=color,
                            linewidth=2.0,
                            linestyle='--',
                            zorder=2
                        )
                    except Exception as e:
                        print(f"拟合曲线绘制失败：{e}")
        
        # 设置图表属性
        self.compare_ax.set_xlabel('洪峰流量 Q (m3/s)', fontsize=14, fontweight='bold', labelpad=10)
        self.compare_ax.set_ylabel('高程 Z (m)', fontsize=14, fontweight='bold', labelpad=10)
        self.compare_ax.set_title('水位流量关系图对比', fontsize=16, fontweight='bold', pad=20)
        
        # 设置图例
        self.compare_ax.legend(loc='best', fontsize=10, framealpha=0.95)
        
        # 设置网格
        self.compare_ax.grid(True, alpha=0.3, linestyle='--')
        
        # 设置坐标轴样式
        for spine in self.compare_ax.spines.values():
            spine.set_linewidth(1.5)
        
        # 调整布局
        self.compare_fig.tight_layout()
    
    def _plot_hydrograph_comparison(self):
        """绘制洪水过程线对比"""
        if len(self.compare_charts_data) < 2:
            messagebox.showwarning("警告", "至少需要2个图表才能进行对比！")
            return
        
        # 清空当前图形
        self.compare_ax.clear()
        
        # 设置颜色循环
        colors = plt.cm.Set1(np.linspace(0, 1, len(self.compare_charts_data)))
        
        # 绘制每个图表的数据
        for i, chart_data in enumerate(self.compare_charts_data):
            color = colors[i]
            
            # 绘制过程线
            if chart_data.get('time_list') and chart_data.get('discharge_list'):
                time_list = chart_data['time_list']
                discharge_list = chart_data['discharge_list']
                
                # 绘制洪水过程线
                self.compare_ax.plot(
                    time_list, 
                    discharge_list, 
                    color=color,
                    linewidth=2.5,
                    label=chart_data['title'],
                    zorder=3
                )
                
                # 添加面积填充
                self.compare_ax.fill_between(
                    time_list, 
                    0, 
                    discharge_list, 
                    color=color,
                    alpha=0.2,
                    zorder=2
                )
                
                # 计算并显示洪峰流量
                if discharge_list:
                    peak_q = max(discharge_list)
                    peak_time = time_list[discharge_list.index(peak_q)]
                    # 添加洪峰标记
                    self.compare_ax.scatter(
                        peak_time, 
                        peak_q, 
                        color=color,
                        s=150,
                        marker='*',
                        edgecolors='black',
                        linewidth=1.5,
                        zorder=4
                    )
                    # 添加洪峰标注
                    self.compare_ax.annotate(
                        f'洪峰: {peak_q:.1f} m³/s\n时间: {peak_time:.1f}h',
                        (peak_time, peak_q),
                        xytext=(10, 10),
                        textcoords='offset points',
                        fontsize=10,
                        fontweight='bold',
                        color=color,
                        bbox=dict(boxstyle='round,pad=0.5', facecolor='white', alpha=0.9, edgecolor='gray'),
                        zorder=5
                    )
        
        # 设置图表属性
        self.compare_ax.set_xlabel('时间 (h)', fontsize=14, fontweight='bold', labelpad=10, color='#2c3e50')
        self.compare_ax.set_ylabel('流量 Q (m³/s)', fontsize=14, fontweight='bold', labelpad=10, color='#2c3e50')
        self.compare_ax.set_title('洪水过程线对比', fontsize=18, fontweight='bold', pad=20, color='#2c3e50')
        
        # 设置网格
        self.compare_ax.grid(True, which='major', alpha=0.3, linestyle='-', linewidth=0.8, color='#bdc3c7')
        self.compare_ax.grid(True, which='minor', alpha=0.1, linestyle='--', linewidth=0.4, color='#bdc3c7')
        
        # 添加次要刻度
        self.compare_ax.minorticks_on()
        
        # 设置坐标轴样式
        for spine in self.compare_ax.spines.values():
            spine.set_linewidth(1.5)
            spine.set_color('#2c3e50')
        
        # 设置刻度标签字体
        self.compare_ax.tick_params(axis='both', which='major', labelsize=12, width=1, length=6, direction='out', colors='#2c3e50')
        self.compare_ax.tick_params(axis='both', which='minor', width=0.5, length=3, direction='out', colors='#7f8c8d')
        
        # 设置图例
        self.compare_ax.legend(loc='upper right', fontsize=10, framealpha=0.95, frameon=True, 
                             borderpad=0.5, labelspacing=0.3, ncol=1, fancybox=True, 
                             handlelength=2.0, handletextpad=0.8, edgecolor='#7f8c8d', 
                             title='图例', title_fontsize=11, title_weight='bold')
        
        # 添加图表背景色
        self.compare_ax.set_facecolor('#ffffff')
        self.compare_fig.patch.set_facecolor('#f8f9fa')
        
        # 调整布局
        self.compare_fig.subplots_adjust(left=0.12, right=0.98, top=0.92, bottom=0.12, wspace=0.2, hspace=0.2)
        
        # 更新图表
        self.compare_canvas.draw()
    
    def _plot_history_comparison(self):
        """绘制历史洪水对比"""
        try:
            # 获取输入参数
            years_str = self.history_years_var.get().strip()
            q_str = self.history_q_var.get().strip()
            z_str = self.history_z_var.get().strip()
            design_q = float(self.design_q_var.get())
            design_z = float(self.design_z_var.get())
            
            # 解析历史数据
            years = list(map(int, years_str.split()))
            history_q = list(map(float, q_str.split()))
            history_z = list(map(float, z_str.split()))
            
            # 验证数据长度
            if len(years) != len(history_q) or len(years) != len(history_z):
                messagebox.showerror("数据错误", "历史洪水数据长度不一致！")
                return
            
            # 设置颜色循环
            colors = plt.cm.viridis(np.linspace(0, 1, len(years) + 1))
            
            # 绘制历史洪水数据点
            for i, (year, q, z) in enumerate(zip(years, history_q, history_z)):
                color = colors[i]
                self.compare_ax.scatter(
                    q, 
                    z, 
                    s=150, 
                    c=[color], 
                    label=f'{year}年洪水',
                    edgecolors='black',
                    linewidth=1.5,
                    zorder=3
                )
                # 添加年份标注
                self.compare_ax.annotate(
                    f'{year}',
                    (q, z),
                    xytext=(5, 5),
                    textcoords='offset points',
                    fontsize=10,
                    fontweight='bold'
                )
            
            # 绘制设计洪水点
            design_color = colors[-1]
            self.compare_ax.scatter(
                design_q, 
                design_z, 
                s=200, 
                c=[design_color], 
                label='设计洪水',
                edgecolors='red',
                linewidth=2.0,
                zorder=4,
                marker='*'
            )
            
            # 绘制趋势线
            all_q = history_q + [design_q]
            all_z = history_z + [design_z]
            if len(all_q) >= 2:
                try:
                    from scipy.optimize import curve_fit
                    def power_func(Q, a, b, c):
                        return a * Q**b + c
                    
                    popt, pcov = curve_fit(
                        power_func, 
                        all_q, 
                        all_z,
                        p0=[0.001, 1.0, min(all_z) - 0.2],
                        maxfev=2000
                    )
                    a, b, c = popt
                    
                    # 生成拟合曲线数据
                    Q_min = max(0, min(all_q) - 5)
                    Q_max = max(all_q) + 5
                    Q_fit = np.linspace(Q_min, Q_max, 100)
                    Z_fit = power_func(Q_fit, a, b, c)
                    
                    # 绘制拟合曲线
                    self.compare_ax.plot(
                        Q_fit, 
                        Z_fit, 
                        color='gray',
                        linewidth=1.5,
                        linestyle='--',
                        alpha=0.7,
                        label='趋势线'
                    )
                except Exception as e:
                    print(f"趋势线绘制失败：{e}")
            
            # 设置图表属性
            self.compare_ax.set_xlabel('洪峰流量 Q (m3/s)', fontsize=14, fontweight='bold', labelpad=10)
            self.compare_ax.set_ylabel('洪水位 Z (m)', fontsize=14, fontweight='bold', labelpad=10)
            self.compare_ax.set_title('历史洪水与设计洪水对比', fontsize=16, fontweight='bold', pad=20)
            
            # 设置图例
            self.compare_ax.legend(loc='best', fontsize=10, framealpha=0.95)
            
            # 设置网格
            self.compare_ax.grid(True, alpha=0.3, linestyle='--')
            
            # 设置坐标轴样式
            for spine in self.compare_ax.spines.values():
                spine.set_linewidth(1.5)
            
            # 调整布局
            self.compare_fig.tight_layout()
            
        except ValueError as e:
            messagebox.showerror("数据错误", f"输入数据格式错误：{e}")
        except Exception as e:
            messagebox.showerror("绘图错误", f"绘制历史洪水对比失败：{e}")
    
    def export_compare_charts(self):
        """导出对比图表"""
        try:
            # 确保output/plots目录存在
            import os
            os.makedirs('output/plots', exist_ok=True)
            
            file_path = filedialog.asksaveasfilename(
                defaultextension=".png",
                filetypes=[
                    ("PNG图片", "*.png"), 
                    ("JPEG图片", "*.jpg"), 
                    ("PDF文件", "*.pdf"),
                    ("SVG矢量图", "*.svg"),
                    ("EPS矢量图", "*.eps"),
                    ("TIFF图片", "*.tiff")
                ],
                initialdir="output/plots"
            )
            if file_path:
                self.compare_fig.savefig(
                    file_path, 
                    dpi=300, 
                    bbox_inches='tight', 
                    pad_inches=0.1,
                    facecolor='white',
                    edgecolor='none'
                )
                messagebox.showinfo("导出成功", f"对比图表已成功导出到 {file_path}！")
        except Exception as e:
            messagebox.showerror("导出错误", f"导出对比图表失败：{e}")
    
    def import_design_flood_to_flood_level(self):
        """导入设计洪水计算结果到洪水位计算"""
        try:
            # 检查是否有设计洪水计算结果
            if not self.design_flood_data['design_results']:
                messagebox.showwarning("警告", "请先进行设计洪水计算！")
                return
            
            # 提取设计洪峰流量、频率和重现期
            design_results = self.design_flood_data['design_results']
            design_q_list = [result['qp'] for result in design_results]
            design_freq_list = [result['frequency'] for result in design_results]
            design_return_period_list = [result['return_period'] for result in design_results]
            
            # 将设计洪峰流量转换为字符串格式（空格分隔）
            q_list_str = ' '.join([f"{q:.1f}" for q in design_q_list])
            
            # 设置到洪水位计算的设计洪峰流量输入框
            self.q_list_entry.delete(0, tk.END)
            self.q_list_entry.insert(0, q_list_str)
            
            # 保存频率和重现期信息，供洪水位计算使用
            self.design_flood_frequencies = design_freq_list
            self.design_flood_return_periods = design_return_period_list
            
            messagebox.showinfo("成功", "设计洪水计算结果已导入到洪水位计算！")
        except Exception as e:
            messagebox.showerror("错误", f"导入设计洪水计算结果失败：{e}")
    
    def import_flood_level_to_wld(self):
        """导入洪水位计算结果到水位流量关系图"""
        try:
            # 检查是否有洪水位计算结果
            if not self.flood_level_data['results']:
                messagebox.showwarning("警告", "请先进行洪水位计算！")
                return
            
            # 提取洪峰流量、水位数据、频率和重现期
            discharges = [result['q'] for result in self.flood_level_data['results']]
            water_levels = [result['flood_elevation'] for result in self.flood_level_data['results']]
            
            # 使用洪水位计算结果中的重现期，如果没有则使用默认值
            return_periods = []
            for result in self.flood_level_data['results']:
                if result['return_period'] is not None:
                    return_periods.append(str(result['return_period']))
                else:
                    return_periods.append(str(len(return_periods) + 1))
            
            bank_elevation = self.flood_level_data['params']['bank_elevation']
            
            # 设置到水位流量关系图的输入框
            self.wld_bank_elevation_entry.delete(0, tk.END)
            self.wld_bank_elevation_entry.insert(0, str(bank_elevation))
            
            self.wld_discharges_entry.delete(0, tk.END)
            self.wld_discharges_entry.insert(0, ' '.join([f"{q:.1f}" for q in discharges]))
            
            self.wld_water_levels_entry.delete(0, tk.END)
            self.wld_water_levels_entry.insert(0, ' '.join([f"{z:.2f}" for z in water_levels]))
            
            self.wld_return_periods_entry.delete(0, tk.END)
            self.wld_return_periods_entry.insert(0, ' '.join(return_periods))
            
            messagebox.showinfo("成功", "洪水位计算结果已导入到水位流量关系图！")
        except Exception as e:
            messagebox.showerror("错误", f"导入洪水位计算结果失败：{e}")
    
    def batch_calculate_design_flood(self):
        """批量计算设计洪水"""
        try:
            # 打开文件对话框，选择包含多个参数配置的JSON文件
            file_path = filedialog.askopenfilename(
                defaultextension=".json",
                filetypes=[("JSON文件", "*.json"), ("所有文件", "*.*")],
                title="选择批量计算参数文件"
            )
            
            if not file_path:
                return
            
            # 加载批量计算参数
            import json
            with open(file_path, "r", encoding="utf-8") as f:
                batch_params = json.load(f)
            
            # 检查参数格式
            if not isinstance(batch_params, list):
                messagebox.showerror("错误", "批量计算参数文件必须是JSON数组格式")
                return
            
            if len(batch_params) == 0:
                messagebox.showerror("错误", "批量计算参数文件不能为空")
                return
            
            # 显示进度条
            total_params = len(batch_params)
            self.show_progress("批量计算设计洪水", total_params)
            
            # 执行批量计算
            batch_results = []
            for i, params in enumerate(batch_params):
                try:
                    # 更新进度条
                    self.update_progress(i, f"正在计算第 {i+1}/{total_params} 组参数...")
                    
                    # 设置当前参数
                    self.flood_type_var.set(params.get("flood_type", "泼机河型"))
                    self.area_entry.delete(0, tk.END)
                    self.area_entry.insert(0, params.get("area", ""))
                    self.pd24_entry.delete(0, tk.END)
                    self.pd24_entry.insert(0, params.get("pd24", ""))
                    self.c_entry.delete(0, tk.END)
                    self.c_entry.insert(0, params.get("c", ""))
                    self.n_exp_entry.delete(0, tk.END)
                    self.n_exp_entry.insert(0, params.get("n_exp", ""))
                    self.cv_q_entry.delete(0, tk.END)
                    self.cv_q_entry.insert(0, params.get("cv_q", ""))
                    self.cv_w24_entry.delete(0, tk.END)
                    self.cv_w24_entry.insert(0, params.get("cv_w24", ""))
                    self.frequencies_entry.delete(0, tk.END)
                    self.frequencies_entry.insert(0, params.get("frequencies", ""))
                    
                    # 执行计算
                    self.calculate_design_flood()
                    
                    # 保存结果
                    batch_results.append({
                        "params": params,
                        "results": self.design_flood_data.copy()
                    })
                    
                    # 更新进度
                    self.root.update_idletasks()
                except Exception as e:
                    messagebox.showwarning("警告", f"第 {i+1} 组参数计算失败：{e}")
                    continue
            
            # 更新进度条为完成状态
            self.update_progress(total_params, "批量计算完成！")
            
            # 保存批量计算结果
            if batch_results:
                save_path = filedialog.asksaveasfilename(
                    defaultextension=".json",
                    filetypes=[("JSON文件", "*.json"), ("所有文件", "*.*")],
                    initialfile="batch_design_flood_results.json"
                )
                
                if save_path:
                    with open(save_path, "w", encoding="utf-8") as f:
                        json.dump(batch_results, f, ensure_ascii=False, indent=2)
            
            # 隐藏进度条
            self.hide_progress()
            
            # 显示结果
            if batch_results:
                messagebox.showinfo("成功", f"批量计算完成，共计算 {len(batch_results)} 组参数，结果已保存到 {save_path}")
            else:
                messagebox.showinfo("结果", "批量计算完成，但没有成功的计算结果")
        except Exception as e:
            # 隐藏进度条
            self.hide_progress()
            messagebox.showerror("错误", f"批量计算失败：{e}")