pqAutomationApp/app/runner/test_runner.py

"""测试执行（runner）相关逻辑（Step 5 重构）。

从 pqAutomationApp.PQAutomationApp 中搬迁。每个函数第一行 `self = app`
以保留原有 `self.xxx` 属性访问不变。
"""

import datetime
import time
import traceback
from tkinter import messagebox
import tkinter as tk

import colour
import numpy as np

import algorithm.pq_algorithm as pq_algorithm
from utils.data_range_converter import convert_pattern_params
from utils.pq.pq_result import PQResult

def new_pq_results(self, test_type, test_name):
    self.results = PQResult(test_type, test_name)
    # 设置配置
    config = {
        "test_type": test_type,
        "test_name": test_name,
        "test_items": self.config.current_test_types[test_type]["test_items"],
        "test_items_chinese": self.config.get_test_item_chinese_names(
            self.config.current_test_types[test_type]["test_items"]
        ),
    }
    self.results.set_test_config(config)

    # 添加测试项
    for item in config["test_items"]:
        self.results.add_test_item(
            item, config["test_items_chinese"][config["test_items"].index(item)]
        )


def run_test(self, test_type, test_items):
    """执行测试"""
    try:
        self.log_gui.log(f"开始执行{self.get_test_type_name(test_type)}测试")
        self.log_gui.log(
            f"测试项目: {', '.join(self.config.get_test_item_chinese_names(test_items))}"
        )

        # 根据测试类型执行不同的测试流程
        if test_type == "screen_module":
            self.run_screen_module_test(test_items)
        elif test_type == "sdr_movie":
            self.run_sdr_movie_test(test_items)
        elif test_type == "hdr_movie":
            self.run_hdr_movie_test(test_items)

        # 测试完成后更新UI状态
        if self.testing:  # 如果没有被中途停止
            self.root.after(0, self.on_test_completed)
    except Exception as e:
        self.log_gui.log(f"测试过程中发生错误: {str(e)}")
        import traceback

        self.log_gui.log(traceback.format_exc())
        self.root.after(0, self.on_test_error)


def run_screen_module_test(self, test_items):
    """执行屏模组性能测试 - 优化版"""
    self.log_gui.log("执行屏模组性能测试...")

    if test_items:
        self.new_pq_results("screen_module", "屏模组性能测试")
    else:
        self.log_gui.log("未选择任何测试项目")
        return

    # 判断是否需要灰阶数据
    needs_gray_data = any(
        item in test_items for item in ["gamma", "cct", "contrast"]
    )
    shared_gray_data = None  # 共享的灰阶数据

    # 计算总测试项数量
    total_items = len(test_items)
    current_item = 0

    for item in test_items:
        if not self.testing:  # 检查是否被停止
            return

        current_item += 1
        self.status_var.set(f"测试进行中... ({current_item}/{total_items})")

        # ==================== 色域测试 ====================
        if item == "gamut":
            self.test_gamut("screen_module")

        # ==================== 灰阶数据采集 ====================
        # 如果是第一个需要灰阶数据的测试项，统一采集数据
        elif (
            item in ["gamma", "cct", "contrast"]
            and shared_gray_data is None
            and needs_gray_data
        ):
            self.log_gui.log("=" * 50)
            self.log_gui.log("开始统一采集灰阶数据（用于 Gamma/CCT/对比度测试）")
            self.log_gui.log("=" * 50)

            shared_gray_data = self.send_fix_pattern("gray")

            if not shared_gray_data or len(shared_gray_data) < 2:
                self.log_gui.log("灰阶数据采集失败或数据不足，跳过相关测试")
                return

            self.log_gui.log(
                f"✓ 灰阶数据采集完成，共 {len(shared_gray_data)} 个数据点"
            )

            # 保存到 results 对象，供所有灰阶测试使用
            self.results.add_intermediate_data("shared", "gray", shared_gray_data)

            # 执行当前测试项
            if item == "gamma":
                self.test_gamma("screen_module", shared_gray_data)
            elif item == "cct":
                self.test_cct("screen_module", shared_gray_data)
            elif item == "contrast":
                self.test_contrast("screen_module", shared_gray_data)

        # ==================== 后续灰阶测试（复用数据） ====================
        elif item in ["gamma", "cct", "contrast"] and shared_gray_data is not None:
            self.log_gui.log(f"复用已采集的灰阶数据进行 {item} 测试")

            if item == "gamma":
                self.test_gamma("screen_module", shared_gray_data)
            elif item == "cct":
                self.test_cct("screen_module", shared_gray_data)
            elif item == "contrast":
                self.test_contrast("screen_module", shared_gray_data)


def run_custom_sdr_test(self, test_items):
    """执行客户定制 SDR 测试 - 升级版"""
    self.log_gui.log("执行客户定制 SDR 测试...")
    # 获取信号格式设置
    color_space = self.sdr_color_space_var.get()  # BT.709/BT.601/BT.2020
    gamma_type = self.sdr_gamma_type_var.get()  # 2.2/2.4/2.6
    data_range = self.sdr_data_range_var.get()  # Full/Limited
    bit_depth = self.sdr_bit_depth_var.get()  # 8bit/10bit/12bit

    self.log_gui.log(f"信号格式: 色彩空间={color_space}, Gamma={gamma_type}")
    self.log_gui.log(f"          数据范围={data_range}, 编码位深={bit_depth}")
    self.log_gui.log("开始统一采集灰阶数据（用于 Gamma/CCT/对比度测试）")
    self.test_custom_sdr()

    if self.testing:
        self.root.after(0, self.on_custom_template_test_completed)


