重构删除/移动主文件冗余函数

app/views/panels/cct_panel.py

@@ -1,4 +1,4 @@
-"""CCT 参数面板及其处理函数（Step 6 重构）。"""
+"""CCT 参数面板及其处理函数（与主文件重构版本保持同步）。"""
 
 import time
 import traceback
@@ -18,21 +18,16 @@ def create_cct_params_frame(self):
     )
 
     # 默认值
-    self.DEFAULT_CCT_PARAMS = {
+    screen_default_cct_params = self.config.get_default_cct_params("screen_module")
-        "x_ideal": 0.3127,
-        "x_tolerance": 0.003,
-        "y_ideal": 0.3290,
-        "y_tolerance": 0.003,
-    }
 
     # 从配置读取屏模组参数
     saved_params = self.config.current_test_types.get("screen_module", {}).get(
-        "cct_params", self.DEFAULT_CCT_PARAMS.copy()
+        "cct_params", screen_default_cct_params.copy()
     )
 
     # 色域参考标准
     saved_gamut_ref = self.config.current_test_types.get("screen_module", {}).get(
-        "gamut_reference", "DCI-P3"
+        "gamut_reference", self.config.get_default_gamut_reference("screen_module")
     )
 
     # 创建屏模组变量
@@ -66,7 +61,7 @@ def create_cct_params_frame(self):
         entry.grid(row=i, column=1, sticky=tk.W, padx=5, pady=3)
 
         # 绑定失去焦点事件
-        default_val = self.DEFAULT_CCT_PARAMS[key]
+        default_val = screen_default_cct_params[key]
         entry.bind(
             "<FocusOut>",
             lambda e, v=var, d=default_val: self.on_cct_param_focus_out(v, d),
@@ -142,21 +137,16 @@ def create_cct_params_frame(self):
     )
 
     # SDR 默认值
-    self.SDR_DEFAULT_CCT_PARAMS = {
+    sdr_default_cct_params = self.config.get_default_cct_params("sdr_movie")
-        "x_ideal": 0.3127,
-        "x_tolerance": 0.003,
-        "y_ideal": 0.3290,
-        "y_tolerance": 0.003,
-    }
 
     # 从配置读取 SDR 参数
     sdr_saved_params = self.config.current_test_types.get("sdr_movie", {}).get(
-        "cct_params", self.SDR_DEFAULT_CCT_PARAMS.copy()
+        "cct_params", sdr_default_cct_params.copy()
     )
 
     # 色域参考标准
     sdr_saved_gamut_ref = self.config.current_test_types.get("sdr_movie", {}).get(
-        "gamut_reference", "BT.709"
+        "gamut_reference", self.config.get_default_gamut_reference("sdr_movie")
     )
 
     # 创建 SDR 变量
@@ -190,7 +180,7 @@ def create_cct_params_frame(self):
         entry.grid(row=i, column=1, sticky=tk.W, padx=5, pady=3)
 
         # 绑定失去焦点事件
-        default_val = self.SDR_DEFAULT_CCT_PARAMS[key]
+        default_val = sdr_default_cct_params[key]
         entry.bind(
             "<FocusOut>",
             lambda e, v=var, d=default_val: self.on_sdr_cct_param_focus_out(v, d),
@@ -264,21 +254,16 @@ def create_cct_params_frame(self):
     )
 
     # HDR 默认值
-    self.HDR_DEFAULT_CCT_PARAMS = {
+    hdr_default_cct_params = self.config.get_default_cct_params("hdr_movie")
-        "x_ideal": 0.3127,
-        "x_tolerance": 0.003,
-        "y_ideal": 0.3290,
-        "y_tolerance": 0.003,
-    }
 
     # 从配置读取 HDR 参数
     hdr_saved_params = self.config.current_test_types.get("hdr_movie", {}).get(
-        "cct_params", self.HDR_DEFAULT_CCT_PARAMS.copy()
+        "cct_params", hdr_default_cct_params.copy()
     )
 
     # 色域参考标准
     hdr_saved_gamut_ref = self.config.current_test_types.get("hdr_movie", {}).get(
-        "gamut_reference", "BT.2020"
+        "gamut_reference", self.config.get_default_gamut_reference("hdr_movie")
     )
 
     # 创建 HDR 变量
@@ -312,7 +297,7 @@ def create_cct_params_frame(self):
         entry.grid(row=i, column=1, sticky=tk.W, padx=5, pady=3)
 
         # 绑定失去焦点事件
-        default_val = self.HDR_DEFAULT_CCT_PARAMS[key]
+        default_val = hdr_default_cct_params[key]
         entry.bind(
             "<FocusOut>",
             lambda e, v=var, d=default_val: self.on_hdr_cct_param_focus_out(v, d),
@@ -381,15 +366,68 @@ def create_cct_params_frame(self):
     ).grid(row=5, column=0, columnspan=4, sticky=tk.W, padx=5, pady=5)
 
 
