pqAutomationApp/app/pq/pq_config.py

# PQ自动化测试配置模块
import json
import copy


class PQConfig:
    def __init__(self, current_test_type="screen_module", device_config={}, pattern={}):
        self.default_cct_params_by_type = {
            "screen_module": {
                "x_ideal": 0.3127,
                "x_tolerance": 0.003,
                "y_ideal": 0.3290,
                "y_tolerance": 0.003,
            },
            "sdr_movie": {
                "x_ideal": 0.3127,
                "x_tolerance": 0.003,
                "y_ideal": 0.3290,
                "y_tolerance": 0.003,
            },
            "hdr_movie": {
                "x_ideal": 0.3127,
                "x_tolerance": 0.003,
                "y_ideal": 0.3290,
                "y_tolerance": 0.003,
            },
        }
        self.default_gamut_reference_by_type = {
            "screen_module": "DCI-P3",
            "sdr_movie": "BT.709",
            "hdr_movie": "BT.2020",
        }

        self.default_test_types = {
            "screen_module": {
                "name": "屏模组性能测试",
                "test_items": ["gamut", "gamma", "cct", "contrast"],
                "timing": "DMT 1920x 1080 @ 60Hz",
                "color_format": "RGB",
                "bpc": 8,
                "colorimetry": "sRGB",
            },
            "sdr_movie": {
                "name": "SDR Movie测试",
                "test_items": ["gamut", "gamma", "cct", "contrast", "accuracy"],
                "timing": "DMT 1920x 1080 @ 60Hz",
                "color_format": "RGB",
                "bpc": 8,
                "colorimetry": "sRGB",
            },
            "hdr_movie": {
                "name": "HDR Movie测试",
                "test_items": ["gamut", "eotf", "cct", "contrast", "accuracy"],
                "timing": "DMT 1920x 1080 @ 60Hz",
                "color_format": "RGB",
                "bpc": 8,
                "colorimetry": "sRGB",
            },
        }

        # 设备连接配置
        self.device_config = {
            "ca_com": "COM1",
            "ucd_list": "0: UCD-323 [2128C209]",
            "ca_channel": "0",
        }

        # ========== RGB Pattern 配置 ==========
        self.default_pattern_rgb = {
            "pattern_mode": "SolidColor",
            "measurement_bit_depth": 8,
            "measurement_max_value": 2,
            "pattern_params": [
                [255, 0, 0],  # 红色
                [0, 255, 0],  # 绿色
                [0, 0, 255],  # 蓝色
            ],
        }

        # ========== 灰阶 Pattern 配置 ==========
        self.default_pattern_gray = {
            "pattern_mode": "SolidColor",
            "measurement_bit_depth": 8,
            "measurement_max_value": 10,
            "pattern_params": [
                [255, 255, 255],  # 100% 白色
                [230, 230, 230],  # 90%
                [205, 205, 205],  # 80%
                [179, 179, 179],  # 70%
                [154, 154, 154],  # 60%
                [128, 128, 128],  # 50%
                [102, 102, 102],  # 40%
                [78, 78, 78],  # 30%
                [52, 52, 52],  # 20%
                [26, 26, 26],  # 10%
                [0, 0, 0],  # 0% 黑色
            ],
        }

        # ========== 色准 Pattern 配置（29色 - SDR 和 HDR 通用）==========
        self.default_pattern_accuracy = {
            "pattern_mode": "SolidColor",
            "measurement_bit_depth": 8,
            "measurement_max_value": 28,  # 29个颜色，最大索引是28
            "pattern_params": [
                # ========== 灰阶 (5个) ==========
                [255, 255, 255],  # 0: White
                [230, 230, 230],  # 1: Gray 80
                [209, 209, 209],  # 2: Gray 65
                [186, 186, 186],  # 3: Gray 50
                [158, 158, 158],  # 4: Gray 35
                # ========== ColorChecker 24色 (18个) ==========
                [115, 82, 66],  # 5: Dark Skin
                [194, 150, 130],  # 6: Light Skin
                [94, 122, 156],  # 7: Blue Sky
                [89, 107, 66],  # 8: Foliage
                [130, 128, 176],  # 9: Blue Flower
                [99, 189, 168],  # 10: Bluish Green
                [217, 120, 41],  # 11: Orange
                [74, 92, 163],  # 12: Purplish Blue
                [194, 84, 97],  # 13: Moderate Red
                [92, 61, 107],  # 14: Purple
                [158, 186, 64],  # 15: Yellow Green
                [230, 161, 46],  # 16: Orange Yellow
                [51, 61, 150],  # 17: Blue (Legacy)
                [71, 148, 71],  # 18: Green (Legacy)
                [176, 48, 59],  # 19: Red (Legacy)
                [237, 199, 33],  # 20: Yellow (Legacy)
                [186, 84, 145],  # 21: Magenta (Legacy)
                [0, 133, 163],  # 22: Cyan (Legacy)
                # ========== 100% 饱和色 (6个) ==========
                [255, 0, 0],  # 23: 100% Red
                [0, 255, 0],  # 24: 100% Green
                [0, 0, 255],  # 25: 100% Blue
                [0, 255, 255],  # 26: 100% Cyan
                [255, 0, 255],  # 27: 100% Magenta
                [255, 255, 0],  # 28: 100% Yellow
            ],
        }

        self.default_pattern_temp = {
            "pattern_mode": "SolidColor",
            "measurement_bit_depth": 8,
            "measurement_max_value": 146,
            "pattern_params": [
                [255, 255, 255],
                [242, 242, 242],
                [230, 230, 230],
                [217, 217, 217],
                [204, 204, 204],
                [191, 191, 191],
                [179, 179, 179],
                [166, 166, 166],
                [153, 153, 153],
                [140, 140, 140],
                [128, 128, 128],
                [115, 115, 115],
                [102, 102, 102],
                [89, 89, 89],
                [77, 77, 77],
                [64, 64, 64],
                [51, 51, 51],
                [38, 38, 38],
                [26, 26, 26],
                [13, 13, 13],
                [0, 0, 0],

                [255, 0, 0],
                [242, 0, 0],
                [230, 0, 0],
                [217, 0, 0],
                [204, 0, 0],
                [191, 0, 0],
                [179, 0, 0],
                [166, 0, 0],
                [153, 0, 0],
                [140, 0, 0],
                [128, 0, 0],
                [115, 0, 0],
                [102, 0, 0],
                [89, 0, 0],
                [77, 0, 0],
                [64, 0, 0],
                [51, 0, 0],
                [38, 0, 0],
                [26, 0, 0],
                [13, 0, 0],
                [0, 0, 0],

                [0, 255, 0],
                [0, 242, 0],
                [0, 230, 0],
                [0, 217, 0],
                [0, 204, 0],
                [0, 191, 0],
                [0, 179, 0],
                [0, 166, 0],
                [0, 153, 0],
                [0, 140, 0],
                [0, 128, 0],
                [0, 115, 0],
                [0, 102, 0],
                [0, 89, 0],
                [0, 77, 0],
                [0, 64, 0],
                [0, 51, 0],
                [0, 38, 0],
                [0, 26, 0],
                [0, 13, 0],
                [0, 0, 0],

                [0, 0, 255],
                [0, 0, 242],
                [0, 0, 230],
                [0, 0, 217],
                [0, 0, 204],
                [0, 0, 191],
                [0, 0, 179],
                [0, 0, 166],
                [0, 0, 153],
                [0, 0, 140],
                [0, 0, 128],
                [0, 0, 115],
                [0, 0, 102],
                [0, 0, 89],
                [0, 0, 77],
                [0, 0, 64],
                [0, 0, 51],
                [0, 0, 38],
                [0, 0, 26],
                [0, 0, 13],
                [0, 0, 0],

                [255, 255, 0],
                [242, 242, 0],
                [230, 230, 0],
                [217, 217, 0],
                [204, 204, 0],
                [191, 191, 0],
                [179, 179, 0],
                [166, 166, 0],
                [153, 153, 0],
                [140, 140, 0],
                [128, 128, 0],
                [115, 115, 0],
                [102, 102, 0],
                [89, 89, 0],
                [77, 77, 0],
                [64, 64, 0],
                [51, 51, 0],
                [38, 38, 0],
                [26, 26, 0],
                [13, 13, 0],
                [0, 0, 0],

                [0, 255, 255],
                [0, 242, 242],
                [0, 230, 230],
                [0, 217, 217],
                [0, 204, 204],
                [0, 191, 191],
                [0, 179, 179],
                [0, 166, 166],
                [0, 153, 153],
                [0, 140, 140],
                [0, 128, 128],
                [0, 115, 115],
                [0, 102, 102],
                [0, 89, 89],
                [0, 77, 77],
                [0, 64, 64],
                [0, 51, 51],
                [0, 38, 38],
                [0, 26, 26],
                [0, 13, 13],
                [0, 0, 0],

                [255, 0, 255],
                [242, 0, 242],
                [230, 0, 230],
                [217, 0, 217],
                [204, 0, 204],
                [191, 0, 191],
                [179, 0, 179],
                [166, 0, 166],
                [153, 0, 153],
                [140, 0, 140],
                [128, 0, 128],
                [115, 0, 115],
                [102, 0, 102],
                [89, 0, 89],
                [77, 0, 77],
                [64, 0, 64],
                [51, 0, 51],
                [38, 0, 38],
                [26, 0, 26],
                [13, 0, 13],
                [0, 0, 0],
            ]
        }

        # 自定义图案
        self.custom_pattern = {
            "pattern_mode": "SolidColor",
            "measurement_bit_depth": 8,
            "measurement_max_value": 0,
            "pattern_params": [],
        }

        self.current_test_types = self.default_test_types
        self.current_test_type = current_test_type
        self.current_pattern = self.default_pattern_rgb

    def get_default_cct_params(self, test_type):
        """获取指定测试类型的默认 CCT 参数副本。"""
        default = self.default_cct_params_by_type.get(
            test_type, self.default_cct_params_by_type["screen_module"]
        )
        return copy.deepcopy(default)

    def get_default_gamut_reference(self, test_type):
        """获取指定测试类型的默认色域参考。"""
        return self.default_gamut_reference_by_type.get(test_type, "DCI-P3")

    # ========== 获取临时配置（用于 Full/Limited 转换）==========
    def get_temp_config_with_converted_params(self, mode, converted_params):
        """
        创建一个临时配置对象，包含转换后的 pattern 参数

        Args:
            mode: "rgb" | "gray" | "accuracy"
            converted_params: 转换后的参数列表（Full 或 Limited Range）

        Returns:
            PQConfig: 临时配置对象（深拷贝，不影响原始配置）
        """
        # 1. 深拷贝整个配置对象
        temp_config = copy.deepcopy(self)

        # 2. 设置正确的 pattern 模式
        if mode == "rgb":
            temp_config.current_pattern = copy.deepcopy(self.default_pattern_rgb)
        elif mode == "gray":
            temp_config.current_pattern = copy.deepcopy(self.default_pattern_gray)
        elif mode == "accuracy":
            temp_config.current_pattern = copy.deepcopy(self.default_pattern_accuracy)

        # 3. 替换为转换后的参数
        temp_config.current_pattern["pattern_params"] = converted_params

        return temp_config

    def to_dict(self):
        """将配置转换为字典格式"""
        return {
            "current_test_type": self.current_test_type,
            "test_types": self.current_test_types,
            "device_config": self.device_config,
            "default_pattern_rgb": self.default_pattern_rgb,
            "default_pattern_gray": self.default_pattern_gray,
            "default_pattern_accuracy": self.default_pattern_accuracy,
            "custom_pattern": self.custom_pattern,
        }

    def from_dict(self, config_dict):
        """从字典加载配置"""
        self.current_test_type = config_dict.get("current_test_type", "screen_module")
        self.current_test_types = config_dict.get("test_types", self.current_test_types)
        self.device_config = config_dict.get("device_config", self.device_config)

        self.default_pattern_rgb = config_dict.get(
            "default_pattern_rgb", self.default_pattern_rgb
        )
        self.default_pattern_gray = config_dict.get(
            "default_pattern_gray", self.default_pattern_gray
        )

        # ========== 强制使用新的 29色配置 ==========
        loaded_accuracy = config_dict.get("default_pattern_accuracy", None)

        # 检查加载的配置是否是旧的 10色
        if loaded_accuracy and len(loaded_accuracy.get("pattern_params", [])) != 29:
            print(
                f"检测到旧的配置（{len(loaded_accuracy.get('pattern_params', []))}色），强制使用新的 29色配置"
            )
            # 使用 __init__ 中定义的新配置
            self.default_pattern_accuracy = self.default_pattern_accuracy
        else:
            self.default_pattern_accuracy = config_dict.get(
                "default_pattern_accuracy", self.default_pattern_accuracy
            )
        # ==========================================

        self.custom_pattern = config_dict.get("custom_pattern", self.custom_pattern)

    def save_to_file(self, filename):
        """将配置保存到文件"""
        with open(filename, "w", encoding="utf-8") as f:
            json.dump(self.to_dict(), f, indent=4, ensure_ascii=False)

    def set_current_test_type(self, test_type):
        """设置当前测试类型"""
        if test_type in self.current_test_types:
            self.current_test_type = test_type
            return True
        return False

    def set_current_test_items(self, test_items):
        """设置当前测试类型的测试项"""
        if self.current_test_type in self.current_test_types:
            self.current_test_types[self.current_test_type]["test_items"] = test_items
            return True
        return False

    def set_current_timing(self, timing):
        if self.current_test_type in self.current_test_types:
            self.current_test_types[self.current_test_type]["timing"] = timing
            return True
        return False

    def set_device_config(self, ca_com, ucd_list, ca_channel):
        """设置设备连接配置"""
        self.device_config["ca_com"] = ca_com
        self.device_config["ucd_list"] = ucd_list
        self.device_config["ca_channel"] = ca_channel
        return True

    def set_current_pattern(self, mode):
        """设置当前模式的测试图案"""
        if mode == "rgb":
            self.current_pattern = self.default_pattern_rgb
        elif mode == "gray":
            self.current_pattern = self.default_pattern_gray
        elif mode == "accuracy":  # 色准模式（SDR 和 HDR 通用 29色）
            self.current_pattern = self.default_pattern_accuracy
        elif mode == "custom":
            # self.current_pattern = self.custom_pattern
            self.current_pattern = self.default_pattern_temp
        else:
            return False

        # 确保 measurement_max_value 是整数
        if "measurement_max_value" in self.current_pattern:
            value = self.current_pattern["measurement_max_value"]
            if isinstance(value, str):
                try:
                    self.current_pattern["measurement_max_value"] = int(value)
                except ValueError:
                    self.current_pattern["measurement_max_value"] = (
                        len(self.current_pattern["pattern_params"]) - 1
                    )

        return True

    def set_custom_pattern(self, pattern_mode, pattern_params):
        """设置自定义模式的测试项"""
        self.custom_pattern["pattern_mode"] = pattern_mode
        self.custom_pattern["pattern_params"] = pattern_params
        self.custom_pattern["measurement_max_value"] = len(pattern_params) - 1
        return True

    # ========== 获取 29色名称列表 ==========
    def get_accuracy_color_names(self):
        """
        获取色准测试的 29个颜色名称（SDR 和 HDR 通用）

        Returns:
            list: 29个颜色名称
        """
        return [
            # 灰阶 (5个)
            "White",
            "Gray 80",
            "Gray 65",
            "Gray 50",
            "Gray 35",
            # ColorChecker 24色 (18个)
            "Dark Skin",
            "Light Skin",
            "Blue Sky",
            "Foliage",
            "Blue Flower",
            "Bluish Green",
            "Orange",
            "Purplish Blue",
            "Moderate Red",
            "Purple",
            "Yellow Green",
            "Orange Yellow",
            "Blue (Legacy)",
            "Green (Legacy)",
            "Red (Legacy)",
            "Yellow (Legacy)",
            "Magenta (Legacy)",
            "Cyan (Legacy)",
            # 100% 饱和色 (6个)
            "100% Red",
            "100% Green",
            "100% Blue",
            "100% Cyan",
            "100% Magenta",
            "100% Yellow",
        ]

    # ========== 获取 29色的 RGB 值 ==========
    def get_accuracy_color_rgb(self):
        """
        获取色准测试的 RGB 值（用于标准值计算）

        Returns:
            list: [(name, r, g, b), ...]
        """
        names = self.get_accuracy_color_names()
        rgb_values = self.default_pattern_accuracy["pattern_params"]

        return [(name, r, g, b) for name, (r, g, b) in zip(names, rgb_values)]

    def get_temp_pattern_names(self):
        """获取客户模板测试（default_pattern_temp）的固定 pattern 名称列表"""
        percentages = list(range(100, -1, -5))
        color_prefixes = ["W", "R", "G", "B", "Y", "C", "M"]

        names = []
        for prefix in color_prefixes:
            for value in percentages:
                names.append(f"{prefix} {value}%")

        pattern_count = len(self.default_pattern_temp.get("pattern_params", []))

        if pattern_count <= len(names):
            return names[:pattern_count]

        # 兜底：如果后续扩展了 pattern 数量，补充通用名称，避免索引越界。
        for i in range(len(names), pattern_count):
            names.append(f"P {i + 1}")

        return names

    def get_test_item_chinese_names(self, test_items):
        """获取测试项目的显示名称"""
        item_names = []
        for item in test_items:
            if item == "gamut":
                item_names.append("色域")
            elif item == "gamma":
                item_names.append("Gamma")
            elif item == "eotf":
                item_names.append("EOTF")
            elif item == "cct":
                item_names.append("色度一致性")
            elif item == "contrast":
                item_names.append("对比度")
            elif item == "accuracy":
                item_names.append("色准")
            else:
                item_names.append(item)
        return item_names

    def get_current_config(self):
        """返回当前测试类型相关的所有配置信息"""
        if self.current_test_type not in self.current_test_types:
            return {}

        current_test = self.current_test_types[self.current_test_type]

        config_info = {
            "test_type": self.current_test_type,
            "test_name": current_test.get("name", "未知测试"),
            "test_items": current_test.get("test_items", []),
            "test_items_chinese": self.get_test_item_chinese_names(
                current_test.get("test_items", [])
            ),
            "timing": current_test.get("timing", "DMT 1920x 1080 @ 60Hz"),
            "color_format": current_test.get("color_format", "RGB"),
            "bpc": current_test.get("bpc", 8),
            "colorimetry": current_test.get("colorimetry", "sRGB"),
        }

        return config_info