def run_sdr_movie_test(self, test_items):
    """执行SDR Movie测试"""
    self.log_gui.log("执行SDR Movie测试...")

    if test_items:
        self.new_pq_results("sdr_movie", "SDR Movie测试")
    else:
        self.log_gui.log("未选择任何测试项目")
        return

    # 获取信号格式设置
    color_space = self.sdr_color_space_var.get()  # BT.709/BT.601/BT.2020
    gamma_type = self.sdr_gamma_type_var.get()  # 2.2/2.4/2.6
    data_range = self.sdr_data_range_var.get()  # Full/Limited
    bit_depth = self.sdr_bit_depth_var.get()  # 8bit/10bit/12bit

    self.log_gui.log(f"信号格式: 色彩空间={color_space}, Gamma={gamma_type}")
    self.log_gui.log(f"          数据范围={data_range}, 编码位深={bit_depth}")

    # 判断是否需要灰阶数据
    needs_gray_data = any(
        item in test_items for item in ["gamma", "cct", "contrast"]
    )
    shared_gray_data = None

    # 计算总测试项数量
    total_items = len(test_items)
    current_item = 0

    for item in test_items:
        if not self.testing:
            return

        current_item += 1
        self.status_var.set(f"测试进行中... ({current_item}/{total_items})")

        if item == "gamut":
            self.test_gamut("sdr_movie")

        elif (
            item in ["gamma", "cct", "contrast"]
            and shared_gray_data is None
            and needs_gray_data
        ):
            self.log_gui.log("开始统一采集灰阶数据（用于 Gamma/CCT/对比度测试）")
            shared_gray_data = self.send_fix_pattern("gray")

            if not shared_gray_data or len(shared_gray_data) < 2:
                self.log_gui.log("灰阶数据采集失败或数据不足")
                return

            self.results.add_intermediate_data("shared", "gray", shared_gray_data)

            if item == "gamma":
                self.test_gamma("sdr_movie", shared_gray_data)
            elif item == "cct":
                self.test_cct("sdr_movie", shared_gray_data)
            elif item == "contrast":
                self.test_contrast("sdr_movie", shared_gray_data)

        elif item in ["gamma", "cct", "contrast"] and shared_gray_data is not None:
            self.log_gui.log(f"复用已采集的灰阶数据进行 {item} 测试")
            if item == "gamma":
                self.test_gamma("sdr_movie", shared_gray_data)
            elif item == "cct":
                self.test_cct("sdr_movie", shared_gray_data)
            elif item == "contrast":
                self.test_contrast("sdr_movie", shared_gray_data)

        elif item == "accuracy":
            self.test_color_accuracy("sdr_movie")


def run_hdr_movie_test(self, test_items):
    """执行HDR Movie测试"""
    self.log_gui.log("执行HDR Movie测试...")

    if test_items:
        self.new_pq_results("hdr_movie", "HDR Movie测试")
    else:
        self.log_gui.log("未选择任何测试项目")
        return

    # 获取信号格式设置
    color_space = self.hdr_color_space_var.get()
    max_cll = self.hdr_maxcll_var.get()
    max_fall = self.hdr_maxfall_var.get()
    data_range = self.hdr_data_range_var.get()
    bit_depth = self.hdr_bit_depth_var.get()

    self.log_gui.log(f"信号格式: 色彩空间={color_space}")
    self.log_gui.log(f"          MaxCLL={max_cll}, MaxFALL={max_fall}")
    self.log_gui.log(f"          数据范围={data_range}, 编码位深={bit_depth}")

    # 判断是否需要灰阶数据
    needs_gray_data = any(
        item in test_items for item in ["eotf", "cct", "contrast"]
    )
    shared_gray_data = None

    # 计算总测试项数量
    total_items = len(test_items)
    current_item = 0

    for item in test_items:
        if not self.testing:
            return

        current_item += 1
        self.status_var.set(f"测试进行中... ({current_item}/{total_items})")

        if item == "gamut":
            self.test_gamut("hdr_movie")

        elif (
            item in ["eotf", "cct", "contrast"]
            and shared_gray_data is None
            and needs_gray_data
        ):
            self.log_gui.log("开始统一采集灰阶数据（用于 EOTF/CCT/对比度测试）")
            shared_gray_data = self.send_fix_pattern("gray")

            if not shared_gray_data or len(shared_gray_data) < 2:
                self.log_gui.log("灰阶数据采集失败或数据不足")
                return

            self.results.add_intermediate_data("shared", "gray", shared_gray_data)

            if item == "eotf":
                self.test_eotf("hdr_movie", shared_gray_data)
            elif item == "cct":
                self.test_cct("hdr_movie", shared_gray_data)
            elif item == "contrast":
                self.test_contrast("hdr_movie", shared_gray_data)

        elif item in ["eotf", "cct", "contrast"] and shared_gray_data is not None:
            self.log_gui.log(f"复用已采集的灰阶数据进行 {item} 测试")
            if item == "eotf":
                self.test_eotf("hdr_movie", shared_gray_data)
            elif item == "cct":
                self.test_cct("hdr_movie", shared_gray_data)
            elif item == "contrast":
                self.test_contrast("hdr_movie", shared_gray_data)

        elif item == "accuracy":
            self.test_color_accuracy("hdr_movie")