-def on_sdr_cct_param_focus_out(self, var, default_value):
+def _get_cct_var_dict(self, test_type):
-    """SDR 色度参数失去焦点时的处理"""
+    """按测试类型返回 CCT 变量映射。"""
+    if test_type == "sdr_movie":
+        return {
+            "x_ideal": self.sdr_cct_x_ideal_var,
+            "x_tolerance": self.sdr_cct_x_tolerance_var,
+            "y_ideal": self.sdr_cct_y_ideal_var,
+            "y_tolerance": self.sdr_cct_y_tolerance_var,
+        }
+    if test_type == "hdr_movie":
+        return {
+            "x_ideal": self.hdr_cct_x_ideal_var,
+            "x_tolerance": self.hdr_cct_x_tolerance_var,
+            "y_ideal": self.hdr_cct_y_ideal_var,
+            "y_tolerance": self.hdr_cct_y_tolerance_var,
+        }
+    return {
+        "x_ideal": self.cct_x_ideal_var,
+        "x_tolerance": self.cct_x_tolerance_var,
+        "y_ideal": self.cct_y_ideal_var,
+        "y_tolerance": self.cct_y_tolerance_var,
+    }
+
+
+def _parse_cct_float(self, var, default):
+    """读取并解析 CCT 输入值，失败时回落默认值。"""
     try:
         value = var.get().strip()
+        if value == "":
+            return default
+        return float(value)
+    except Exception:
+        return default
 
+
+def _save_cct_params_for(self, test_type):
+    """保存指定测试类型的 CCT 参数。"""
+    try:
+        default_params = self.config.get_default_cct_params(test_type)
+        var_dict = self._get_cct_var_dict(test_type)
+        cct_params = {
+            key: self._parse_cct_float(var_dict[key], default_params[key])
+            for key in default_params
+        }
+
+        if test_type not in self.config.current_test_types:
+            self.config.current_test_types[test_type] = {}
+
+        self.config.current_test_types[test_type]["cct_params"] = cct_params
+        self.save_pq_config()
+    except Exception:
+        pass
+
+
+def _handle_cct_focus_out(self, var, default_value, save_func, label):
+    """统一处理 CCT 参数失焦校验并保存。"""
+    try:
+        value = var.get().strip()
         if value == "":
             var.set(str(default_value))
             if hasattr(self, "log_gui"):
-                self.log_gui.log(f"✓ SDR 参数为空，恢复默认值: {default_value}")
+                self.log_gui.log(f"✓ {label} 参数为空，恢复默认值: {default_value}")
         else:
             try:
                 float_val = float(value)
@@ -397,124 +435,39 @@ def on_sdr_cct_param_focus_out(self, var, default_value):
                     var.set(str(default_value))
                     if hasattr(self, "log_gui"):
                         self.log_gui.log(
-                            f"⚠️ SDR 参数超出范围，恢复默认值: {default_value}"
+                            f"⚠️ {label} 参数超出范围，恢复默认值: {default_value}"
                         )
             except ValueError:
                 var.set(str(default_value))
                 if hasattr(self, "log_gui"):
-                    self.log_gui.log(f"⚠️ SDR 参数无效，恢复默认值: {default_value}")
+                    self.log_gui.log(
+                        f"⚠️ {label} 参数无效，恢复默认值: {default_value}"
+                    )
 
-        self.save_sdr_cct_params()
+        save_func()
     except Exception as e:
         if hasattr(self, "log_gui"):
-            self.log_gui.log(f"处理 SDR 参数失败: {str(e)}")
+            self.log_gui.log(f"处理 {label} 参数失败: {str(e)}")
+
+
+def on_sdr_cct_param_focus_out(self, var, default_value):
+    """SDR 色度参数失去焦点时的处理。"""
+    self._handle_cct_focus_out(var, default_value, self.save_sdr_cct_params, "SDR")
 
 
 def save_sdr_cct_params(self):
-    """保存 SDR 色度参数"""
+    """保存 SDR 色度参数。"""
-    try:
+    self._save_cct_params_for("sdr_movie")
-
-        def get_float(var, default):
-            try:
-                value = var.get().strip()
-                if value == "":
-                    return default
-                return float(value)
-            except:
-                return default
-
-        sdr_cct_params = {
-            "x_ideal": get_float(
-                self.sdr_cct_x_ideal_var, self.SDR_DEFAULT_CCT_PARAMS["x_ideal"]
-            ),
-            "x_tolerance": get_float(
-                self.sdr_cct_x_tolerance_var,
-                self.SDR_DEFAULT_CCT_PARAMS["x_tolerance"],
-            ),
-            "y_ideal": get_float(
-                self.sdr_cct_y_ideal_var, self.SDR_DEFAULT_CCT_PARAMS["y_ideal"]
-            ),
-            "y_tolerance": get_float(
-                self.sdr_cct_y_tolerance_var,
-                self.SDR_DEFAULT_CCT_PARAMS["y_tolerance"],
-            ),
-        }
-
-        if "sdr_movie" not in self.config.current_test_types:
-            self.config.current_test_types["sdr_movie"] = {}
-
-        self.config.current_test_types["sdr_movie"]["cct_params"] = sdr_cct_params
-        self.save_pq_config()
-    except:
-        pass
 
 
 def on_hdr_cct_param_focus_out(self, var, default_value):
