import numpy as np
import cv2

class SFRMeasurement:
    """
    空间频率响应（SFR）测量
    
    ISO 12233 标准方法
    用于评估 DMS 摄像头在不同空间频率下的细节还原能力
    
    关键指标：
    - 中心 SFR：图像中心区域
    - 边角 SFR：图像四角
    - Nyquist 频率：传感器采样极限
    """
    
    def __init__(self):
        self.iso_standard = "ISO 12233:2023"
        self.test_charts = {
            'slanted_edge': '倾斜边缘图卡（标准方法）',
            'siemens_star': '西门子星图（替代方法）',
            'dead_leaves': '枯叶图（纹理方法）'
        }
        
    def measure_sfr(self, image: np.ndarray, region: str = 'center') -> dict:
        """
        测量指定区域的 SFR
        
        Args:
            image: 测试图卡图像
            region: 'center', 'corner', 'edge'
        Returns:
            sfr_data: 包含 SFR 曲线和关键指标
        """
        # 裁剪感兴趣区域
        h, w = image.shape[:2]
        if region == 'center':
            roi = image[h//4:3*h//4, w//4:3*w//4]
        elif region == 'corner':
            roi = image[:h//8, :w//8]  # 左上角
        else:
            roi = image[h//2:3*h//4, w//2:3*w//4]
        
        # 使用倾斜边缘法
        # 1. 找边缘
        edges = cv2.Canny(roi, 50, 150)
        
        # 2. 计算边缘扩展函数（ESF）
        esf = np.mean(roi, axis=1)  # 简化版
        
        # 3. 计算 LSF（线扩展函数 = ESF 的导数）
        lsf = np.diff(esf)
        
        # 4. FFT 得到 SFR
        sfr = np.abs(np.fft.fft(lsf))
        sfr = sfr / sfr[0]  # 归一化
        
        # 关键指标
        nyquist_freq = 0.5  # 归一化 Nyquist
        sfr_at_nyquist = np.interp(nyquist_freq, 
                                    np.linspace(0, 1, len(sfr)), 
                                    sfr)
        
        # MTF50：SFR 下降到 50% 时的频率
        mtf50_idx = np.where(sfr < 0.5)[0]
        mtf50 = mtf50_idx[0] / len(sfr) if len(mtf50_idx) > 0 else 1.0
        
        return {
            'region': region,
            'sfr_curve': sfr.tolist(),
            'sfr_at_nyquist': float(sfr_at_nyquist),
            'mtf50': float(mtf50),
            'iso_standard': self.iso_standard,
        }
    
    def evaluate_dms_requirements(self, sfr_data: dict) -> str:
        """评估是否满足 DMS 需求"""
        # DMS 需要至少 15 pixels per eye (IEEE P2020 建议)
        # 对应 SFR@Nyquist > 0.3
        if sfr_data['sfr_at_nyquist'] > 0.3:
            return "✅ 满足 DMS 分辨率需求"
        elif sfr_data['sfr_at_nyquist'] > 0.15:
            return "⚠️ 边缘可用，中心区域可能不满足"
        else:
            return "❌ 不满足 DMS 需求"


# 测试
if __name__ == "__main__":
    sfr = SFRMeasurement()
    # 模拟测试图图
    test_image = np.random.randint(0, 255, (480, 640), dtype=np.uint8)
    
    for region in ['center', 'corner']:
        result = sfr.measure_sfr(test_image, region)
        print(f"\n{region} SFR:")
        print(f"  SFR@Nyquist: {result['sfr_at_nyquist']:.3f}")
        print(f"  MTF50: {result['mtf50']:.3f}")
        print(f"  {sfr.evaluate_dms_requirements(result)}")

class DistortionMeasurement:
    """
    局部几何畸变测量
    
    ISO 17850 标准
    
    DMS 关键场景：
    - 如果算法需要 15 pixels/eye，中心可能满足
      但边角由于畸变可能只有 10 pixels/eye
    - 畸变导致眼距测量不准确
    """
    
    def __init__(self):
        self.iso_standard = "ISO 17850:2023"
        # Image Engineering 的 GEOCAL 设备
        # 创建来自无穷远的光点网格用于畸变测量
        
    def measure_distortion(self, image: np.ndarray) -> dict:
        """
        测量局部几何畸变
        
        Returns:
            distortion_data: 包含畸变系数和网格
        """
        # 简化版：使用棋盘格检测
        found, corners = cv2.findChessboardCorners(
            image, (9, 6), 
            cv2.CALIB_CB_ADAPTIVE_THRESH + cv2.CALIB_CB_NORMALIZE_IMAGE
        )
        
        if found:
            # 计算畸变系数
            h, w = image.shape[:2]
            objp = np.zeros((6*9, 3), np.float32)
            objp[:, :2] = np.mgrid[0:9, 0:6].T.reshape(-1, 2)
            
            ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(
                [objp], [corners], (w, h), None, None
            )
            
            # 畸变量化
            max_distortion = np.max(np.abs(dist))
            
            return {
                'k1': float(dist[0][0]),  # 径向畸变 k1
                'k2': float(dist[0][1]),  # 径向畸变 k2
                'p1': float(dist[0][2]),  # 切向畸变 p1
                'p2': float(dist[0][3]),  # 切向畸变 p2
                'max_distortion_pct': max_distortion * 100,
                'iso_standard': self.iso_standard,
            }
        
        return {'error': 'Chessboard not detected'}
    
    def evaluate_dms_requirements(self, dist_data: dict) -> str:
        """评估 DMS 畸变要求"""
        if 'max_distortion_pct' in dist_data:
            d = dist_data['max_distortion_pct']
            if d < 2:
                return "✅ 畸变 < 2%，满足 DMS"
            elif d < 5:
                return "⚠️ 畸变 2-5%，需要软件校正"
            else:
                return "❌ 畸变 > 5%，边角区域精度不足"
        return "N/A"

class DynamicRangeMeasurement:
    """
    动态范围（OECF）测量
    
    ISO 14524 标准
    
    DMS 关键场景：
    - 白天：阳光从车窗直射，高对比度
    - 夜间：仅 NIR 主动照明，极低光
    - 隧道出入口：快速光强变化
    
    传感器必须能在 0.1 lux 到 100,000 lux 范围内工作
    """
    
    def __init__(self):
        self.iso_standard = "ISO 14524:2023"
        self.test_conditions = {
            'daylight': {'lux': 10000, 'desc': '白天阳光直射'},
            'overcast': {'lux': 1000, 'desc': '阴天'},
            'dawn_dusk': {'lux': 10, 'desc': '黄昏/黎明'},
            'night_active': {'lux': 1, 'desc': '夜间 + NIR 主动照明'},
            'night_minimal': {'lux': 0.1, 'desc': '极低光'}
        }
    
    def measure_oecf(self, images_at_different_exposure: list) -> dict:
        """
        测量光电转换函数（OECF）
        
        Args:
            images_at_different_exposure: 不同曝光下的图像序列
        Returns:
            oecf_data: 包含 OECF 曲线和动态范围
        """
        # 从不同曝光图像中提取信号值
        signal_levels = []
        for img in images_at_different_exposure:
            # 使用灰阶图卡中心区域
            center = img[img.shape[0]//4:3*img.shape[0]//4,
                        img.shape[1]//4:3*img.shape[1]//4]
            signal_levels.append(np.mean(center))
        
        # 构建 OECF 曲线
        exposure_values = np.linspace(0, 1, len(signal_levels))
        oecf_curve = np.array(signal_levels) / 255.0
        
        # 动态范围计算
        # 从 SNR = 1 的点到饱和点
        snr_threshold = 1.0
        dynamic_range_stops = 0
        
        for i in range(1, len(signal_levels)):
            signal = signal_levels[i] - signal_levels[0]
            noise = np.std(images_at_different_exposure[i])
            if noise > 0 and signal / noise > snr_threshold:
                dynamic_range_stops += 1
        
        dr_db = 20 * np.log10(signal_levels[-1] / max(signal_levels[0], 1))
        
        return {
            'oecf_curve': oecf_curve.tolist(),
            'exposure_values': exposure_values.tolist(),
            'dynamic_range_db': float(dr_db),
            'dynamic_range_stops': int(dynamic_range_stops),
            'iso_standard': self.iso_standard,
        }
    
    def evaluate_dms_requirements(self, dr_data: dict) -> str:
        """评估 DMS 动态范围需求"""
        stops = dr_data.get('dynamic_range_stops', 0)
        # DMS 需要 ≥60dB (10 stops) 动态范围
        if stops >= 10:
            return f"✅ 动态范围 {stops} stops，满足 DMS 全场景"
        elif stops >= 7:
            return f"⚠️ 动态范围 {stops} stops，夜间可能受限"
        else:
            return f"❌ 动态范围 {stops} stops，无法覆盖昼夜场景"

class NoiseMeasurement:
    """
    噪声测量（信噪比 SNR）
    
    ISO 15739 标准
    
    DMS 关键：
    - 低光环境下噪声会掩盖眼睛细节
    - 噪声不能太低（会丢失信号），也不能太高
    - PERCLOS 需要精确的闭眼检测，噪声直接影响准确率
    """
    
    def __init__(self):
        self.iso_standard = "ISO 15739:2023"
        
    def measure_snr(self, image: np.ndarray) -> dict:
        """
        测量信噪比
        
        使用均匀灰阶图卡
        """
        # 使用图像中心区域
        h, w = image.shape[:2]
        roi = image[h//4:3*h//4, w//4:3*w//4].astype(np.float64)
        
        signal = np.mean(roi)
        noise = np.std(roi)
        
        if noise > 0:
            snr = signal / noise
            snr_db = 20 * np.log10(snr)
        else:
            snr = float('inf')
            snr_db = float('inf')
        
        return {
            'signal': float(signal),
            'noise': float(noise),
            'snr': float(snr),
            'snr_db': float(snr_db),
            'iso_standard': self.iso_standard,
        }
    
    def evaluate_dms_requirements(self, snr_data: dict) -> str:
        """评估 DMS 噪声需求"""
        snr_db = snr_data.get('snr_db', 0)
        # DMS 需要 SNR > 30dB 在最低工作照度
        if snr_db > 35:
            return f"✅ SNR = {snr_db:.1f} dB，满足 PERCLOS 检测"
        elif snr_db > 25:
            return f"⚠️ SNR = {snr_db:.1f} dB，边缘场景可能误检"
        else:
            return f"❌ SNR = {snr_db:.1f} dB，噪声影响检测精度"

class ColorAccuracy:
    """
    色彩准确度测量
    
    用于 RGB-IR 传感器（DMS/OMS 常用）
    
    注意：纯 NIR DMS 不需要色彩准确度
    但 RGB-IR 传感器在白天模式下需要
    """
    
    def __init__(self):
        self.iso_standard = "ISO 17321-1 (色彩再现)"
        self.test_chart = "ColorChecker SG (140 色)"
        
    def measure_color_accuracy(self, image: np.ndarray) -> dict:
        """测量色彩准确度"""
        # 简化版：从 ColorChecker 图像中提取色块
        # 实际需要校准色彩图卡
        
        # 计算色彩误差
        # 使用 CIEDE2000 色差公式
        
        return {
            'mean_delta_E': 3.2,  # 示例值
            'max_delta_E': 8.5,
            'skin_tone_delta_E': 2.1,  # 肤色：肤色
            'iso_standard': self.iso_standard,
        }
    
    def evaluate_dms_requirements(self, color_data: dict) -> str:
        """评估 DMS 色彩需求"""
        delta_e = color_data.get('mean_delta_E', 99)
        # DMS RGB 模式需要 ΔE < 5
        if delta_e < 3:
            return f"✅ ΔE = {delta_e}，色彩准确"
        elif delta_e < 5:
            return f"⚠️ ΔE = {delta_e}，可接受"
        else:
            return f"❌ ΔE = {delta_e}，肤色检测可能受影响"

class UniformityMeasurement:
    """
    照明和传感器响应均匀性测量
    
    DMS 关键：
    - NIR 主动照明需要均匀覆盖面部区域
    - 边角变暗会降低眼动检测精度
    """
    
    def __init__(self):
        self.test = "均匀白板在 DMS 工作距离拍摄"
        
    def measure_uniformity(self, image: np.ndarray) -> dict:
        """测量照明和传感器响应均匀性"""
        h, w = image.shape[:2]
        
        # 中心区域亮度
        center_roi = image[h//4:3*h//4, w//4:3*w//4]
        center_brightness = np.mean(center_roi)
        
        # 四角亮度
        corners = {
            'top_left': np.mean(image[:h//8, :w//8]),
            'top_right': np.mean(image[:h//8, 7*w//8:]),
            'bottom_left': np.mean(image[7*h//8:, :w//8]),
            'bottom_right': np.mean(image[7*h//8:, 7*w//8:]),
        }
        
        # 计算均匀性
        min_corner = min(corners.values())
        max_val = max(center_brightness, max(corners.values()))
        
        uniformity = (min_corner / center_brightness * 100) if center_brightness > 0 else 0
        falloff = ((center_brightness - min_corner) / center_brightness * 100) if center_brightness > 0 else 100
        
        return {
            'center_brightness': float(center_brightness),
            'corner_brightness': {k: float(v) for k, v in corners.items()},
            'uniformity_pct': float(uniformity),
            'corner_falloff_pct': float(falloff),
        }
    
    def evaluate_dms_requirements(self, uni_data: dict) -> str:
        """评估 DMS 均匀性需求"""
        u = uni_data.get('uniformity_pct', 0)
        # DMS 需要均匀性 > 60%（边角亮度不低于中心 60%）
        if u > 70:
            return f"✅ 均匀性 {u:.1f}%，面部区域照明均匀"
        elif u > 50:
            return f"⚠️ 均匀性 {u:.1f}%，边角可能影响检测"
        else:
            return f"❌ 均匀性 {u:.1f}%，需要改进照明设计"

class DMSImageQualitySuite:
    """
    DMS/OMS 摄像头图像质量完整测试套件
    
    整合 6 大测试维度
    遵循 ISO 标准
    """
    
    def __init__(self):
        self.tests = {
            'sfr': SFRMeasurement(),
            'distortion': DistortionMeasurement(),
            'dynamic_range': DynamicRangeMeasurement(),
            'noise': NoiseMeasurement(),
            'color': ColorAccuracy(),
            'uniformity': UniformityMeasurement(),
        }
        
        self.dms_requirements = {
            'sfr_at_nyquist': '> 0.3 (中心和边角)',
            'distortion': '< 2%',
            'dynamic_range': '≥ 60 dB (10 stops)',
            'snr': '> 30 dB @最低工作照度',
            'color_delta_E': '< 5 (RGB 模式)',
            'uniformity': '> 60%',
        }
    
    def run_full_test(self, test_images: dict) -> dict:
        """
        运行完整测试套件
        
        Args:
            test_images: 包含不同测试图卡的图像
        Returns:
            report: 完整测试报告
        """
        report = {
            'timestamp': '2026-08-19',
            'standard': 'ISO 12233/17850/14524/15739',
            'results': {},
            'summary': 'PASS',
        }
        
        for name, test in self.tests.items():
            if name in test_images:
                if name == 'sfr':
                    for region in ['center', 'corner']:
                        result = test.measure_sfr(test_images[name], region)
                        eval_result = test.evaluate_dms_requirements(result)
                        report['results'][f'{name}_{region}'] = {
                            'data': result,
                            'evaluation': eval_result
                        }
                else:
                    method = getattr(test, 'measure_snr', 
                                   getattr(test, 'measure_oecf', 
                                   getattr(test, 'measure_distortion', 
                                   getattr(test, 'measure_color_accuracy',
                                   getattr(test, 'measure_uniformity', None)))))
                    if method:
                        result = method(test_images[name])
                        eval_result = test.evaluate_dms_requirements(result)
                        report['results'][name] = {
                            'data': result,
                            'evaluation': eval_result
                        }
        
        # 汇总
        failures = [k for k, v in report['results'].items() 
                   if '❌' in v.get('evaluation', '')]
        warnings = [k for k, v in report['results'].items() 
                   if '⚠️' in v.get('evaluation', '')]
        
        if failures:
            report['summary'] = f'FAIL: {", ".join(failures)}'
        elif warnings:
            report['summary'] = f'WARNING: {", ".join(warnings)}'
        else:
            report['summary'] = 'PASS: All tests meet DMS requirements'
        
        return report
    
    def print_report(self, report: dict):
        """打印格式化报告"""
        print("=" * 60)
        print("DMS/OMS 摄像头图像质量测试报告")
        print("=" * 60)
        print(f"标准: {report['standard']}")
        print(f"日期: {report['timestamp']}")
        print(f"总结: {report['summary']}")
        print()
        
        for test_name, result in report['results'].items():
            print(f"--- {test_name} ---")
            print(f"  {result['evaluation']}")
            if 'data' in result:
                for k, v in result['data'].items():
                    if isinstance(v, (int, float, str)):
                        print(f"  {k}: {v}")
            print()


# ==================== 测试 ====================

if __name__ == "__main__":
    suite = DMSImageQualitySuite()
    
    # 模拟测试图像
    test_images = {
        'sfr': np.random.randint(0, 255, (480, 640), dtype=np.uint8),
        'noise': np.random.randint(50, 200, (480, 640), dtype=np.uint8),
        'uniformity': np.random.randint(80, 150, (480, 640), dtype=np.uint8),
    }
    
    report = suite.run_full_test(test_images)
    suite.print_report(report)