def send_fix_pattern(self, mode):
    """发送固定图案并采集数据 - 支持不同测试类型的信号格式"""
    results = []

    try:
        # 1. 设置图案模式
        if mode == "rgb":
            self.config.set_current_pattern("rgb")
        elif mode == "gray":
            self.config.set_current_pattern("gray")
        elif mode == "accuracy":  # 色准模式（SDR 和 HDR 通用 29色）
            self.config.set_current_pattern("accuracy")
        elif mode == "custom":
            self.config.set_current_pattern("custom")
        else:
            self.log_gui.log(f"❌ 未知的图案模式: {mode}")
            return None

        # 2. 获取当前测试类型
        test_type = self.config.current_test_type

        # 3. 根据测试类型设置信号格式和图案
        if test_type == "screen_module":
            # 屏模组测试：使用 Timing
            self.log_gui.log("=" * 50)
            self.log_gui.log("设置屏模组信号格式:")
            self.log_gui.log("=" * 50)

            timing_str = self.config.current_test_types[test_type]["timing"]
            self.log_gui.log(f"  Timing: {timing_str}")

            # ✅ 屏模组测试：直接使用原始配置
            self.ucd.set_ucd_params(self.config)

        elif test_type == "sdr_movie":
            # SDR 测试：设置色彩空间、Gamma 等
            self.log_gui.log("=" * 50)
            self.log_gui.log("设置 SDR 信号格式:")
            self.log_gui.log("=" * 50)

            color_space = self.sdr_color_space_var.get()
            gamma = self.sdr_gamma_type_var.get()
            data_range = self.sdr_data_range_var.get()
            bit_depth = self.sdr_bit_depth_var.get()

            self.log_gui.log(f"  色彩空间: {color_space}")
            self.log_gui.log(f"  Gamma: {gamma}")
            self.log_gui.log(f"  数据范围: {data_range}")
            self.log_gui.log(f"  编码位深: {bit_depth}")

            success = self.ucd.set_sdr_format(
                color_space=color_space,
                gamma=gamma,
                data_range=data_range,
                bit_depth=bit_depth,
            )

            if success:
                self.log_gui.log("✓ SDR 信号格式设置成功")
            else:
                self.log_gui.log("✗ SDR 信号格式设置失败")

            # 设置图案参数
            if mode == "accuracy":
                self.log_gui.log(f"设置 SDR 29色色准测试图案...")
            else:
                self.log_gui.log(f"设置 SDR 测试图案（{mode} 模式）...")

            # ========== ✅✅✅ 修改：使用临时配置对象 ==========
            import copy

            # 从原始配置获取参数（每次都是干净的）
            if mode == "rgb":
                original_params = copy.deepcopy(
                    self.config.default_pattern_rgb["pattern_params"]
                )
            elif mode == "gray":
                original_params = copy.deepcopy(
                    self.config.default_pattern_gray["pattern_params"]
                )
            elif mode == "accuracy":
                original_params = copy.deepcopy(
                    self.config.default_pattern_accuracy["pattern_params"]
                )
            elif mode == "custom":
                original_params = copy.deepcopy(
                    self.config.default_pattern_temp["pattern_params"]
                )

            self.log_gui.log(f"🔍 使用原始 RGB 参数（前 3 个）:")
            for i in range(min(3, len(original_params))):
                self.log_gui.log(f"  [{i+1}] {original_params[i]}")

            # 根据 data_range 转换
            converted_params = convert_pattern_params(
                pattern_params=original_params, data_range=data_range, verbose=False
            )

            if data_range == "Limited":
                self.log_gui.log("🔧 转换为 Limited Range (16-235):")
                for i in range(min(3, len(converted_params))):
                    self.log_gui.log(
                        f"  {original_params[i]} → {converted_params[i]}"
                    )
            else:
                self.log_gui.log("✓ Full Range，RGB 保持不变")

            # ✅ 创建临时配置对象（不修改 self.config）
            temp_config = self.config.get_temp_config_with_converted_params(
                mode=mode, converted_params=converted_params
            )

            # ✅ 使用临时配置设置参数
            self.ucd.set_ucd_params(temp_config)

            self.log_gui.log(f"✓ 图案参数已设置，共 {len(converted_params)} 个图案")
            # ========== 修改结束 ==========

        elif test_type == "hdr_movie":
            # HDR 测试：设置色彩空间、Metadata 等
            self.log_gui.log("=" * 50)
            self.log_gui.log("设置 HDR 信号格式:")
            self.log_gui.log("=" * 50)

            color_space = self.hdr_color_space_var.get()
            data_range = self.hdr_data_range_var.get()
            bit_depth = self.hdr_bit_depth_var.get()
            max_cll = self.hdr_maxcll_var.get()
            max_fall = self.hdr_maxfall_var.get()

            self.log_gui.log(f"  色彩空间: {color_space}")
            self.log_gui.log(f"  数据范围: {data_range}")
            self.log_gui.log(f"  编码位深: {bit_depth}")
            self.log_gui.log(f"  MaxCLL: {max_cll}")
            self.log_gui.log(f"  MaxFALL: {max_fall}")

            success = self.ucd.set_hdr_format(
                color_space=color_space,
                data_range=data_range,
                bit_depth=bit_depth,
                max_cll=max_cll,
                max_fall=max_fall,
            )

            if success:
                self.log_gui.log("✓ HDR 信号格式设置成功")
            else:
                self.log_gui.log("✗ HDR 信号格式设置失败")

            # 设置图案参数
            if mode == "accuracy":
                self.log_gui.log(f"设置 HDR 29色色准测试图案...")
            else:
                self.log_gui.log(f"设置 HDR 测试图案（{mode} 模式）...")

            # ========== ✅✅✅ 修改：使用临时配置对象 ==========
            import copy

            # 从原始配置获取参数
            if mode == "rgb":
                original_params = copy.deepcopy(
                    self.config.default_pattern_rgb["pattern_params"]
                )
            elif mode == "gray":
                original_params = copy.deepcopy(
                    self.config.default_pattern_gray["pattern_params"]
                )
            elif mode == "accuracy":
                original_params = copy.deepcopy(
                    self.config.default_pattern_accuracy["pattern_params"]
                )

            self.log_gui.log(f"🔍 使用原始 RGB 参数（前 3 个）:")
            for i in range(min(3, len(original_params))):
                self.log_gui.log(f"  [{i+1}] {original_params[i]}")

            # 根据 data_range 转换
            converted_params = convert_pattern_params(
                pattern_params=original_params, data_range=data_range, verbose=False
            )

            if data_range == "Limited":
                self.log_gui.log("🔧 转换为 Limited Range (16-235):")
                for i in range(min(3, len(converted_params))):
                    self.log_gui.log(
                        f"  {original_params[i]} → {converted_params[i]}"
                    )
            else:
                self.log_gui.log("✓ Full Range，RGB 保持不变")

            # ✅ 创建临时配置对象
            temp_config = self.config.get_temp_config_with_converted_params(
                mode=mode, converted_params=converted_params
            )

            self.ucd.set_ucd_params(temp_config)

            self.log_gui.log(f"✓ 图案参数已设置，共 {len(converted_params)} 个图案")
            # ========== 修改结束 ==========

        self.log_gui.log("=" * 50)

        # 4. 循环发送图案并采集数据（使用原始配置的数量）
        total_patterns = len(self.config.current_pattern["pattern_params"])
        self.log_gui.log(f"开始采集数据，共 {total_patterns} 个图案")
        settle_time = max(0.2, float(getattr(self, "pattern_settle_time", 1.0)))
        progress_step = max(
            1, int(getattr(self, "pattern_progress_log_step", 5))
        )
        self.log_gui.log(
            f"采集等待时间: {settle_time:.2f}s（可通过 pattern_settle_time 调整）"
        )

        # 获取颜色名称列表（用于日志显示）
        color_names = None
        if mode == "accuracy":
            color_names = self.config.get_accuracy_color_names()

        custom_pattern_names = []
        if mode == "custom" and hasattr(self.config, "get_temp_pattern_names"):
            custom_pattern_names = self.config.get_temp_pattern_names()

        for i in range(total_patterns):
            if not self.testing:
                self.log_gui.log("⚠️ 测试已停止")
                return results

            should_log_detail = (
                i == 0
                or (i + 1) == total_patterns
                or ((i + 1) % progress_step == 0)
            )

            # 设置下一个图案（显示颜色名称）
            if should_log_detail:
                if color_names and i < len(color_names):
                    self.log_gui.log(
                        f"发送第 {i+1}/{total_patterns} 个图案: {color_names[i]}..."
                    )
                else:
                    self.log_gui.log(f"发送第 {i+1}/{total_patterns} 个图案...")

            self.ucd.set_next_pattern()
            self.ucd.run()
            time.sleep(settle_time)

            # 测量数据
            if mode == "custom":
                result = []
                self.ca.set_Display(1)
                tcp, duv, lv, X, Y, Z = self.ca.readAllDisplay()

                if should_log_detail:
                    self.log_gui.log(
                        f"  ✓ 测量完成: TCP={tcp:.4f}, DUV={duv:.4f}, lv={lv:.2f}, "
                        f"X={X:.4f}, Y={Y:.4f}, Z={Z:.4f}"
                    )

                self.ca.set_Display(8)
                lambda_, Pe, lv, X, Y, Z = self.ca.readAllDisplay()

                if should_log_detail:
                    self.log_gui.log(
                        f"  ✓ 测量完成: λ={lambda_:.4f}, Pe={Pe:.4f}, lv={lv:.2f}, "
                        f"X={X:.4f}, Y={Y:.4f}, Z={Z:.4f}"
                    )
                result = [tcp, duv, lv, lambda_, Pe, lv, X, Y, Z]
                results.append(result)

                # 每完成一个 pattern，实时写入客户模板结果表。
                try:
                    xy = colour.XYZ_to_xy(np.array([X, Y, Z]))
                    u_prime, v_prime, _ = colour.XYZ_to_CIE1976UCS(
                        np.array([X, Y, Z])
                    )
                    row_data = {
                        "pattern_name": (
                            custom_pattern_names[i]
                            if i < len(custom_pattern_names)
                            else f"P {i + 1}"
                        ),
                        "X": X,
                        "Y": Y,
                        "Z": Z,
                        "x": xy[0],
                        "y": xy[1],
                        "Lv": lv,
                        "u_prime": u_prime,
                        "v_prime": v_prime,
                        "Tcp": tcp,
                        "duv": duv,
                        "lambda_d": lambda_,
                        "Pe": Pe,
                    }
                    self.root.after(
                        0,
                        lambda row_no=i + 1, data=row_data: self.append_custom_template_result(
                            row_no, data
                        ),
                    )
                except Exception as e:
                    self.log_gui.log(f"⚠️ 第 {i+1} 行实时结果写入失败: {str(e)}")

            else:
                self.ca.set_xyLv_Display()

                x, y, lv, X, Y, Z = self.ca.readAllDisplay()
                results.append([x, y, lv, X, Y, Z])

                if should_log_detail:
                    self.log_gui.log(
                        f"  ✓ 测量完成: x={x:.4f}, y={y:.4f}, lv={lv:.2f}, "
                        f"X={X:.4f}, Y={Y:.4f}, Z={Z:.4f}"
                    )

        self.log_gui.log(f"✓ 数据采集完成，共 {len(results)} 组数据")
        return results

    except Exception as e:
        self.log_gui.log(f"❌ 发送图案失败: {str(e)}")
        import traceback

        self.log_gui.log(traceback.format_exc())
        return None