-    """HDR 色度参数失去焦点时的处理"""
+    """HDR 色度参数失去焦点时的处理。"""
-    try:
+    self._handle_cct_focus_out(var, default_value, self.save_hdr_cct_params, "HDR")
-        value = var.get().strip()
-
-        if value == "":
-            var.set(str(default_value))
-            if hasattr(self, "log_gui"):
-                self.log_gui.log(f"✓ HDR 参数为空，恢复默认值: {default_value}")
-        else:
-            try:
-                float_val = float(value)
-                if float_val < 0 or float_val > 1:
-                    var.set(str(default_value))
-                    if hasattr(self, "log_gui"):
-                        self.log_gui.log(
-                            f"⚠️ HDR 参数超出范围，恢复默认值: {default_value}"
-                        )
-            except ValueError:
-                var.set(str(default_value))
-                if hasattr(self, "log_gui"):
-                    self.log_gui.log(f"⚠️ HDR 参数无效，恢复默认值: {default_value}")
-
-        self.save_hdr_cct_params()
-    except Exception as e:
-        if hasattr(self, "log_gui"):
-            self.log_gui.log(f"处理 HDR 参数失败: {str(e)}")
 
 
 def save_hdr_cct_params(self):
-    """保存 HDR 色度参数"""
+    """保存 HDR 色度参数。"""
-    try:
+    self._save_cct_params_for("hdr_movie")
-
-        def get_float(var, default):
-            try:
-                value = var.get().strip()
-                if value == "":
-                    return default
-                return float(value)
-            except:
-                return default
-
-        hdr_cct_params = {
-            "x_ideal": get_float(
-                self.hdr_cct_x_ideal_var, self.HDR_DEFAULT_CCT_PARAMS["x_ideal"]
-            ),
-            "x_tolerance": get_float(
-                self.hdr_cct_x_tolerance_var,
-                self.HDR_DEFAULT_CCT_PARAMS["x_tolerance"],
-            ),
-            "y_ideal": get_float(
-                self.hdr_cct_y_ideal_var, self.HDR_DEFAULT_CCT_PARAMS["y_ideal"]
-            ),
-            "y_tolerance": get_float(
-                self.hdr_cct_y_tolerance_var,
-                self.HDR_DEFAULT_CCT_PARAMS["y_tolerance"],
-            ),
-        }
-
-        if "hdr_movie" not in self.config.current_test_types:
-            self.config.current_test_types["hdr_movie"] = {}
-
-        self.config.current_test_types["hdr_movie"]["cct_params"] = hdr_cct_params
-        self.save_pq_config()
-    except:
-        pass
 
 
 def recalculate_cct(self):
@@ -630,6 +583,7 @@ def recalculate_gamut(self):
         # 7. 重新计算 XY 色域覆盖率
         xy_points = [[result[0], result[1]] for result in rgb_data]
 