# ========== 验证代码（测试完成后可删除）==========
if __name__ == "__main__":
    print("=" * 60)
    print("验证 pq_config.py 配置")
    print("=" * 60)

    config = PQConfig()

    # 检查 default_pattern_accuracy
    pattern_count = len(config.default_pattern_accuracy["pattern_params"])
    max_value = config.default_pattern_accuracy["measurement_max_value"]

    print(f"\ndefault_pattern_accuracy:")
    print(f"  图案数量: {pattern_count}")
    print(f"  measurement_max_value: {max_value}")

    if pattern_count == 29 and max_value == 28:
        print("\n配置正确（29色）")

        # 显示前 5 个图案
        print("\n前5个图案:")
        for i in range(5):
            rgb = config.default_pattern_accuracy["pattern_params"][i]
            names = config.get_accuracy_color_names()
            print(f"  [{i}] {names[i]:15s} RGB{rgb}")

        # 显示后 5 个图案
        print("\n后5个图案:")
        for i in range(24, 29):
            rgb = config.default_pattern_accuracy["pattern_params"][i]
            names = config.get_accuracy_color_names()
            print(f"  [{i}] {names[i]:15s} RGB{rgb}")

        # 测试 set_current_pattern
        print("\n测试 set_current_pattern('accuracy'):")
        config.set_current_pattern("accuracy")
        current_count = len(config.current_pattern["pattern_params"])
        print(f"  current_pattern 图案数量: {current_count}")

        if current_count == 29:
            print("  set_current_pattern 工作正常")
        else:
            print(f"  [Error] set_current_pattern 失败！只有 {current_count} 个图案")

    else:
        print(f"\n[Error] 配置错误！")
        print(f"   期望: 29 个图案, measurement_max_value=28")
        print(f"   实际: {pattern_count} 个图案, measurement_max_value={max_value}")

        print("\n[Error] 请检查 default_pattern_accuracy 定义！")
        print("   应该包含:")
        print("     - 5个灰阶")
        print("     - 18个 ColorChecker 色块")
        print("     - 6个 100% 饱和色")
        print("     - 总计 29 个 RGB 数组")

    print("=" * 60)