def test_custom_sdr(self):
    """执行客户定制 SDR 测试 - 升级版"""
    self.log_gui.log("执行客户定制 SDR 测试...")
    results = self.send_fix_pattern("custom")
    if not results:
        self.log_gui.log("客户模板SDR测试被中断")
        return

    self.log_gui.log(f"客户模板采集完成，共 {len(results)} 组数据")


def test_gamut(self, test_type):
    """测试色域"""
    self.log_gui.log("开始测试色域...")
    self.results.start_test_item("gamut")

    try:
        # 存储测量结果
        results = self.send_fix_pattern("rgb")

        # 检查结果是否为空
        if not results:
            self.log_gui.log("色域测试被中断")
            return

        self.results.add_intermediate_data("gamut", "rgb", results)

        # 计算色域覆盖率
        self.log_gui.log("计算色域覆盖率...")

        # 提取 x, y 坐标用于计算色域
        xy_points = [[result[0], result[1]] for result in results]

        # ========== ✅ 测试时：使用色彩空间的值作为参考标准 ==========
        reference_standard = None
        area = None
        coverage = None

        if test_type == "screen_module":
            # 屏模组测试：固定使用 DCI-P3（因为没有色彩空间设置）
            reference_standard = "DCI-P3"

            # ✅ 同步更新到色域参考标准变量（供后续重绘使用）
            self.screen_gamut_ref_var.set(reference_standard)

        elif test_type == "sdr_movie":
            # SDR 测试：使用色彩空间设置
            color_space = self.sdr_color_space_var.get()

            if color_space == "BT.709":
                reference_standard = "BT.709"
            elif color_space == "BT.601":
                reference_standard = "BT.601"
            elif color_space == "BT.2020":
                reference_standard = "BT.2020"
            else:
                reference_standard = "BT.709"
                self.log_gui.log(
                    f"⚠️ 未识别的色彩空间 '{color_space}'，使用默认标准 BT.709"
                )

            # ✅ 同步更新到色域参考标准变量
            self.sdr_gamut_ref_var.set(reference_standard)

        elif test_type == "hdr_movie":
            # HDR 测试：使用色彩空间设置
            color_space = self.hdr_color_space_var.get()

            if color_space == "BT.2020":
                reference_standard = "BT.2020"
            elif color_space == "DCI-P3":
                reference_standard = "DCI-P3"
            else:
                reference_standard = "BT.2020"
                self.log_gui.log(
                    f"⚠️ 未识别的色彩空间 '{color_space}'，使用默认标准 BT.2020"
                )

            # ✅ 同步更新到色域参考标准变量
            self.hdr_gamut_ref_var.set(reference_standard)
        else:
            # 未知测试类型，使用 DCI-P3 作为后备
            reference_standard = "DCI-P3"
            self.log_gui.log(
                f"⚠️ 未识别的测试类型 '{test_type}'，使用默认标准 DCI-P3"
            )

        # ========== 根据参考标准计算 XY 覆盖率 ==========
        if reference_standard == "BT.2020":
            area, coverage = pq_algorithm.calculate_gamut_coverage_BT2020(xy_points)
        elif reference_standard == "BT.709":
            area, coverage = pq_algorithm.calculate_gamut_coverage_BT709(xy_points)
        elif reference_standard == "DCI-P3":
            area, coverage = pq_algorithm.calculate_gamut_coverage_DCIP3(xy_points)
        elif reference_standard == "BT.601":
            area, coverage = pq_algorithm.calculate_gamut_coverage_BT601(xy_points)
        else:
            # 默认使用 DCI-P3
            area, coverage = pq_algorithm.calculate_gamut_coverage_DCIP3(xy_points)
            reference_standard = "DCI-P3"
            self.log_gui.log(
                f"⚠️ 未识别的参考标准 '{reference_standard}'，使用默认标准 DCI-P3"
            )

        # ========== ✅✅✅ 新增：计算 UV 覆盖率 ==========
        uv_coverage = 0
        try:
            # 将 XY 转换为 UV
            uv_points = []
            for x, y in xy_points:
                u, v = pq_algorithm.xy_to_uv_1976(x, y)
                uv_points.append([u, v])

            # 根据参考标准计算 UV 覆盖率
            if len(uv_points) >= 3:
                if reference_standard == "BT.2020":
                    _, uv_coverage = (
                        pq_algorithm.calculate_gamut_coverage_BT2020_uv(uv_points)
                    )
                elif reference_standard == "BT.709":
                    _, uv_coverage = pq_algorithm.calculate_gamut_coverage_BT709_uv(
                        uv_points
                    )
                elif reference_standard == "DCI-P3":
                    _, uv_coverage = pq_algorithm.calculate_gamut_coverage_DCIP3_uv(
                        uv_points
                    )
                elif reference_standard == "BT.601":
                    _, uv_coverage = pq_algorithm.calculate_gamut_coverage_BT601_uv(
                        uv_points
                    )
                else:
                    _, uv_coverage = pq_algorithm.calculate_gamut_coverage_DCIP3_uv(
                        uv_points
                    )

                self.log_gui.log(
                    f"✓ XY 覆盖率: {coverage:.1f}% | UV 覆盖率: {uv_coverage:.1f}%"
                )
        except:
            uv_coverage = 0

        # ========== 保存结果时包含 XY 和 UV 覆盖率 ==========
        self.results.set_test_item_result(
            "gamut",
            {
                "area": area,
                "coverage": coverage,
                "uv_coverage": uv_coverage,  # ✅ 新增 UV 覆盖率
                "reference": reference_standard,
            },
        )

        # 传递完整的 results 用于绘图
        self.plot_gamut(results, coverage, test_type)

        self.log_gui.log("色域测试完成")

    except Exception as e:
        self.log_gui.log(f"色域测试失败: {str(e)}")
        import traceback

        self.log_gui.log(traceback.format_exc())
        raise