+        # 根据参考标准计算 XY 覆盖率
         if reference_standard == "BT.2020":
             area_xy, coverage_xy = pq_algorithm.calculate_gamut_coverage_BT2020(
                 xy_points
@@ -651,10 +605,12 @@ def recalculate_gamut(self):
         self.log_gui.log(f"✓ 参考标准: {reference_standard}")
         self.log_gui.log(f"✓ XY 色域覆盖率: {coverage_xy:.1f}%")
 
-        # 8. 重新计算 UV 色域覆盖率
+        # ========== ✅✅✅ 8. 重新计算 UV 色域覆盖率 ==========
+        # 将 XY 坐标转换为 UV 坐标
         uv_points = []
         for x, y in xy_points:
             try:
+                # XY转UV公式
                 denom = -2 * x + 12 * y + 3
                 if abs(denom) < 1e-10:
                     u, v = 0, 0
@@ -667,6 +623,7 @@ def recalculate_gamut(self):
 
         self.log_gui.log(f"✓ 转换后的 UV 点数量: {len(uv_points)}")
 
+        # 根据参考标准计算 UV 覆盖率
         if reference_standard == "BT.2020":
             area_uv, coverage_uv = pq_algorithm.calculate_gamut_coverage_BT2020_uv(
                 uv_points
@@ -685,18 +642,19 @@ def recalculate_gamut(self):
             )
 
         self.log_gui.log(f"✓ UV 色域覆盖率: {coverage_uv:.1f}%")
+        # ========================================================
 
-        # 9. 更新结果
+        # 9. ✅ 更新结果（同时保存 XY 和 UV 覆盖率）
         self.results.set_test_item_result(
             "gamut",
             {
-                "area": area_xy,
+                "area": area_xy,  # ← 兼容旧字段
-                "coverage": coverage_xy,
+                "coverage": coverage_xy,  # ← 兼容旧字段
-                "area_xy": area_xy,
+                "area_xy": area_xy,  # ← XY 面积
-                "coverage_xy": coverage_xy,
+                "coverage_xy": coverage_xy,  # ← XY 覆盖率
-                "area_uv": area_uv,
+                "area_uv": area_uv,  # ← UV 面积
-                "coverage_uv": coverage_uv,
+                "coverage_uv": coverage_uv,  # ← UV 覆盖率
-                "uv_coverage": coverage_uv,
+                "uv_coverage": coverage_uv,  # ← 兼容字段（Excel 导出用）
                 "reference": reference_standard,
             },
         )
@@ -722,103 +680,14 @@ def recalculate_gamut(self):
         messagebox.showerror("错误", f"重新计算失败: {str(e)}")
 
 
-def on_cct_param_change(self, var, default_value):
-    """色度参数改变时的处理 - 空值恢复默认"""
-    try:
-        value = var.get().strip()
-
-        if value == "":
-            var.set(str(default_value))
-            if hasattr(self, "log_gui"):
-                self.log_gui.log(f"输入框为空，恢复默认值: {default_value}")
-        else:
-            try:
-                float_val = float(value)
-                if float_val < 0 or float_val > 1:
-                    var.set(str(default_value))
-                    if hasattr(self, "log_gui"):
-                        self.log_gui.log(
-                            f"参数超出范围 [0, 1]，恢复默认值: {default_value}"
-                        )
-            except ValueError:
-                var.set(str(default_value))
-                if hasattr(self, "log_gui"):
-                    self.log_gui.log(f"无效的参数值，恢复默认值: {default_value}")
-
-        self.save_cct_params()
-
-    except Exception as e:
-        if hasattr(self, "log_gui"):
-            self.log_gui.log(f"处理参数变化失败: {str(e)}")
-
-
 def on_cct_param_focus_out(self, var, default_value):
     """色度参数失去焦点时的处理 - 空值恢复默认"""
-    try:
+    self._handle_cct_focus_out(var, default_value, self.save_cct_params, "屏模组")
-        value = var.get().strip()
-
-        if value == "":
-            var.set(str(default_value))
-            if hasattr(self, "log_gui"):
-                self.log_gui.log(f"✓ 输入框为空，恢复默认值: {default_value}")
-        else:
-            try:
-                float_val = float(value)
-                if float_val < 0 or float_val > 1:
-                    var.set(str(default_value))
-                    if hasattr(self, "log_gui"):
-                        self.log_gui.log(
-                            f"⚠️ 参数超出范围 [0, 1]，恢复默认值: {default_value}"
-                        )
-            except ValueError:
-                var.set(str(default_value))
-                if hasattr(self, "log_gui"):
-                    self.log_gui.log(f"⚠️ 无效的参数值，恢复默认值: {default_value}")
-
-        self.save_cct_params()
-
-    except Exception as e:
-        if hasattr(self, "log_gui"):
-            self.log_gui.log(f"处理参数变化失败: {str(e)}")
 
 
 def save_cct_params(self):
     """保存色度参数 - 简化版"""
-    try:
+    self._save_cct_params_for(self.config.current_test_type)
-        current_type = self.config.current_test_type
-
-        def get_float(var, default):
-            try:
-                value = var.get().strip()
-                if value == "":
-                    return default
-                return float(value)
-            except:
-                return default
-
-        cct_params = {
-            "x_ideal": get_float(
-                self.cct_x_ideal_var, self.DEFAULT_CCT_PARAMS["x_ideal"]
-            ),
-            "x_tolerance": get_float(
-                self.cct_x_tolerance_var, self.DEFAULT_CCT_PARAMS["x_tolerance"]
-            ),
-            "y_ideal": get_float(
-                self.cct_y_ideal_var, self.DEFAULT_CCT_PARAMS["y_ideal"]
-            ),
-            "y_tolerance": get_float(
-                self.cct_y_tolerance_var, self.DEFAULT_CCT_PARAMS["y_tolerance"]
-            ),
-        }
-
-        if current_type not in self.config.current_test_types:
-            self.config.current_test_types[current_type] = {}
-
-        self.config.current_test_types[current_type]["cct_params"] = cct_params
-        self.save_pq_config()
-
-    except:
-        pass
 
 
 def reload_cct_params(self):
@@ -830,7 +699,7 @@ def reload_cct_params(self):
         )
 
         if saved_params is None:
-            saved_params = self.DEFAULT_CCT_PARAMS.copy()
+            saved_params = self.config.get_default_cct_params(current_type)
 
         # 更新输入框的值
         self.cct_x_ideal_var.set(str(saved_params["x_ideal"]))
@@ -841,3 +710,77 @@ def reload_cct_params(self):
     except Exception as e:
         if hasattr(self, "log_gui"):
             self.log_gui.log(f"重新加载色度参数失败: {str(e)}")
