MOKA/pqAutomationApp
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
xinzhu.yin
2026-04-21 10:48:15 +08:00
parent 982210a724
commit a5595b7e60
5 changed files with 421 additions and 2699 deletions
Download Patch File Download Diff File Expand all files Collapse all files

411
app/views/panels/cct_panel.py
View File

@@ -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 = {
"x_ideal": 0.3127,
"x_tolerance": 0.003,
"y_ideal": 0.3290,
"y_tolerance": 0.003,
}
screen_default_cct_params = self.config.get_default_cct_params("screen_module")
# 从配置读取屏模组参数
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 = {
"x_ideal": 0.3127,
"x_tolerance": 0.003,
"y_ideal": 0.3290,
"y_tolerance": 0.003,
}
sdr_default_cct_params = self.config.get_default_cct_params("sdr_movie")
# 从配置读取 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 = {
"x_ideal": 0.3127,
"x_tolerance": 0.003,
"y_ideal": 0.3290,
"y_tolerance": 0.003,
}
hdr_default_cct_params = self.config.get_default_cct_params("hdr_movie")
# 从配置读取 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):
"""SDR 色度参数失去焦点时的处理"""
def _get_cct_var_dict(self, test_type):
"""按测试类型返回 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 色度参数"""
try:
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
"""保存 SDR 色度参数。"""
self._save_cct_params_for("sdr_movie")
def on_hdr_cct_param_focus_out(self, var, default_value):
"""HDR 色度参数失去焦点时的处理"""
try:
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)}")
"""HDR 色度参数失去焦点时的处理。"""
self._handle_cct_focus_out(var, default_value, self.save_hdr_cct_params, "HDR")
def save_hdr_cct_params(self):
"""保存 HDR 色度参数"""
try:
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
"""保存 HDR 色度参数。"""
self._save_cct_params_for("hdr_movie")
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,
"coverage": coverage_xy,
"area_xy": area_xy,
"coverage_xy": coverage_xy,
"area_uv": area_uv,
"coverage_uv": coverage_uv,
"uv_coverage": coverage_uv,
"area": area_xy, # ← 兼容旧字段
"coverage": coverage_xy, # ← 兼容旧字段
"area_xy": area_xy, # ← XY 面积
"coverage_xy": coverage_xy, # ← XY 覆盖率
"area_uv": area_uv, # ← UV 面积
"coverage_uv": coverage_uv, # ← 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:
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)}")
self._handle_cct_focus_out(var, default_value, self.save_cct_params, "屏模组")
def save_cct_params(self):
"""保存色度参数 - 简化版"""
try:
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
self._save_cct_params_for(self.config.current_test_type)
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)

11
app/views/panels/custom_template_panel.py
View File

@@ -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()

39
app/views/panels/main_layout.py
View File

@@ -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)}")

307
app/views/panels/side_panels.py
View File

@@ -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():
self.debug_window.destroy()
self.screen_debug_btn.config(text="打开调试面板")
self.log_gui.log("✓ 单步调试面板已关闭")
existing = getattr(self, win_attr, None)
if existing is not None and existing.winfo_exists():
existing.destroy()
btn.config(text="打开调试面板")
self.log_gui.log(f"✓ {wlp}单步调试面板已关闭")
return
# 创建新窗口
self.debug_window = ttk.Toplevel(self.root)
self.debug_window.title("🔧 单步调试面板")
self.debug_window.geometry("900x400")
self.debug_window.transient(self.root)
win = ttk.Toplevel(self.root)
win.title(cfg["title"])
win.geometry("900x400")
win.transient(self.root)
setattr(self, win_attr, win)
# 创建调试面板容器
debug_container = ttk.Frame(self.debug_window, padding=10)
debug_container.pack(fill=tk.BOTH, expand=True) # ← 这个 pack 是对的
# 创建调试面板实例
from app.views.pq_debug_panel import PQDebugPanel
# 调试面板容器
debug_container = ttk.Frame(win, padding=10)
debug_container.pack(fill=tk.BOTH, expand=True)
# 创建调试面板实例（不要对它调用 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()
if test_type == "screen_module":
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(
"screen_module", "gamma", gray_data
)
self.log_gui.log("✓ 屏模组 Gamma 单步调试已重新启用")
else:
dlp = cfg["data_log_prefix"]
for item_key, debug_key, (cat, sub), data_label, enable_desc in cfg["data_items"]:
if item_key not in selected_items:
continue
data = self.results.get_intermediate_data(cat, sub)
if not data:
if test_type == "screen_module" and item_key == "gamma":
self.log_gui.log(" ✗ 没有可用的灰阶数据")
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(
"screen_module", "rgb", rgb_data
)
self.log_gui.log("✓ 屏模组 RGB 单步调试已重新启用")
continue
self.log_gui.log(f" → 加载 {len(data)} 个{data_label}数据点")
debug_panel_instance.enable_debug(test_type, debug_key, data)
self.log_gui.log(f"✓ {dlp} {enable_desc}已重新启用")
except Exception as e:
self.log_gui.log(f"⚠️ 加载调试数据失败: {str(e)}")
import traceback
self.log_gui.log(f"⚠️ 加载{cfg['failure_data_label']}失败: {str(e)}")
self.log_gui.log(traceback.format_exc())
# 更新按钮文字
self.screen_debug_btn.config(text="关闭调试面板")
btn.config(text="关闭调试面板")
# 窗口关闭时的回调
def on_closing():
self.screen_debug_btn.config(text="打开调试面板")
self.debug_window.destroy()
self.log_gui.log("✓ 单步调试窗口已关闭")
btn.config(text="打开调试面板")
getattr(self, win_attr).destroy()
self.log_gui.log(f"✓ {wlp}单步调试窗口已关闭")
self.debug_window.protocol("WM_DELETE_WINDOW", on_closing)
self.debug_window.update_idletasks()
win.protocol("WM_DELETE_WINDOW", on_closing)
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 单步调试面板（独立窗口）"""
# 如果窗口已存在且可见，关闭它
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 单步调试面板已打开（独立窗口）")
_toggle_debug_panel(self, "sdr_movie")
def toggle_hdr_debug_panel(self):
"""打开/关闭 HDR 单步调试面板（独立窗口）"""
# 如果窗口已存在且可见，关闭它
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 单步调试面板已打开（独立窗口）")
_toggle_debug_panel(self, "hdr_movie")
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")