def test_gamma(self, test_type, gray_data=None):
    """测试Gamma曲线

    Args:
        test_type: 测阶数据，如果提供则使用，否则重新采集
    """
    self.log_gui.log("开始测试Gamma曲线...")
    self.results.start_test_item("gamma")

    try:
        # 使用传入的灰阶数据或独立采集
        if gray_data is not None:
            self.log_gui.log("使用共享的灰阶数据")
            results = gray_data
        else:
            self.log_gui.log("独立采集灰阶数据")
            results = self.send_fix_pattern("gray")

            if not results or len(results) < 2:
                self.log_gui.log("Gamma测试被中断或数据不足")
                return

            self.results.add_intermediate_data("gamma", "gray", results)

        self.log_gui.log(f"使用 {len(results)} 个灰阶数据点进行计算")
        self.log_gui.log("计算Gamma值...")

        # ========== ✅ 修复：正确获取 max_index_fix ==========
        # 获取配置中的值
        config_max_value = self.config.current_pattern.get(
            "measurement_max_value", 10
        )

        # 强制转换为整数
        try:
            max_index_fix = int(config_max_value)
        except (ValueError, TypeError):
            self.log_gui.log(f"警告: measurement_max_value 转换失败，使用默认值 10")
            max_index_fix = 10

        self.log_gui.log(f"配置中的 max_index_fix = {max_index_fix}")

        # 关键修复：验证并调整 max_index_fix
        # max_index_fix 应该是数据点的最大索引（从0开始，所以是 len - 1）
        actual_max_index = len(results) - 1

        if max_index_fix > actual_max_index:
            self.log_gui.log(
                f"警告: 配置的 max_index_fix({max_index_fix}) > 实际最大索引({actual_max_index})"
            )
            self.log_gui.log(f"自动调整为: {actual_max_index}")
            max_index_fix = actual_max_index

        self.log_gui.log(f"最终使用的 max_index_fix = {max_index_fix}")
        # ========================================================

        # 获取灰阶 pattern 参数（用于22293 Gamma数据对齐）
        pattern_params = self.config.default_pattern_gray.get(
            "pattern_params", None
        )

        # 计算Gamma值（使用修正后的 max_index_fix 和 8bit pattern参数）
        results_with_gamma_list, L_bar = self.calculate_gamma(
            results, max_index_fix, pattern_params
        )
        self.results.set_test_item_result(
            "gamma", {"gamma": results_with_gamma_list, "L_bar": L_bar}
        )

        # 绘制Gamma曲线
        if test_type == "sdr_movie":
            try:
                target_gamma = float(self.sdr_gamma_type_var.get())
            except (ValueError, AttributeError):
                target_gamma = 2.2
        else:
            target_gamma = 2.2

        self.plot_gamma(L_bar, results_with_gamma_list, target_gamma, test_type)

        self.log_gui.log("Gamma测试完成")

    except Exception as e:
        self.log_gui.log(f"Gamma测试失败: {str(e)}")
        import traceback

        self.log_gui.log(traceback.format_exc())
        raise


def test_eotf(self, test_type, gray_data=None):
    """测试 EOTF 曲线（HDR 专用）

    Args:
        test_type: 测试类型阶数据，如果提供则使用，否则重新采集
    """
    self.log_gui.log("开始测试 EOTF 曲线（HDR）...")
    self.results.start_test_item("eotf")

    try:
        # 使用传入的灰阶数据或独立采集
        if gray_data is not None:
            self.log_gui.log("使用共享的灰阶数据")
            results = gray_data
        else:
            self.log_gui.log("独立采集灰阶数据")
            results = self.send_fix_pattern("gray")

            if not results or len(results) < 2:
                self.log_gui.log("EOTF 测试被中断或数据不足")
                return

            self.results.add_intermediate_data("eotf", "gray", results)

        self.log_gui.log(f"使用 {len(results)} 个灰阶数据点进行计算")
        self.log_gui.log("计算 EOTF 值...")

        # ========== 获取 max_index_fix ==========
        config_max_value = self.config.current_pattern.get(
            "measurement_max_value", 10
        )

        try:
            max_index_fix = int(config_max_value)
        except (ValueError, TypeError):
            self.log_gui.log(f"警告: measurement_max_value 转换失败，使用默认值 10")
            max_index_fix = 10

        self.log_gui.log(f"配置中的 max_index_fix = {max_index_fix}")

        # 验证并调整 max_index_fix
        actual_max_index = len(results) - 1

        if max_index_fix > actual_max_index:
            self.log_gui.log(
                f"警告: 配置的 max_index_fix({max_index_fix}) > 实际最大索引({actual_max_index})"
            )
            self.log_gui.log(f"自动调整为: {actual_max_index}")
            max_index_fix = actual_max_index

        self.log_gui.log(f"最终使用的 max_index_fix = {max_index_fix}")

        # 获取灰阶 pattern 参数（用于22293 Gamma数据对齐）
        pattern_params = self.config.default_pattern_gray.get(
            "pattern_params", None
        )

        # ========== 计算 EOTF（复用 Gamma 计算逻辑，使用8bit pattern参数）==========
        results_with_eotf_list, L_bar = self.calculate_gamma(
            results, max_index_fix, pattern_params
        )

        # 保存结果
        self.results.set_test_item_result(
            "eotf", {"eotf": results_with_eotf_list, "L_bar": L_bar}
        )

        # ========== 绘制 EOTF 曲线 ==========
        # HDR 使用 PQ 曲线，目标 gamma 设为 None（不使用传统 gamma）
        self.plot_eotf(L_bar, results_with_eotf_list, test_type)

        self.log_gui.log("EOTF 测试完成")

    except Exception as e:
        self.log_gui.log(f"EOTF 测试失败: {str(e)}")
        import traceback

        self.log_gui.log(traceback.format_exc())
        raise