+
+
+def toggle_cct_params_frame(self):
+    """根据测试类型和测试项的选中状态显示对应参数框"""
+    selected_items = self.get_selected_test_items()
+    current_test_type = self.config.current_test_type
+
+    # ========== 默认隐藏所有参数框 ==========
+    self.cct_params_frame.pack_forget()
+    self.sdr_cct_params_frame.pack_forget()
+
+    # HDR 色度参数框（如果存在的话）
+    if hasattr(self, "hdr_cct_params_frame"):
+        self.hdr_cct_params_frame.pack_forget()
+
+    # ========== 根据测试类型和选中项显示对应参数框 ==========
+    if current_test_type == "screen_module":
+        # 屏模组：只有色度参数
+        if "cct" in selected_items:
+            self.cct_params_frame.pack(fill=tk.X, padx=5, pady=5)
+            if hasattr(self, "log_gui"):
+                self.log_gui.log("✓ 显示屏模组色度参数设置")
+
+    elif current_test_type == "sdr_movie":
+        # SDR：只有色度参数（色准不需要参数设置框）
+        if "cct" in selected_items:
+            self.sdr_cct_params_frame.pack(fill=tk.X, padx=5, pady=5)
+            if hasattr(self, "log_gui"):
+                self.log_gui.log("✓ 显示 SDR 色度参数设置")
+
+    elif current_test_type == "hdr_movie":
+        # HDR：只有色度参数（色准不需要参数设置框）
+        if "cct" in selected_items:
+            if hasattr(self, "hdr_cct_params_frame"):
+                self.hdr_cct_params_frame.pack(fill=tk.X, padx=5, pady=5)
+                if hasattr(self, "log_gui"):
+                    self.log_gui.log("✓ 显示 HDR 色度参数设置")
+            else:
+                if hasattr(self, "log_gui"):
+                    self.log_gui.log("⚠️ HDR 色度参数框尚未创建")
+
+
+# ---- gamut 参考标准改变回调（统一实现） ----
+_GAMUT_REF_CONFIGS = {
+    "screen_module": {"var_attr": "screen_gamut_ref_var", "label": "屏模组"},
+    "sdr_movie": {"var_attr": "sdr_gamut_ref_var", "label": "SDR"},
+    "hdr_movie": {"var_attr": "hdr_gamut_ref_var", "label": "HDR"},
+}
+
+
+def _on_gamut_ref_changed(self, test_type, event=None):
+    cfg = _GAMUT_REF_CONFIGS[test_type]
+    try:
+        new_ref = getattr(self, cfg["var_attr"]).get()
+        self.log_gui.log(f"✓ {cfg['label']} 色域参考标准已更改为: {new_ref}")
+
+        if test_type not in self.config.current_test_types:
+            self.config.current_test_types[test_type] = {}
+        self.config.current_test_types[test_type]["gamut_reference"] = new_ref
+        self.save_pq_config()
+    except Exception as e:
+        self.log_gui.log(f"保存 {cfg['label']} 色域参考标准失败: {str(e)}")
+
+
+def on_screen_gamut_ref_changed(self, event=None):
+    _on_gamut_ref_changed(self, "screen_module", event)
+
+
+def on_sdr_gamut_ref_changed(self, event=None):
+    _on_gamut_ref_changed(self, "sdr_movie", event)
+
+
+def on_hdr_gamut_ref_changed(self, event=None):
+    _on_gamut_ref_changed(self, "hdr_movie", event)

app/views/panels/custom_template_panel.py

@@ -605,4 +605,13 @@ def start_custom_template_test(self):
     self.test_thread.daemon = True
     self.test_thread.start()
 
-
+def update_custom_button_visibility(self):
+    """只在 SDR 测试时显示客户模版按钮"""
+    if not hasattr(self, "custom_btn") or not hasattr(self, "test_type_var"):
+        return
+    if self.test_type_var.get() == "sdr_movie":
+        if not self.custom_btn.winfo_manager():
+            self.custom_btn.pack(side=tk.LEFT, padx=5)
+    else:
+        if self.custom_btn.winfo_manager():
+            self.custom_btn.pack_forget()

app/views/panels/main_layout.py

@@ -1,5 +1,6 @@
 """主布局面板创建函数（Step 6 重构）。"""
 
+import re
 import tkinter as tk
 import ttkbootstrap as ttk
 
@@ -496,3 +497,41 @@ def create_operation_frame(self):
     self.update_custom_button_visibility()
 
 
+
+
+def on_screen_module_timing_changed(self, event=None):
+    """屏模组信号格式改变时的回调"""
+    try:
+        selected_timing = self.screen_module_timing_var.get()
+
+        # 记录日志
+        self.log_gui.log(f"屏模组信号格式已更改为: {selected_timing}")
+
+        match = re.search(r"(\d+)x(\d+)\s*@\s*(\d+)", selected_timing)
+        if match:
+            width = int(match.group(1))
+            height = int(match.group(2))
+            refresh_rate = int(match.group(3))
+
+            self.log_gui.log(f"  ├─ 分辨率: {width}x{height}")
+            self.log_gui.log(f"  └─ 刷新率: {refresh_rate}Hz")
+
+            # 根据分辨率给出提示
+            if width >= 3840:  # 4K及以上
+                self.log_gui.log("  ℹ️ 检测到4K分辨率")
+
+            if refresh_rate >= 120:
+                self.log_gui.log("  ℹ️ 检测到高刷新率")
+
+        # 更新配置
+        self.config.set_current_timing(selected_timing)
+
+        # 如果正在测试，提示用户
+        if self.testing:
+            self.log_gui.log("⚠️ 警告: 测试进行中，信号格式更改将在下次测试时生效")
+
+        # 保存配置
+        self.save_pq_config()
+
+    except Exception as e:
+        self.log_gui.log(f"❌ 屏模组信号格式更改失败: {str(e)}")

app/views/panels/side_panels.py

@@ -182,231 +182,138 @@ def toggle_log_panel(self):
     self.show_panel("log")
 
 