def test_cct(self, test_type, gray_data=None):
    """测试色度一致性"""
    self.log_gui.log("开始测试色度一致性...")
    self.results.start_test_item("cct")

    try:
        if gray_data is not None:
            self.log_gui.log("使用共享的灰阶数据")
            results = gray_data
        else:
            self.log_gui.log("独立采集灰阶数据")
            results = self.send_fix_pattern("gray")

            if not results:
                self.log_gui.log("色度一致性测试被中断")
                return

            self.results.add_intermediate_data("cct", "gray", results)

        self.log_gui.log(f"使用 {len(results)} 个灰阶数据点进行色度计算")

        # 提取色度坐标
        cct_values = pq_algorithm.calculate_cct_from_results(results)

        # 保存到结果
        self.results.set_test_item_result("cct", {"cct_values": cct_values})

        # 绘制图表
        self.plot_cct(test_type)

        self.log_gui.log("色度一致性测试完成")
    except Exception as e:
        self.log_gui.log(f"色度一致性测试失败: {str(e)}")
        import traceback

        self.log_gui.log(traceback.format_exc())
        raise


def test_contrast(self, test_type, gray_data=None):
    """测试对比度

    Args:
        test_type: 阶数据，如果提供则使用，否则重新采集
    """
    self.log_gui.log("开始测试对比度...")
    self.results.start_test_item("contrast")

    try:
        # ✅ 优先使用传入的灰阶数据
        if gray_data is not None:
            self.log_gui.log("使用共享的灰阶数据")
            results = gray_data
        else:
            self.log_gui.log("独立采集灰阶数据")
            results = self.send_fix_pattern("gray")

            if not results:
                self.log_gui.log("对比度测试被中断")
                return

            self.results.add_intermediate_data("contrast", "gray", results)

        # 获取最亮和最暗的亮度值
        luminance_values = [result[2] for result in results]  # 提取lv值

        max_luminance = max(luminance_values)  # 最大亮度（白）
        min_luminance = min(luminance_values)  # 最小亮度（黑）

        # 防止除以0
        if min_luminance < 0.001:
            min_luminance = 0.001

        # 计算对比度
        contrast_ratio = max_luminance / min_luminance

        # 保存结果
        contrast_data = {
            "max_luminance": max_luminance,
            "min_luminance": min_luminance,
            "contrast_ratio": contrast_ratio,
            "luminance_values": luminance_values,
        }
        self.results.set_test_item_result("contrast", contrast_data)

        # 显示对比度结果到日志
        self.log_gui.log(f"最大亮度 (白场): {max_luminance:.2f} cd/m²")
        self.log_gui.log(f"最小亮度 (黑场): {min_luminance:.4f} cd/m²")
        self.log_gui.log(f"对比度: {contrast_ratio:.0f}:1")

        # 绘制对比度图表
        self.plot_contrast(contrast_data, test_type)

        self.log_gui.log("对比度测试完成")
    except Exception as e:
        self.log_gui.log(f"对比度测试失败: {str(e)}")
        import traceback

        self.log_gui.log(traceback.format_exc())
        raise