-def toggle_screen_debug_panel(self):
+# ---- 单步调试面板（统一实现） ----
-    """打开/关闭屏模组单步调试面板（独立窗口）"""
+DEBUG_PANEL_CONFIGS = {
+    "screen_module": {
+        "window_attr": "debug_window",
+        "btn_attr": "screen_debug_btn",
+        "title": "🔧 单步调试面板",
+        "window_log_prefix": "",
+        "data_log_prefix": "屏模组",
+        "failure_data_label": "调试数据",
+        # (item_key, debug_key, (category, subkey), data_label, enable_desc)
+        "data_items": [
+            ("gamma", "gamma", ("shared", "gray"), "灰阶", "Gamma 单步调试"),
+            ("gamut", "rgb", ("gamut", "rgb"), "RGB", "RGB 单步调试"),
+        ],
+    },
+    "sdr_movie": {
+        "window_attr": "sdr_debug_window",
+        "btn_attr": "sdr_debug_btn",
+        "title": "🔧 SDR 单步调试面板",
+        "window_log_prefix": "SDR ",
+        "data_log_prefix": "SDR",
+        "failure_data_label": "SDR 调试数据",
+        "data_items": [
+            ("gamma", "gamma", ("shared", "gray"), "灰阶", "Gamma 单步调试"),
+            ("accuracy", "accuracy", ("accuracy", "measured"), "色准", "色准单步调试"),
+            ("gamut", "rgb", ("gamut", "rgb"), "RGB", "RGB 单步调试"),
+        ],
+    },
+    "hdr_movie": {
+        "window_attr": "hdr_debug_window",
+        "btn_attr": "hdr_debug_btn",
+        "title": "🔧 HDR 单步调试面板",
+        "window_log_prefix": "HDR ",
+        "data_log_prefix": "HDR",
+        "failure_data_label": "HDR 调试数据",
+        "data_items": [
+            ("eotf", "eotf", ("shared", "gray"), "灰阶", "EOTF 单步调试"),
+            ("accuracy", "accuracy", ("accuracy", "measured"), "色准", "色准单步调试"),
+            ("gamut", "rgb", ("gamut", "rgb"), "RGB", "RGB 单步调试"),
+        ],
+    },
+}
+
+
+def _toggle_debug_panel(self, test_type):
+    """打开/关闭对应测试类型的单步调试面板（独立窗口）。"""
+    cfg = DEBUG_PANEL_CONFIGS[test_type]
+    win_attr = cfg["window_attr"]
+    btn = getattr(self, cfg["btn_attr"])
+    wlp = cfg["window_log_prefix"]
+
     # 如果窗口已存在且可见，关闭它
-    if hasattr(self, "debug_window") and self.debug_window.winfo_exists():
+    existing = getattr(self, win_attr, None)
-        self.debug_window.destroy()
+    if existing is not None and existing.winfo_exists():
-        self.screen_debug_btn.config(text="打开调试面板")
+        existing.destroy()
-        self.log_gui.log("✓ 单步调试面板已关闭")
+        btn.config(text="打开调试面板")
+        self.log_gui.log(f"✓ {wlp}单步调试面板已关闭")
         return
 
     # 创建新窗口
-    self.debug_window = ttk.Toplevel(self.root)
+    win = ttk.Toplevel(self.root)
-    self.debug_window.title("🔧 单步调试面板")
+    win.title(cfg["title"])
-    self.debug_window.geometry("900x400")
+    win.geometry("900x400")
-    self.debug_window.transient(self.root)
+    win.transient(self.root)
+    setattr(self, win_attr, win)
 
-    # 创建调试面板容器
+    # 调试面板容器
-    debug_container = ttk.Frame(self.debug_window, padding=10)
+    debug_container = ttk.Frame(win, padding=10)
-    debug_container.pack(fill=tk.BOTH, expand=True)  # ← 这个 pack 是对的
+    debug_container.pack(fill=tk.BOTH, expand=True)
-
-    # 创建调试面板实例
-    from app.views.pq_debug_panel import PQDebugPanel
 
+    # 创建调试面板实例（不要对它调用 pack）
     debug_panel_instance = PQDebugPanel(debug_container, self)
-    # ← 这里不应该有任何 pack 调用！
 
-    self.log_gui.log("✓ 单步调试面板实例已创建")
+    self.log_gui.log(f"✓ {wlp}单步调试面板实例已创建")
 
     # 重新启用调试（如果有数据）
     try:
-        test_type = self.config.current_test_type
         selected_items = self.get_selected_test_items()
-
+        dlp = cfg["data_log_prefix"]
-        if test_type == "screen_module":
+        for item_key, debug_key, (cat, sub), data_label, enable_desc in cfg["data_items"]:
-            if "gamma" in selected_items:
+            if item_key not in selected_items:
-                gray_data = self.results.get_intermediate_data("shared", "gray")
+                continue
-                if gray_data:
+            data = self.results.get_intermediate_data(cat, sub)
-                    self.log_gui.log(f"  → 加载 {len(gray_data)} 个灰阶数据点")
+            if not data:
-                    debug_panel_instance.enable_debug(
+                if test_type == "screen_module" and item_key == "gamma":
-                        "screen_module", "gamma", gray_data
-                    )
-                    self.log_gui.log("✓ 屏模组 Gamma 单步调试已重新启用")
-                else:
                     self.log_gui.log("  ✗ 没有可用的灰阶数据")