def test_color_accuracy(self, test_type):
    """测试色准 - 使用手工实现的 ΔE 2000（应用 Gamma）"""

    # ========== 读取用户选择的 Gamma ==========
    if test_type == "sdr_movie":
        try:
            target_gamma = float(self.sdr_gamma_type_var.get())
        except (ValueError, AttributeError):
            target_gamma = 2.2

        self.log_gui.log("=" * 50)
        self.log_gui.log(f"开始测试色准（SDR Movie 标准 - 29色）")
        self.log_gui.log(f"✓ 使用 Gamma: {target_gamma}")  # ← 新增
        self.log_gui.log("=" * 50)

    elif test_type == "hdr_movie":
        target_gamma = 2.4  # HDR 使用 PQ，但保留参考值

        self.log_gui.log("=" * 50)
        self.log_gui.log(f"开始测试色准（HDR Movie 标准 - 29色）")
        self.log_gui.log(f"✓ 使用 Gamma: PQ (参考γ={target_gamma})")  # ← 新增
        self.log_gui.log("=" * 50)

    else:  # screen_module
        target_gamma = 2.2

        self.log_gui.log("=" * 50)
        self.log_gui.log(f"开始测试色准（屏模组 标准 - 29色）")
        self.log_gui.log(f"✓ 使用 Gamma: {target_gamma}")
        self.log_gui.log("=" * 50)

    # 获取 29色名称
    color_names = self.config.get_accuracy_color_names()

    self.log_gui.log(f"✓ 将测试 {len(color_names)} 个色块")
    self.log_gui.log(f"  色块分组:")
    self.log_gui.log(f"    灰阶 (5个): {', '.join(color_names[:5])}")
    self.log_gui.log(f"    ColorChecker (18个): {', '.join(color_names[5:23])}")
    self.log_gui.log(f"    饱和色 (6个): {', '.join(color_names[23:])}")

    self.log_gui.log("=" * 50)
    self.log_gui.log("开始发送色准图案并采集数据...")
    self.log_gui.log("=" * 50)

    # 发送 29色图案
    measured_data_list = self.send_fix_pattern("accuracy")

    if measured_data_list is None or len(measured_data_list) != 29:
        self.log_gui.log(f"❌ 数据数量不匹配")
        self.log_gui.log(f"   期望: 29 个")
        self.log_gui.log(
            f"   实际: {len(measured_data_list) if measured_data_list else 0} 个"
        )
        return

    # 保存原始测量数据供单步调试使用
    self.results.add_intermediate_data("accuracy", "measured", measured_data_list)

    # ========== 计算 ΔE 2000（显示 Gamma）==========
    self.log_gui.log("=" * 50)
    self.log_gui.log(f"计算色准（ΔE 2000，Gamma {target_gamma}）...")
    self.log_gui.log("=" * 50)

    # 获取标准 xy 坐标
    standards = self.get_accuracy_color_standards(test_type)

    delta_e_values = []
    color_patches = []

    for i, (name, measured_data) in enumerate(zip(color_names, measured_data_list)):
        measured_x = measured_data[0]
        measured_y = measured_data[1]
        measured_lv = measured_data[2]

        standard_x, standard_y = standards.get(name, (0.3127, 0.3290))

        delta_e = self.calculate_delta_e_2000(
            measured_x,
            measured_y,
            measured_lv,
            standard_x,
            standard_y,
        )

        delta_e_values.append(delta_e)
        color_patches.append(name)

        if delta_e < 3:
            grade, icon = "优秀", "✓"
        elif delta_e < 5:
            grade, icon = "良好", "○"
        else:
            grade, icon = "偏差", "✗"

        self.log_gui.log(
            f"  [{i+1:2d}] {name:20s} ΔE={delta_e:5.2f}  {icon} {grade}"
        )

    # ========== 统计 ==========
    avg_delta_e_all = sum(delta_e_values) / len(delta_e_values)
    max_delta_e_all = max(delta_e_values)
    min_delta_e_all = min(delta_e_values)

    excellent_count_all = sum(1 for de in delta_e_values if de < 3)
    good_count_all = sum(1 for de in delta_e_values if 3 <= de < 5)
    poor_count_all = sum(1 for de in delta_e_values if de >= 5)

    delta_e_gray = delta_e_values[0:5]
    avg_delta_e_gray = sum(delta_e_gray) / len(delta_e_gray)

    delta_e_colorchecker = delta_e_values[5:23]
    avg_delta_e_colorchecker = sum(delta_e_colorchecker) / len(delta_e_colorchecker)

    delta_e_saturated = delta_e_values[23:29]
    avg_delta_e_saturated = sum(delta_e_saturated) / len(delta_e_saturated)

    self.log_gui.log("=" * 50)
    self.log_gui.log("色准统计（全 29色）:")
    self.log_gui.log("=" * 50)
    self.log_gui.log(f"  平均 ΔE: {avg_delta_e_all:.2f}")
    self.log_gui.log(f"  最大 ΔE: {max_delta_e_all:.2f}")
    self.log_gui.log(f"  最小 ΔE: {min_delta_e_all:.2f}")
    self.log_gui.log(f"  优秀 (ΔE<3): {excellent_count_all} 个")
    self.log_gui.log(f"  良好 (3≤ΔE<5): {good_count_all} 个")
    self.log_gui.log(f"  偏差 (ΔE≥5): {poor_count_all} 个")

    self.log_gui.log("")
    self.log_gui.log("分组统计:")
    self.log_gui.log(f"  灰阶 (5个):        平均 ΔE = {avg_delta_e_gray:.2f}")
    self.log_gui.log(
        f"  ColorChecker (18个): 平均 ΔE = {avg_delta_e_colorchecker:.2f}"
    )
    self.log_gui.log(f"  饱和色 (6个):      平均 ΔE = {avg_delta_e_saturated:.2f}")

    # ========== 保存测试结果 ==========
    accuracy_data = {
        "color_patches": color_patches,
        "delta_e_values": delta_e_values,
        "color_measurements": measured_data_list,
        "avg_delta_e": avg_delta_e_all,
        "max_delta_e": max_delta_e_all,
        "min_delta_e": min_delta_e_all,
        "excellent_count": excellent_count_all,
        "good_count": good_count_all,
        "poor_count": poor_count_all,
        "avg_delta_e_gray": avg_delta_e_gray,
        "avg_delta_e_colorchecker": avg_delta_e_colorchecker,
        "avg_delta_e_saturated": avg_delta_e_saturated,
        "target_gamma": target_gamma,
    }

    self.results.set_test_item_result("accuracy", accuracy_data)

    # ========== 绘制图表 ==========
    self.plot_accuracy(accuracy_data, test_type)

    self.log_gui.log("色准测试完成")


def on_test_completed(self):
    """测试完成后的UI更新"""
    self.testing = False
    self.start_btn.config(state=tk.NORMAL)
    self.stop_btn.config(state=tk.DISABLED)
    self.save_btn.config(state=tk.NORMAL)
    self.clear_config_btn.config(state=tk.NORMAL)
    self.status_var.set("测试完成")
    self.log_gui.log("测试完成")

    # 恢复配置项按钮
    if hasattr(self, "config_panel_frame"):
        try:
            self.config_panel_frame.btn.configure(state="normal")
        except:
            pass

    # 启用色域参考标准下拉框
    try:
        test_type = self.config.current_test_type

        if test_type == "screen_module" and hasattr(self, "screen_gamut_combo"):
            self.screen_gamut_combo.configure(state="readonly")
            self.log_gui.log("✓ 屏模组色域参考标准已启用")

        elif test_type == "sdr_movie" and hasattr(self, "sdr_gamut_combo"):
            self.sdr_gamut_combo.configure(state="readonly")
            self.log_gui.log("✓ SDR 色域参考标准已启用")

        elif test_type == "hdr_movie" and hasattr(self, "hdr_gamut_combo"):
            self.hdr_gamut_combo.configure(state="readonly")
            self.log_gui.log("✓ HDR 色域参考标准已启用")
    except Exception as e:
        self.log_gui.log(f"启用色域参考标准失败: {str(e)}")

    # 获取当前测试类型和选中的测试项
    selected_items = self.get_selected_test_items()
    test_type = self.config.current_test_type

    # ==================== ✅ 启用单步调试按钮 ====================
    if hasattr(self, "debug_panel"):
        try:
            # 屏模组：启用 Gamma 和 RGB 单步调试
            if test_type == "screen_module":
                if "gamma" in selected_items:
                    gray_data = self.results.get_intermediate_data("shared", "gray")
                    if gray_data:
                        self.debug_panel.enable_debug(
                            "screen_module", "gamma", gray_data
                        )

                # 启用 RGB 单步调试（色域测试完成后）
                if "gamut" in selected_items:
                    rgb_data = self.results.get_intermediate_data("gamut", "rgb")
                    if rgb_data:
                        self.debug_panel.enable_debug(
                            "screen_module", "rgb", rgb_data
                        )

                # ✅ 启用单步调试按钮
                if hasattr(self, "screen_debug_btn"):
                    self.screen_debug_btn.config(state=tk.NORMAL)
                    self.log_gui.log("✓ 屏模组单步调试按钮已启用")

            # SDR：启用 Gamma、色准和 RGB 单步调试
            elif test_type == "sdr_movie":
                if "gamma" in selected_items:
                    gray_data = self.results.get_intermediate_data("shared", "gray")
                    if gray_data:
                        self.debug_panel.enable_debug(
                            "sdr_movie", "gamma", gray_data
                        )

                if "accuracy" in selected_items:
                    accuracy_data = self.results.get_intermediate_data(
                        "accuracy", "measured"
                    )
                    if accuracy_data:
                        self.debug_panel.enable_debug(
                            "sdr_movie", "accuracy", accuracy_data
                        )

                # 启用 RGB 单步调试（色域测试完成后）
                if "gamut" in selected_items:
                    rgb_data = self.results.get_intermediate_data("gamut", "rgb")
                    if rgb_data:
                        self.debug_panel.enable_debug("sdr_movie", "rgb", rgb_data)

                # ✅ 启用单步调试按钮
                if hasattr(self, "sdr_debug_btn"):
                    self.sdr_debug_btn.config(state=tk.NORMAL)
                    self.log_gui.log("✓ SDR 单步调试按钮已启用")

            # HDR：启用 EOTF、色准和 RGB 单步调试
            elif test_type == "hdr_movie":
                if "eotf" in selected_items:
                    gray_data = self.results.get_intermediate_data("shared", "gray")
                    if gray_data:
                        self.debug_panel.enable_debug(
                            "hdr_movie", "eotf", gray_data
                        )

                if "accuracy" in selected_items:
                    accuracy_data = self.results.get_intermediate_data(
                        "accuracy", "measured"
                    )
                    if accuracy_data:
                        self.debug_panel.enable_debug(
                            "hdr_movie", "accuracy", accuracy_data
                        )

                # 启用 RGB 单步调试（色域测试完成后）
                if "gamut" in selected_items:
                    rgb_data = self.results.get_intermediate_data("gamut", "rgb")
                    if rgb_data:
                        self.debug_panel.enable_debug("hdr_movie", "rgb", rgb_data)

                # ✅ 启用单步调试按钮
                if hasattr(self, "hdr_debug_btn"):
                    self.hdr_debug_btn.config(state=tk.NORMAL)
                    self.log_gui.log("✓ HDR 单步调试按钮已启用")

        except Exception as e:
            self.log_gui.log(f"启用单步调试失败: {str(e)}")

    # ==================== 显示色度/色域重新计算按钮 ====================
    if "cct" in selected_items:
        try:
            if test_type == "screen_module" and hasattr(self, "recalc_cct_btn"):
                self.recalc_cct_btn.grid()
                self.log_gui.log("✓ 屏模组色度参数调整按钮已启用")
            elif test_type == "sdr_movie" and hasattr(self, "sdr_recalc_cct_btn"):
                self.sdr_recalc_cct_btn.grid()
                self.log_gui.log("✓ SDR 色度参数调整按钮已启用")
            elif test_type == "hdr_movie" and hasattr(self, "hdr_recalc_cct_btn"):
                self.hdr_recalc_cct_btn.grid()
                self.log_gui.log("✓ HDR 色度参数调整按钮已启用")
        except Exception as e:
            self.log_gui.log(f"显示色度重新计算按钮失败: {str(e)}")

    if "gamut" in selected_items:
        try:
            if test_type == "screen_module" and hasattr(self, "recalc_gamut_btn"):
                self.recalc_gamut_btn.grid()
                self.log_gui.log("✓ 屏模组色域参考调整按钮已启用")
            elif test_type == "sdr_movie" and hasattr(self, "sdr_recalc_gamut_btn"):
                self.sdr_recalc_gamut_btn.grid()
                self.log_gui.log("✓ SDR 色域参考调整按钮已启用")
            elif test_type == "hdr_movie" and hasattr(self, "hdr_recalc_gamut_btn"):
                self.hdr_recalc_gamut_btn.grid()
                self.log_gui.log("✓ HDR 色域参考调整按钮已启用")
        except Exception as e:
            self.log_gui.log(f"显示色域重新计算按钮失败: {str(e)}")

    messagebox.showinfo("完成", "测试已完成！")


def on_custom_template_test_completed(self):
    """客户模板测试完成后的UI更新"""
    self.testing = False
    self.set_custom_result_table_locked(False)
    self.start_btn.config(state=tk.NORMAL)
    self.stop_btn.config(state=tk.DISABLED)
    self.save_btn.config(state=tk.DISABLED)
    self.clear_config_btn.config(state=tk.NORMAL)
    self.custom_btn.config(state=tk.NORMAL)
    self.status_var.set("客户模板测试完成")

    if hasattr(self, "config_panel_frame"):
        try:
            self.config_panel_frame.btn.configure(state="normal")
        except:
            pass

    self.log_gui.log("客户模板测试完成")
    messagebox.showinfo("完成", "客户模板测试已完成！")


def get_current_test_result(self):
    """获取当前测试结果"""
    test_type = self.test_type_var.get()
    test_items = self.get_selected_test_items()

    # 构建测试结果字典
    result = {
        "test_type": test_type,
        "test_type_name": self.get_test_type_name(test_type),
        "test_items": test_items,
        "test_items_names": self.config.get_test_item_chinese_names(test_items),
        "timestamp": datetime.datetime.now(),
        "status": "完成",
        "results": {},
    }

    # 根据测试项目收集结果数据
    for item in test_items:
        if item == "gamut" and hasattr(self, "gamut_results"):
            result["results"]["gamut"] = getattr(self, "gamut_results", {})
        elif item in ["gamma", "eotf"] and hasattr(self, "gamma_results"):
            result["results"][item] = getattr(self, "gamma_results", {})
        elif item == "cct" and hasattr(self, "cct_results"):
            result["results"]["cct"] = getattr(self, "cct_results", {})
        elif item == "contrast" and hasattr(self, "contrast_results"):
            result["results"]["contrast"] = getattr(self, "contrast_results", {})
        elif item == "accuracy" and hasattr(self, "accuracy_results"):
            result["results"]["accuracy"] = getattr(self, "accuracy_results", {})

    return result


def on_test_error(self):
    """测试出错后的UI更新"""
    self.testing = False
    self.set_custom_result_table_locked(False)
    self.start_btn.config(state=tk.NORMAL)
    self.stop_btn.config(state=tk.DISABLED)
    self.clear_config_btn.config(state=tk.NORMAL)
    if hasattr(self, "custom_btn"):
        self.custom_btn.config(state=tk.NORMAL)
    self.status_var.set("测试出错")

    # 恢复配置项按钮
    if hasattr(self, "config_panel_frame"):
        try:
            self.config_panel_frame.btn.configure(state="normal")
        except:
            pass

    messagebox.showerror("错误", "测试过程中发生错误，请查看日志")