-
+                continue
-            if "gamut" in selected_items:
+            self.log_gui.log(f"  → 加载 {len(data)} 个{data_label}数据点")
-                rgb_data = self.results.get_intermediate_data("gamut", "rgb")
+            debug_panel_instance.enable_debug(test_type, debug_key, data)
-                if rgb_data:
+            self.log_gui.log(f"✓ {dlp} {enable_desc}已重新启用")
-                    self.log_gui.log(f"  → 加载 {len(rgb_data)} 个RGB数据点")
-                    debug_panel_instance.enable_debug(
-                        "screen_module", "rgb", rgb_data
-                    )
-                    self.log_gui.log("✓ 屏模组 RGB 单步调试已重新启用")
-
     except Exception as e:
-        self.log_gui.log(f"⚠️ 加载调试数据失败: {str(e)}")
+        self.log_gui.log(f"⚠️ 加载{cfg['failure_data_label']}失败: {str(e)}")
-        import traceback
-
         self.log_gui.log(traceback.format_exc())
 
-    # 更新按钮文字
+    btn.config(text="关闭调试面板")
-    self.screen_debug_btn.config(text="关闭调试面板")
 
-    # 窗口关闭时的回调
     def on_closing():
-        self.screen_debug_btn.config(text="打开调试面板")
+        btn.config(text="打开调试面板")
-        self.debug_window.destroy()
+        getattr(self, win_attr).destroy()
-        self.log_gui.log("✓ 单步调试窗口已关闭")
+        self.log_gui.log(f"✓ {wlp}单步调试窗口已关闭")
 
-    self.debug_window.protocol("WM_DELETE_WINDOW", on_closing)
+    win.protocol("WM_DELETE_WINDOW", on_closing)
-    self.debug_window.update_idletasks()
+    win.update_idletasks()
 
-    self.log_gui.log("✓ 单步调试面板已打开（独立窗口）")
+    self.log_gui.log(f"✓ {wlp}单步调试面板已打开（独立窗口）")
+
+
+def toggle_screen_debug_panel(self):
+    _toggle_debug_panel(self, "screen_module")
 
 
 def toggle_sdr_debug_panel(self):
-    """打开/关闭 SDR 单步调试面板（独立窗口）"""
+    _toggle_debug_panel(self, "sdr_movie")
-    # 如果窗口已存在且可见，关闭它
-    if hasattr(self, "sdr_debug_window") and self.sdr_debug_window.winfo_exists():
-        self.sdr_debug_window.destroy()
-        self.sdr_debug_btn.config(text="打开调试面板")
-        self.log_gui.log("✓ SDR 单步调试面板已关闭")
-        return
-
-    # 创建新窗口
-    self.sdr_debug_window = ttk.Toplevel(self.root)
-    self.sdr_debug_window.title("🔧 SDR 单步调试面板")
-    self.sdr_debug_window.geometry("900x400")
-    self.sdr_debug_window.transient(self.root)
-
-    # 创建调试面板容器
-    debug_container = ttk.Frame(self.sdr_debug_window, padding=10)
-    debug_container.pack(fill=tk.BOTH, expand=True)
-
-    # ✅ 创建调试面板实例（不要对它调用 pack）
-    from app.views.pq_debug_panel import PQDebugPanel
-
-    debug_panel_instance = PQDebugPanel(debug_container, self)
-    # ← 删除：debug_panel_instance.pack(...)
-
-    self.log_gui.log("✓ SDR 单步调试面板实例已创建")
-
-    # ✅ 重新启用调试（如果有数据）
-    try:
-        selected_items = self.get_selected_test_items()
-
-        if "gamma" in selected_items:
-            gray_data = self.results.get_intermediate_data("shared", "gray")
-            if gray_data:
-                self.log_gui.log(f"  → 加载 {len(gray_data)} 个灰阶数据点")
-                debug_panel_instance.enable_debug("sdr_movie", "gamma", gray_data)
-                self.log_gui.log("✓ SDR Gamma 单步调试已重新启用")
-
-        if "accuracy" in selected_items:
-            accuracy_data = self.results.get_intermediate_data(
-                "accuracy", "measured"
-            )
-            if accuracy_data:
-                self.log_gui.log(f"  → 加载 {len(accuracy_data)} 个色准数据点")
-                debug_panel_instance.enable_debug(
-                    "sdr_movie", "accuracy", accuracy_data
-                )
-                self.log_gui.log("✓ SDR 色准单步调试已重新启用")
-
-        if "gamut" in selected_items:
-            rgb_data = self.results.get_intermediate_data("gamut", "rgb")
-            if rgb_data:
-                self.log_gui.log(f"  → 加载 {len(rgb_data)} 个RGB数据点")
-                debug_panel_instance.enable_debug("sdr_movie", "rgb", rgb_data)
-                self.log_gui.log("✓ SDR RGB 单步调试已重新启用")
-
-    except Exception as e:
-        self.log_gui.log(f"⚠️ 加载 SDR 调试数据失败: {str(e)}")
-        import traceback
-
-        self.log_gui.log(traceback.format_exc())
-
-    # 更新按钮文字
-    self.sdr_debug_btn.config(text="关闭调试面板")
-
-    # 窗口关闭时的回调
-    def on_closing():
-        self.sdr_debug_btn.config(text="打开调试面板")
-        self.sdr_debug_window.destroy()
-        self.log_gui.log("✓ SDR 单步调试窗口已关闭")
-
-    self.sdr_debug_window.protocol("WM_DELETE_WINDOW", on_closing)
-    self.sdr_debug_window.update_idletasks()
-
-    self.log_gui.log("✓ SDR 单步调试面板已打开（独立窗口）")
 
 
 def toggle_hdr_debug_panel(self):
-    """打开/关闭 HDR 单步调试面板（独立窗口）"""
+    _toggle_debug_panel(self, "hdr_movie")
-    # 如果窗口已存在且可见，关闭它
-    if hasattr(self, "hdr_debug_window") and self.hdr_debug_window.winfo_exists():
-        self.hdr_debug_window.destroy()
-        self.hdr_debug_btn.config(text="打开调试面板")
-        self.log_gui.log("✓ HDR 单步调试面板已关闭")
-        return
-
-    # 创建新窗口
-    self.hdr_debug_window = ttk.Toplevel(self.root)
-    self.hdr_debug_window.title("🔧 HDR 单步调试面板")
-    self.hdr_debug_window.geometry("900x400")
-    self.hdr_debug_window.transient(self.root)
-
-    # 创建调试面板容器
-    debug_container = ttk.Frame(self.hdr_debug_window, padding=10)
-    debug_container.pack(fill=tk.BOTH, expand=True)
-
-    # ✅ 创建调试面板实例（不要对它调用 pack）
-    from app.views.pq_debug_panel import PQDebugPanel
-
-    debug_panel_instance = PQDebugPanel(debug_container, self)
-    # ← 删除：debug_panel_instance.pack(...)
-
-    self.log_gui.log("✓ HDR 单步调试面板实例已创建")
-
-    # ✅ 重新启用调试（如果有数据）
-    try:
-        selected_items = self.get_selected_test_items()
-
-        if "eotf" in selected_items:
-            gray_data = self.results.get_intermediate_data("shared", "gray")
-            if gray_data:
-                self.log_gui.log(f"  → 加载 {len(gray_data)} 个灰阶数据点")
-                debug_panel_instance.enable_debug("hdr_movie", "eotf", gray_data)
-                self.log_gui.log("✓ HDR EOTF 单步调试已重新启用")
-
-        if "accuracy" in selected_items:
-            accuracy_data = self.results.get_intermediate_data(
-                "accuracy", "measured"
-            )
-            if accuracy_data:
-                self.log_gui.log(f"  → 加载 {len(accuracy_data)} 个色准数据点")
-                debug_panel_instance.enable_debug(
-                    "hdr_movie", "accuracy", accuracy_data
-                )
-                self.log_gui.log("✓ HDR 色准单步调试已重新启用")
-
-        if "gamut" in selected_items:
-            rgb_data = self.results.get_intermediate_data("gamut", "rgb")
-            if rgb_data:
-                self.log_gui.log(f"  → 加载 {len(rgb_data)} 个RGB数据点")
-                debug_panel_instance.enable_debug("hdr_movie", "rgb", rgb_data)
-                self.log_gui.log("✓ HDR RGB 单步调试已重新启用")
-
-    except Exception as e:
-        self.log_gui.log(f"⚠️ 加载 HDR 调试数据失败: {str(e)}")
-        import traceback
-
-        self.log_gui.log(traceback.format_exc())
-
-    # 更新按钮文字
-    self.hdr_debug_btn.config(text="关闭调试面板")
-
-    # 窗口关闭时的回调
-    def on_closing():
-        self.hdr_debug_btn.config(text="打开调试面板")
-        self.hdr_debug_window.destroy()
-        self.log_gui.log("✓ HDR 单步调试窗口已关闭")
-
-    self.hdr_debug_window.protocol("WM_DELETE_WINDOW", on_closing)
-    self.hdr_debug_window.update_idletasks()
-
-    self.log_gui.log("✓ HDR 单步调试面板已打开（独立窗口）")
 
 
+
+def update_sidebar_selection(self):
+    """更新侧边栏按钮的选中状态"""
+    # 重置所有按钮样式为默认
+    self.screen_module_btn.configure(style="Sidebar.TButton")
+    self.sdr_movie_btn.configure(style="Sidebar.TButton")
+    self.hdr_movie_btn.configure(style="Sidebar.TButton")
+
+    # 设置当前选中按钮的样式
+    current_type = self.test_type_var.get()
+    if current_type == "screen_module":
+        self.screen_module_btn.configure(style="SidebarSelected.TButton")
+    elif current_type == "sdr_movie":
+        self.sdr_movie_btn.configure(style="SidebarSelected.TButton")
+    elif current_type == "hdr_movie":
+        self.hdr_movie_btn.configure(style="SidebarSelected.TButton")