#!/usr/bin/env python3 """ Delta E* Color Difference Calculation Tool - Complete Refactoring Features: - Calculate color differences (Delta E*) in CIE LAB color space - Support multiple color difference calculation methods: CIE76, CIE94, CIEDE2000 - Input: LAB three-band image + standard color CSV file - Output: Color difference results as multi-band images or CSV files - Support arbitrary range selection for standard colors and target colors - Optional heatmap visualization output 依赖库： - numpy, pandas: 数据处理 - colour-science: Color difference calculation - matplotlib: 可视化 - spectral: ENVI文件处理 - tqdm: 进度条（可选） 安装依赖： pip install numpy pandas colour-science matplotlib spectral tqdm """ import numpy as np import pandas as pd import os import sys import warnings import argparse from pathlib import Path from typing import Optional, Tuple, List, Union, Dict, Any from dataclasses import dataclass, field from enum import Enum @dataclass class ColorDifferenceConfig: """色差计算配置类""" lab_image_path: Optional[str] = None standard_colors_path: Optional[str] = None method: str = 'CIEDE2000' output_dir: Optional[str] = None def __post_init__(self): """参数校验和默认值设置""" if not self.lab_image_path: raise ValueError("必须指定LAB图像文件路径(lab_image_path)") if not self.standard_colors_path: raise ValueError("必须指定标准颜色文件路径(standard_colors_path)") if self.method not in ['CIE76', 'CIE94', 'CIEDE2000']: raise ValueError(f"不支持的计算方法: {self.method}") if not self.output_dir: self.output_dir = './results' # 尝试导入可选依赖 try: from colour import delta_E COLOUR_AVAILABLE = True except ImportError: COLOUR_AVAILABLE = False print("警告: colour-science库不可用，请安装: pip install colour-science") try: import spectral SPECTRAL_AVAILABLE = True except ImportError: SPECTRAL_AVAILABLE = False print("警告: spectral库不可用，将无法处理ENVI格式文件") try: import matplotlib.pyplot as plt import matplotlib.colors as mcolors from matplotlib import cm MATPLOTLIB_AVAILABLE = True except ImportError: MATPLOTLIB_AVAILABLE = False print("Warning: matplotlib not available, heatmap generation will be disabled") try: from tqdm import tqdm TQDM_AVAILABLE = True except ImportError: TQDM_AVAILABLE = False print("提示: tqdm库不可用，进度条将不可用。安装: pip install tqdm") class DeltaEMethod(Enum): """Color difference calculation method enumeration""" CIE76 = "CIE76" CIE94 = "CIE94" CIEDE2000 = "CIEDE2000" @staticmethod def to_colour_method(method: str) -> str: """将内部方法标识符映射到colour库的标准方法字符串""" mapping = { "CIE76": "CIE 1976", "CIE94": "CIE 1994", "CIEDE2000": "CIE 2000" } return mapping.get(method, "CIE 2000") @dataclass class ColorData: """颜色数据容器""" L: np.ndarray a: np.ndarray b: np.ndarray categories: Optional[List[str]] = None metadata: Optional[Dict[str, Any]] = None @property def lab_array(self) -> np.ndarray: """返回LAB数组 (..., 3)""" return np.stack([self.L, self.a, self.b], axis=-1) @property def shape(self) -> tuple: """返回数据形状""" return self.L.shape @classmethod def from_array(cls, array: np.ndarray, categories: Optional[List[str]] = None) -> 'ColorData': """从数组创建ColorData对象""" if array.shape[-1] != 3: raise ValueError(f"数组的最后一个维度必须为3 (LAB), 但得到 {array.shape}") if array.ndim == 1: array = array.reshape(1, 3) return cls( L=array[..., 0], a=array[..., 1], b=array[..., 2], categories=categories ) class LabDataValidator: """LAB数据验证器""" @staticmethod def validate_lab_range(lab_data: Union[np.ndarray, ColorData], data_name: str = "LAB数据", warn_only: bool = True) -> bool: """ 验证LAB数据是否在合理范围内 参数: lab_data: LAB数据数组或ColorData对象 data_name: 数据名称（用于错误信息） warn_only: 是否仅警告而不抛出异常 返回: bool: 数据是否有效 """ if isinstance(lab_data, ColorData): L, a, b = lab_data.L, lab_data.a, lab_data.b else: L, a, b = lab_data[..., 0], lab_data[..., 1], lab_data[..., 2] L_min, L_max = np.nanmin(L), np.nanmax(L) a_min, a_max = np.nanmin(a), np.nanmax(a) b_min, b_max = np.nanmin(b), np.nanmax(b) issues = [] # 检查L*范围（理论[0, 100]，允许微小误差） if L_max > 100.5 or L_min < -0.5: issues.append(f"L*值超出理论范围[0, 100]，实际为[{L_min:.2f}, {L_max:.2f}]") # 检查a*, b*范围（常见[-128, 127]） if abs(a_max) > 150 or abs(a_min) > 150: issues.append(f"a*值超出常见范围[-128, 127]，实际为[{a_min:.2f}, {a_max:.2f}]") if abs(b_max) > 150 or abs(b_min) > 150: issues.append(f"b*值超出常见范围[-128, 127]，实际为[{b_min:.2f}, {b_max:.2f}]") # 检查NaN值 nan_count = np.sum(np.isnan(L)) + np.sum(np.isnan(a)) + np.sum(np.isnan(b)) if nan_count > 0: issues.append(f"发现{nan_count}个NaN值") if issues: message = f"{data_name}验证问题: " + "; ".join(issues) if warn_only: warnings.warn(message) return True # 即使有问题也继续处理 else: raise ValueError(message) return True @staticmethod def validate_data_shape(data1: np.ndarray, data2: np.ndarray, operation: str) -> bool: """验证两个数据数组的形状是否兼容""" # For color difference calculation, the last dimension must be 3 if data1.shape[-1] != 3 or data2.shape[-1] != 3: raise ValueError(f"{operation}: 两个数组的最后一个维度都必须为3 (LAB)") # 检查广播兼容性 try: np.broadcast_shapes(data1.shape[:-1], data2.shape[:-1]) return True except ValueError as e: raise ValueError(f"{operation}: 数组形状不兼容 - {str(e)}") class ColorStandardManager: """Standard color manager""" def __init__(self): self.standards = pd.DataFrame() self._color_cache = {} def load_from_csv(self, csv_path: Union[str, Path]) -> pd.DataFrame: """ Load standard colors from CSV file Parameters: csv_path: CSV file path Returns: Standard colors DataFrame """ print(f"Loading standard colors file: {csv_path}") try: df = pd.read_csv(csv_path) except Exception as e: raise IOError(f"无法读取CSV文件 {csv_path}: {str(e)}") # 验证数据列 if len(df.columns) < 4: raise ValueError(f"CSV文件必须至少有4列（类别, L, a, b），但只有 {len(df.columns)} 列") # 识别列 if 'category' not in df.columns: # 如果没有category列，设置默认列名 df.columns = ['category', 'L', 'a', 'b'] + list(df.columns[4:]) # 处理可能的列名变体 column_mapping = { 'l': 'L', 'l*': 'L', 'L*': 'L', 'a*': 'a', 'b*': 'b' } for old_col, new_col in column_mapping.items(): if old_col in df.columns and new_col not in df.columns: df.rename(columns={old_col: new_col}, inplace=True) print(f"将列 '{old_col}' 重命名为 '{new_col}'") # 确保必要的列存在 required_cols = ['category', 'L', 'a', 'b'] for col in required_cols: if col not in df.columns: raise ValueError(f"CSV文件缺少必需的列: {col}. 可用列: {list(df.columns)}") # 验证数据类型 for col in ['L', 'a', 'b']: if not pd.api.types.is_numeric_dtype(df[col]): try: df[col] = pd.to_numeric(df[col], errors='coerce') except: raise ValueError(f"列 {col} 包含非数值数据") # 删除NaN值 initial_count = len(df) df = df.dropna(subset=['L', 'a', 'b']) if len(df) < initial_count: print(f"警告: 删除了 {initial_count - len(df)} 行包含NaN值的记录") self.standards = df.reset_index(drop=True) print(f"Successfully loaded {len(self.standards)} standard colors") print(f"Standard color categories: {', '.join(df['category'].unique().astype(str))}") # Preview data if len(self.standards) > 0: print("Standard colors preview:") print(self.standards.head().to_string()) return self.standards def get_standard_colors(self, indices: Optional[List[int]] = None) -> ColorData: """ 获取指定索引的标准色 参数: indices: 标准色索引列表，None表示全部 返回: ColorData对象 """ if self.standards.empty: raise ValueError("尚未加载标准色数据") if indices is None: df = self.standards else: df = self.standards.iloc[indices] categories = df['category'].tolist() lab_array = df[['L', 'a', 'b']].values return ColorData.from_array(lab_array, categories) def get_standard_by_category(self, categories: List[str]) -> ColorData: """ 按类别获取标准色 参数: categories: 类别名称列表 返回: ColorData对象 """ if self.standards.empty: raise ValueError("尚未加载标准色数据") mask = self.standards['category'].isin(categories) df = self.standards[mask] if len(df) == 0: raise ValueError(f"未找到类别为 {categories} 的标准色") categories_list = df['category'].tolist() lab_array = df[['L', 'a', 'b']].values return ColorData.from_array(lab_array, categories_list) def save_to_csv(self, output_path: Union[str, Path]) -> None: """保存标准色到CSV文件""" if self.standards.empty: print("警告: 没有标准色数据可保存") return self.standards.to_csv(output_path, index=False) print(f"标准色已保存到: {output_path}") class DeltaECalculator: """ Delta E* Color Difference Calculator Supports calculating color differences in CIE LAB color space """ def __init__(self, method: Union[str, DeltaEMethod] = DeltaEMethod.CIEDE2000): """ Initialize color difference calculator Parameters: method: Color difference calculation method ('CIE76', 'CIE94', 'CIEDE2000') """ if not COLOUR_AVAILABLE: raise ImportError("需要安装colour-science库: pip install colour-science") # 处理方法参数 if isinstance(method, DeltaEMethod): self.method = method else: try: self.method = DeltaEMethod(method.upper()) except ValueError: raise ValueError(f"不支持的色差计算方法: {method}。可选: {[e.value for e in DeltaEMethod]}") print(f"初始化Delta E计算器 - 方法: {self.method.value}") def calculate(self, lab1: Union[np.ndarray, ColorData], lab2: Union[np.ndarray, ColorData]) -> np.ndarray: """ 计算两个LAB颜色或颜色集之间的Delta E 参数: lab1: 第一个LAB颜色或颜色集 lab2: 第二个LAB颜色或颜色集 返回: delta_e: Delta E值或值数组 """ # 提取数组 if isinstance(lab1, ColorData): arr1 = lab1.lab_array else: arr1 = lab1 if isinstance(lab2, ColorData): arr2 = lab2.lab_array else: arr2 = lab2 # 验证数据 LabDataValidator.validate_data_shape(arr1, arr2, "色差计算") # 转换为colour库的方法名称 colour_method = DeltaEMethod.to_colour_method(self.method.value) try: # 使用colour库的统一API result = delta_E(arr1, arr2, method=colour_method) return result except Exception as e: raise RuntimeError(f"色差计算失败（方法: {self.method.value}）: {str(e)}") def calculate_image_vs_standards(self, image_data: ColorData, standards: ColorData, use_progress_bar: bool = True) -> np.ndarray: """ 计算图像中每个像素与每个标准色的Delta E 参数: image_data: 图像颜色数据 standards: 标准色数据 use_progress_bar: 是否显示进度条 返回: delta_e_image: Delta E图像 (height, width, n_standards) """ print(f"开始计算图像色差...") print(f" 图像大小: {image_data.shape}") print(f" 标准色数量: {len(standards.categories) if standards.categories else standards.shape[0]}") # 重塑图像为 (pixels, 3) height, width = image_data.shape[:2] lab_pixels = image_data.lab_array.reshape(-1, 3) n_pixels = lab_pixels.shape[0] # 获取标准色数组 std_array = standards.lab_array n_standards = std_array.shape[0] # 准备结果数组 delta_e_result = np.zeros((n_pixels, n_standards), dtype=np.float32) # 计算进度条 if use_progress_bar and TQDM_AVAILABLE: iterator = tqdm(range(n_standards), desc="计算标准色", unit="色") else: iterator = range(n_standards) print(f"处理 0/{n_standards} 个标准色", end="") # 对每个标准色计算Delta E for i in iterator: # 广播计算所有像素与这个标准色的Delta E delta_e_result[:, i] = self.calculate(lab_pixels, std_array[i]) if not TQDM_AVAILABLE and not use_progress_bar: if (i + 1) % max(1, n_standards // 10) == 0 or i + 1 == n_standards: print(f"\r处理 {i + 1}/{n_standards} 个标准色", end="") if not TQDM_AVAILABLE and not use_progress_bar: print() # 换行 # 重塑回图像格式 (height, width, n_standards) delta_e_image = delta_e_result.reshape(height, width, n_standards) # 输出统计信息 print(f"色差计算完成!") print(f" ΔE范围: [{delta_e_result.min():.3f}, {delta_e_result.max():.3f}]") print(f" ΔE均值: {delta_e_result.mean():.3f} ± {delta_e_result.std():.3f}") # 添加色差解读 self._interpret_delta_e(delta_e_result.mean()) return delta_e_image def calculate_pairwise(self, colors1: ColorData, colors2: Optional[ColorData] = None) -> pd.DataFrame: """ 计算两组颜色之间的两两Delta E 参数: colors1: 第一组颜色数据 colors2: 第二组颜色数据，如果为None则计算colors1内部的两两比较 返回: 包含Delta E结果的DataFrame """ if colors2 is None: colors2 = colors1 print(f"计算内部两两Delta E - 颜色数量: {colors1.shape[0]}") else: print(f"计算两组颜色间Delta E - 组1: {colors1.shape[0]}, 组2: {colors2.shape[0]}") results = [] # 获取类别信息 cats1 = colors1.categories if colors1.categories else [f"Color_{i}" for i in range(colors1.shape[0])] cats2 = colors2.categories if colors2.categories else [f"Color_{i}" for i in range(colors2.shape[0])] # 获取LAB数组 lab1 = colors1.lab_array lab2 = colors2.lab_array # 计算所有组合 for i in range(lab1.shape[0]): for j in range(lab2.shape[0]): # 如果是内部比较且i>=j，跳过以避免重复（对角线保留） if colors2 is colors1 and i > j: continue delta_e_value = self.calculate(lab1[i], lab2[j]) results.append({ 'reference_index': i, 'reference_category': cats1[i], 'reference_L': lab1[i, 0], 'reference_a': lab1[i, 1], 'reference_b': lab1[i, 2], 'target_index': j, 'target_category': cats2[j], 'target_L': lab2[j, 0], 'target_a': lab2[j, 1], 'target_b': lab2[j, 2], 'delta_E': delta_e_value, 'method': self.method.value }) result_df = pd.DataFrame(results) print(f"两两Delta E计算完成，共 {len(result_df)} 对颜色组合") return result_df def _interpret_delta_e(self, mean_delta_e: float) -> None: """根据ΔE平均值提供解读""" print(f" ΔE结果解读 ({self.method.value}):") if self.method == DeltaEMethod.CIEDE2000: if mean_delta_e < 0.5: print(" ΔE<0.5 - 差异极微小，通常不可感知") elif mean_delta_e < 1.0: print(" ΔE<1.0 - 微小差异，经验丰富的观察者可能感知") elif mean_delta_e < 2.0: print(" ΔE<2.0 - 可感知的微小差异") elif mean_delta_e < 3.5: print(" ΔE<3.5 - 中等差异，明显可感知") elif mean_delta_e < 5.0: print(" ΔE<5.0 - 较大差异") else: print(" ΔE≥5.0 - 非常大差异，可能被认为是不同颜色") else: # 对于CIE76和CIE94的通用解读 if mean_delta_e < 1.0: print(" ΔE<1.0 - 差异通常不可感知") elif mean_delta_e < 2.3: print(" ΔE<2.3 - 微小差异（近距离观察可感知）") elif mean_delta_e < 4.0: print(" ΔE<4.0 - 可感知的差异") elif mean_delta_e < 6.0: print(" ΔE<6.0 - 明显差异") else: print(" ΔE≥6.0 - 非常大差异") class EnviFileHandler: """ENVI文件处理器""" def __init__(self): if not SPECTRAL_AVAILABLE: raise ImportError("需要安装spectral库才能处理ENVI格式文件") def load_image(self, image_path: Union[str, Path]) -> Tuple[ColorData, Dict[str, Any]]: """ 使用spectral库加载ENVI格式的高光谱/LAB图像 参数: image_path: 图像文件路径 支持格式: .hdr (头文件), .dat/.bip/.bsq/.bil (数据文件) spectral库会自动找到对应的文件 返回: image_data: ColorData对象，包含L, a, b数据 metadata: ENVI文件的元数据字典 """ image_path = Path(image_path) print(f"正在加载ENVI图像: {image_path}") try: # 使用spectral库打开图像，自动处理各种格式 # spectral.open_image 可以接受: # - 数据文件路径 (.dat, .bip, .bsq, .bil) # - HDR文件路径 (.hdr) # - 甚至basename（会自动查找对应的文件） img = spectral.open_image(str(image_path)) print(f"图像形状: {img.shape}") print(f"数据类型: {img.dtype}") print(f"波段数: {img.shape[2] if len(img.shape) > 2 else 1}") except Exception as e: # 提供详细的错误信息和建议 error_msg = f"无法打开ENVI图像 {image_path}: {str(e)}" # 检查文件是否存在 if not image_path.exists(): error_msg += f"\n文件不存在: {image_path}" # 建议可能的替代文件 parent_dir = image_path.parent if parent_dir.exists(): # 查找可能的ENVI文件 envi_files = [] for ext in ['*.hdr', '*.dat', '*.bip', '*.bsq', '*.bil']: envi_files.extend(list(parent_dir.glob(ext))) if envi_files: error_msg += f"\n\n目录中的ENVI文件:" for f in envi_files[:10]: # 最多显示10个 error_msg += f"\n {f.name}" else: error_msg += f"\n\n目录中没有找到ENVI文件" error_msg += f"\n\n使用建议:" error_msg += f"\n1. 确保文件路径正确" error_msg += f"\n2. 尝试使用数据文件 (.bip, .dat) 而不是头文件 (.hdr)" error_msg += f"\n3. 或使用不带扩展名的basename，让spectral自动查找" raise IOError(error_msg) # 检查波段数 if img.shape[2] != 3: raise ValueError(f"LAB图像必须有3个波段，当前波段数: {img.shape[2]}") # 加载数据 image_array = img.load().astype(np.float32) print(f"图像形状: {image_array.shape}") print(f"数据类型: {image_array.dtype}") # 创建ColorData对象 image_data = ColorData( L=image_array[..., 0], a=image_array[..., 1], b=image_array[..., 2] ) # 检查数据范围 self._print_lab_range(image_data, "图像") # 提取元数据 metadata = {} if hasattr(img, 'metadata') and img.metadata: metadata = dict(img.metadata) return image_data, metadata def save_color_data(self, color_data: np.ndarray, output_path: Union[str, Path], output_format: str = 'csv', input_hdr_path: Optional[Union[str, Path]] = None, method: str = 'DeltaE'): """ 保存颜色数据到文件 参数: color_data: 颜色数据数组 output_path: 输出文件路径 output_format: 输出格式 ('csv' 或 'dat') input_hdr_path: 输入ENVI文件的HDR路径，用于复制元数据 method: 方法名称，用于波段命名 """ output_path = Path(output_path) print(f"保存{method}数据到: {output_path}, 格式: {output_format}") # 根据颜色空间确定列名（这里是Delta E，所以使用通用命名） if len(color_data.shape) >= 3 and color_data.shape[-1] <= 10: # 如果是多波段数据，假设是Delta E结果 n_bands = color_data.shape[-1] if len(color_data.shape) == 3 else 1 column_names = [f'DeltaE_{i+1}' for i in range(n_bands)] else: column_names = [f'Band_{i+1}' for i in range(color_data.shape[-1])] if output_format == 'csv': # 保存为CSV格式 if len(color_data.shape) == 3: # 图像数据 (height, width, channels) # 为图像数据创建CSV，每行是一个像素的颜色值 color_flat = color_data.reshape(-1, color_data.shape[-1]) df = pd.DataFrame(color_flat, columns=column_names) df.to_csv(output_path, index=False) print(f"保存为CSV: {color_flat.shape[0]} 行数据") else: # 一维数据 (samples, channels) df = pd.DataFrame(color_data, columns=column_names) df.to_csv(output_path, index=False) print(f"保存为CSV: {color_data.shape[0]} 行数据") elif output_format == 'dat': # 保存为ENVI格式的.dat文件，参考classification.py的方式 try: from osgeo import gdal GDAL_AVAILABLE = True except ImportError: GDAL_AVAILABLE = False # 为ENVI格式创建必要的元数据 if len(color_data.shape) == 3: # 图像数据 (height, width, channels) height, width, channels = color_data.shape # 确保目录存在 output_path.parent.mkdir(parents=True, exist_ok=True) print(f"保存ENVI文件 - {method}形状: {color_data.shape}") if GDAL_AVAILABLE and channels <= 4: # 支持最多4个通道 # 使用GDAL保存，参考classification.py的方式 driver = gdal.GetDriverByName('ENVI') # 创建多波段ENVI文件 out_dataset = driver.Create( str(output_path), width, height, channels, gdal.GDT_Float32, options=['INTERLEAVE=BIL'] ) if out_dataset is None: raise ValueError(f"无法创建输出文件: {output_path}") # 写入每个波段的数据 for band_idx in range(channels): band_data = color_data[:, :, band_idx] # (height, width) out_band = out_dataset.GetRasterBand(band_idx + 1) out_band.WriteArray(band_data.astype(np.float32)) # 设置波段名称 out_band.SetDescription(column_names[band_idx]) # 设置地理信息 (如果有的话，这里没有地理信息) # out_dataset.SetGeoTransform(geotransform) # out_dataset.SetProjection(projection) out_dataset.FlushCache() out_dataset = None # 创建HDR文件，保持输入文件的元数据 self._create_envi_hdr_file(output_path, height, width, channels, 'float32', input_hdr_path, method) print(f"使用GDAL保存为ENVI文件: {output_path}") print(f"数据类型: float32, 波段数: {channels}, 大小: {width}x{height}") else: # GDAL不可用时，直接保存为二进制文件 print("GDAL不可用，使用numpy直接保存二进制数据") # 确保目录存在 output_path.parent.mkdir(parents=True, exist_ok=True) # 重新排列数据为BIL格式 (channels, height, width) 并保存 color_bil = np.transpose(color_data, (2, 0, 1)) # (channels, height, width) color_bil.astype(np.float32).tofile(str(output_path)) # 创建HDR文件 self._create_envi_hdr_file(output_path, height, width, channels, 'float32', input_hdr_path, method) print(f"使用numpy保存为ENVI格式二进制文件: {output_path}") print(f"数据类型: float32, 波段数: {channels}, 大小: {width}x{height}") else: # 一维数据 (samples, channels) # 一维数据保存为CSV csv_path = output_path.with_suffix('.csv') np.savetxt(csv_path, color_data, delimiter=',', header=','.join(column_names), comments='') print(f"一维数据保存为CSV: {csv_path}") else: raise ValueError(f"不支持的输出格式: {output_format}") print(f"结果已保存到: {output_path}") def _create_envi_hdr_file(self, bil_path: Union[str, Path], height: int, width: int, bands: int, data_type: str, input_hdr_path: Optional[Union[str, Path]] = None, method: str = 'DeltaE') -> None: """ 创建ENVI头文件，参考classification.py的方式，并保持输入文件的元数据 Args: bil_path: BIL文件路径 height: 图像高度 width: 图像宽度 bands: 波段数 data_type: 数据类型 ('float32', 'uint8', 'int16', 等) input_hdr_path: 输入ENVI文件的HDR路径，用于复制元数据 method: 方法名称，用于描述 """ hdr_path = Path(bil_path).with_suffix('.hdr') # 数据类型映射 (ENVI格式) dtype_map = { 'uint8': '1', 'int16': '2', 'int32': '3', 'float32': '4', 'float64': '5', 'complex64': '6', 'complex128': '9', 'uint16': '12', 'uint32': '13', 'int64': '14', 'uint64': '15' } envi_dtype = dtype_map.get(data_type, '4') # 默认为float32 # 为Delta E数据确定波段名称 band_names = [f"DeltaE_Band_{i+1}" for i in range(bands)] with open(hdr_path, 'w') as f: f.write("ENVI\n") f.write("description = {\n") f.write(f" Delta E Color Difference Data - Generated by DeltaECalculator\n") f.write(f" Method: {method}\n") f.write("}\n") f.write(f"samples = {width}\n") f.write(f"lines = {height}\n") f.write(f"bands = {bands}\n") f.write("header offset = 0\n") f.write("file type = ENVI Standard\n") f.write(f"data type = {envi_dtype}\n") f.write("interleave = bil\n") f.write("sensor type = Unknown\n") f.write("byte order = 0\n") # 波段名称 f.write("band names = {\n") for i, name in enumerate(band_names): f.write(f' "{name}"') if i < len(band_names) - 1: f.write(",") f.write("\n") f.write("}\n") # 如果有输入HDR文件，尝试复制相关的元数据 if input_hdr_path and Path(input_hdr_path).exists(): try: self._copy_hdr_metadata(input_hdr_path, f) except Exception as e: print(f"复制HDR元数据失败: {e}") print(f"ENVI头文件创建完成: {hdr_path}") def _copy_hdr_metadata(self, input_hdr_path: Union[str, Path], output_file) -> None: """ 从输入HDR文件复制元数据到输出HDR文件 Args: input_hdr_path: 输入HDR文件路径 output_file: 输出文件对象 """ try: with open(input_hdr_path, 'r', encoding='utf-8', errors='ignore') as f: content = f.read() # 解析输入HDR文件，提取有用的元数据 lines = content.split('\n') metadata_to_copy = [] # 需要复制的元数据字段 fields_to_copy = [ 'wavelength units', 'wavelength', 'fwhm', 'bbl', 'map info', 'coordinate system string', 'projection info', 'pixel size', 'acquisition time', 'sensor type', 'radiance scale factor', 'reflectance scale factor', 'data gain values', 'data offset values' ] i = 0 while i < len(lines): line = lines[i].strip() if '=' in line: key = line.split('=')[0].strip().lower() if any(field in key for field in fields_to_copy): # 复制这个字段及其可能的后续行 metadata_to_copy.append(lines[i]) i += 1 # 如果是多行值，继续读取 while i < len(lines) and not ('=' in lines[i] and not lines[i].strip().endswith(',')): if lines[i].strip(): metadata_to_copy.append(lines[i]) i += 1 if i >= len(lines): break continue i += 1 # 将复制的元数据写入输出文件 if metadata_to_copy: output_file.write("\n") for line in metadata_to_copy: if line.strip(): output_file.write(line + "\n") print(f"已从输入HDR文件复制 {len(metadata_to_copy)} 行元数据") except Exception as e: print(f"读取输入HDR文件失败: {e}") def save_delta_e_image(self, delta_e_image: np.ndarray, output_path: Union[str, Path], standard_categories: List[str], method: str, metadata: Optional[Dict[str, Any]] = None) -> None: """ 保存Delta E结果为ENVI格式（兼容性方法） 参数: delta_e_image: Delta E图像 (height, width, n_standards) output_path: 输出路径 standard_categories: 标准色类别列表 method: 色差计算方法 metadata: 可选的元数据 """ # 根据标准色类别确定列名 column_names = [] for i, cat in enumerate(standard_categories): column_names.append(f'DeltaE_{cat}_{method}') # 转换数据格式以匹配save_color_data的期望 # delta_e_image 是 (height, width, n_standards)，需要转换为 (height, width, channels) color_data = delta_e_image # 调用统一的保存方法 self.save_color_data(color_data, output_path, 'dat', None, method) def _print_lab_range(self, color_data: ColorData, data_name: str) -> None: """打印LAB值范围""" L_min, L_max = color_data.L.min(), color_data.L.max() a_min, a_max = color_data.a.min(), color_data.a.max() b_min, b_max = color_data.b.min(), color_data.b.max() print(f"{data_name}LAB值范围:") print(f" L: [{L_min:.2f}, {L_max:.2f}]") print(f" a: [{a_min:.2f}, {a_max:.2f}]") print(f" b: [{b_min:.2f}, {b_max:.2f}]") class DeltaEVisualizer: """Delta E可视化器""" def __init__(self, colormap: str = 'RdYlBu_r'): if not MATPLOTLIB_AVAILABLE: raise ImportError("需要安装matplotlib库才能生成可视化") self.colormap = colormap plt.style.use('default') def create_heatmap(self, delta_e_image: np.ndarray, standard_categories: List[str], output_path: Union[str, Path], title: str = "Delta E Heatmap", dpi: int = 150) -> None: """ Create Delta E heatmap Parameters: delta_e_image: Delta E图像 (height, width, n_standards) standard_categories: 标准色类别列表 output_path: 输出路径 title: 图表标题 dpi: 图像分辨率 """ print(f"Generating heatmap: {output_path}") n_standards = delta_e_image.shape[2] # 计算子图布局 if n_standards <= 4: nrows, ncols = 1, n_standards figsize = (5 * ncols, 5) elif n_standards <= 9: nrows = 2 ncols = (n_standards + 1) // 2 figsize = (5 * ncols, 4 * nrows) else: nrows = int(np.ceil(np.sqrt(n_standards))) ncols = int(np.ceil(n_standards / nrows)) figsize = (5 * ncols, 4 * nrows) fig, axes = plt.subplots(nrows, ncols, figsize=figsize) # 如果只有一个子图，确保axes是数组 if n_standards == 1: axes = np.array([axes]) # 扁平化axes数组以便迭代 if axes.ndim > 1: axes_flat = axes.flatten() else: axes_flat = axes # 计算全局的最小值和最大值，用于统一颜色条范围 global_min = np.nanmin(delta_e_image) global_max = np.nanmax(delta_e_image) # 为每个标准色创建热图 for i in range(len(axes_flat)): ax = axes_flat[i] if i < n_standards: # 提取当前标准色的Delta E数据 de_data = delta_e_image[:, :, i] # 计算统计数据 mean_de = np.nanmean(de_data) std_de = np.nanstd(de_data) # 显示热图 im = ax.imshow(de_data, cmap=self.colormap, vmin=global_min, vmax=global_max, aspect='auto') # 设置标题 if i < len(standard_categories): category = standard_categories[i] else: category = f"Standard_{i}" ax.set_title(f"{category}\nΔE={mean_de:.2f}±{std_de:.2f}", fontsize=10) ax.axis('off') # 添加颜色条 plt.colorbar(im, ax=ax, shrink=0.8, pad=0.02) else: # 隐藏多余的子图 ax.axis('off') # Add main title plt.suptitle(title, fontsize=14, y=1.02) # Adjust layout plt.tight_layout() # Save image output_path = Path(output_path) output_path.parent.mkdir(parents=True, exist_ok=True) plt.savefig(output_path, dpi=dpi, bbox_inches='tight') plt.close() print(f"Heatmap saved: {output_path}") def create_delta_e_histogram(self, delta_e_values: np.ndarray, output_path: Union[str, Path], title: str = "Delta E Distribution Histogram", bins: int = 30) -> None: """ Create Delta E distribution histogram Parameters: delta_e_values: Delta E值数组 output_path: 输出路径 title: 图表标题 bins: 直方图箱数 """ fig, ax = plt.subplots(figsize=(10, 6)) # 绘制直方图 n, bins, patches = ax.hist(delta_e_values.flatten(), bins=bins, edgecolor='black', alpha=0.7) # 添加统计信息 mean_val = np.mean(delta_e_values) std_val = np.std(delta_e_values) median_val = np.median(delta_e_values) # Add vertical lines marking statistics ax.axvline(mean_val, color='red', linestyle='--', linewidth=2, label=f'Mean: {mean_val:.2f}') ax.axvline(median_val, color='green', linestyle='--', linewidth=2, label=f'Median: {median_val:.2f}') # Set title and labels ax.set_title(title, fontsize=14) ax.set_xlabel('Delta E', fontsize=12) ax.set_ylabel('Frequency', fontsize=12) ax.legend() ax.grid(True, alpha=0.3) # Add statistical information text box textstr = '\n'.join([ f'Data points: {delta_e_values.size:,}', f'Minimum: {delta_e_values.min():.2f}', f'Maximum: {delta_e_values.max():.2f}', f'Mean: {mean_val:.2f}', f'Standard deviation: {std_val:.2f}', f'Median: {median_val:.2f}' ]) props = dict(boxstyle='round', facecolor='wheat', alpha=0.5) ax.text(0.05, 0.95, textstr, transform=ax.transAxes, fontsize=10, verticalalignment='top', bbox=props) # 保存图像 output_path = Path(output_path) output_path.parent.mkdir(parents=True, exist_ok=True) plt.savefig(output_path, dpi=150, bbox_inches='tight') plt.close() print(f"直方图已保存: {output_path}") class DeltaEApp: """主应用程序类""" def __init__(self): self.calculator = None self.standard_manager = ColorStandardManager() self.envi_handler = None if not SPECTRAL_AVAILABLE else EnviFileHandler() self.visualizer = None if not MATPLOTLIB_AVAILABLE else DeltaEVisualizer() def run(self, args): """Run application""" print("=" * 60) print("Delta E* Color Difference Calculation Tool - Starting") print("=" * 60) # Initialize calculator self.calculator = DeltaECalculator(method=args.method) if args.mode == 'image': self._run_image_mode(args) elif args.mode == 'pairwise': self._run_pairwise_mode(args) else: raise ValueError(f"Unknown mode: {args.mode}") print("=" * 60) print("Processing completed!") print("=" * 60) def _run_image_mode(self, args): """运行图像模式""" # 根据输入文件类型加载数据 input_path = Path(args.input) if input_path.suffix.lower() == '.csv': # CSV 文件输入 print(f"从CSV文件加载LAB数据: {input_path}") import pandas as pd df = pd.read_csv(input_path) print(f"CSV文件列名: {list(df.columns)}") # 查找LAB列（支持多种命名方式） lab_columns = {} for col in df.columns: col_lower = col.lower() if col_lower in ['l', 'l*', 'l_star'] or col_lower.startswith('l '): lab_columns['L'] = col elif col_lower in ['a', 'a*', 'a_star'] or col_lower.startswith('a '): lab_columns['a'] = col elif col_lower in ['b', 'b*', 'b_star'] or col_lower.startswith('b '): lab_columns['b'] = col if len(lab_columns) < 3: raise ValueError(f"CSV文件必须包含L、a、b列。找到的列: {list(lab_columns.keys())}") # 提取LAB数据 L = df[lab_columns['L']].values a = df[lab_columns['a']].values b = df[lab_columns['b']].values # 创建ColorData对象 image_data = ColorData(L=L, a=a, b=b) metadata = {} print(f"从CSV加载了 {len(L)} 个LAB样本") else: # ENVI 文件输入 if not SPECTRAL_AVAILABLE: raise ImportError("ENVI文件输入需要spectral库，但未安装") image_data, metadata = self.envi_handler.load_image(str(input_path)) # 加载标准色 standards_df = self.standard_manager.load_from_csv(args.standards) # 验证数据 LabDataValidator.validate_lab_range(image_data, "输入图像", warn_only=True) # 解析标准色范围 standard_indices = self._parse_range_param(args.standards_range, len(standards_df)) standard_colors = self.standard_manager.get_standard_colors(standard_indices) # 计算Delta E delta_e_image = self.calculator.calculate_image_vs_standards( image_data, standard_colors, use_progress_bar=not args.no_progress ) # 准备标准色类别列表 if standard_colors.categories: standard_categories = standard_colors.categories else: standard_categories = [f"Standard_{i}" for i in range(len(standard_indices))] # 保存结果 output_dir = Path(args.output_dir) output_dir.mkdir(parents=True, exist_ok=True) # 生成输出文件名 if hasattr(args, 'output_file') and args.output_file: # 如果指定了输出文件名 if Path(args.output_file).is_absolute(): output_path = Path(args.output_file) else: output_path = output_dir / args.output_file else: # 使用默认文件名 input_name = Path(args.input).stem output_filename = f"{input_name}_delta_e_{args.method.lower()}.dat" output_path = output_dir / output_filename # 保存ENVI图像 self.envi_handler.save_delta_e_image( delta_e_image, output_path, standard_categories, args.method, metadata ) # 保存CSV摘要 self._save_image_summary_csv(delta_e_image, standard_categories, output_path) # 生成可视化 if args.create_heatmap and self.visualizer: heatmap_path = output_path.with_suffix('.png') self.visualizer.create_heatmap( delta_e_image, standard_categories, heatmap_path, title=f"Delta E ({args.method}) 热图" ) if args.create_histogram and self.visualizer: histogram_path = output_path.with_name(f"{output_path.stem}_histogram.png") self.visualizer.create_delta_e_histogram( delta_e_image, histogram_path, title=f"Delta E ({args.method}) 分布" ) def _run_pairwise_mode(self, args): """运行两两比较模式""" # 加载标准色 standards_df = self.standard_manager.load_from_csv(args.standards) # 解析范围参数 all_indices = list(range(len(standards_df))) if args.reference_range and args.target_range: ref_indices = self._parse_range_param(args.reference_range, len(standards_df)) tgt_indices = self._parse_range_param(args.target_range, len(standards_df)) ref_colors = self.standard_manager.get_standard_colors(ref_indices) tgt_colors = self.standard_manager.get_standard_colors(tgt_indices) # 计算两组之间的Delta E result_df = self.calculator.calculate_pairwise(ref_colors, tgt_colors) else: # 计算所有标准色内部的两两Delta E all_colors = self.standard_manager.get_standard_colors(all_indices) result_df = self.calculator.calculate_pairwise(all_colors) # 保存结果 output_dir = Path(args.output_dir) output_dir.mkdir(parents=True, exist_ok=True) # 生成输出文件名 if hasattr(args, 'output_file') and args.output_file: # 如果指定了输出文件名 if Path(args.output_file).is_absolute(): output_path = Path(args.output_file) else: output_path = output_dir / args.output_file else: # 使用默认文件名 output_filename = f"delta_e_pairwise_{args.method.lower()}.csv" output_path = output_dir / output_filename result_df.to_csv(output_path, index=False) print(f"两两比较结果已保存到: {output_path}") # 生成矩阵热图（如果颜色数量合理） if self.visualizer and len(standards_df) <= 20 and args.create_heatmap: self._create_pairwise_heatmap(result_df, output_path) def _parse_range_param(self, range_str: Optional[str], max_index: int) -> List[int]: """解析范围参数""" if not range_str or range_str.lower() == 'all': return list(range(max_index)) indices = [] parts = range_str.split(',') for part in parts: part = part.strip() if '-' in part: # 处理范围 try: start, end = map(int, part.split('-')) if start < 0 or end >= max_index or start > end: raise ValueError(f"范围 {part} 超出有效范围 [0, {max_index-1}]") indices.extend(range(start, end + 1)) except ValueError as e: raise ValueError(f"无效的范围格式: {part}。错误: {str(e)}") else: # 处理单个索引 try: idx = int(part) if idx < 0 or idx >= max_index: raise ValueError(f"索引 {idx} 超出有效范围 [0, {max_index-1}]") indices.append(idx) except ValueError: raise ValueError(f"无效的索引: {part}") # 去重并排序 indices = sorted(set(indices)) if not indices: raise ValueError("未指定有效的索引") return indices def _save_image_summary_csv(self, delta_e_image: np.ndarray, standard_categories: List[str], output_path: Path) -> None: """保存图像结果的统计摘要""" summary_data = [] for i, category in enumerate(standard_categories): de_data = delta_e_image[:, :, i] de_flat = de_data.flatten() summary_data.append({ 'category': category, 'min': np.nanmin(de_flat), 'max': np.nanmax(de_flat), 'mean': np.nanmean(de_flat), 'median': np.nanmedian(de_flat), 'std': np.nanstd(de_flat), 'q25': np.nanpercentile(de_flat, 25), 'q75': np.nanpercentile(de_flat, 75), 'pixels': np.sum(~np.isnan(de_flat)) }) summary_df = pd.DataFrame(summary_data) summary_path = output_path.with_name(f"{output_path.stem}_summary.csv") summary_df.to_csv(summary_path, index=False, float_format='%.4f') print(f"Statistical summary saved to: {summary_path}") def _create_pairwise_heatmap(self, result_df: pd.DataFrame, output_path: Path) -> None: """Create heatmap for pairwise comparison results""" try: # 提取唯一的类别 ref_categories = result_df['reference_category'].unique() tgt_categories = result_df['target_category'].unique() # 创建矩阵 matrix = np.zeros((len(ref_categories), len(tgt_categories))) # 填充矩阵 cat_to_idx = {cat: i for i, cat in enumerate(ref_categories)} for _, row in result_df.iterrows(): i = cat_to_idx[row['reference_category']] j = np.where(tgt_categories == row['target_category'])[0][0] matrix[i, j] = row['delta_E'] # 创建热图 fig, ax = plt.subplots(figsize=(10, 8)) im = ax.imshow(matrix, cmap='RdYlBu_r') # 设置刻度 ax.set_xticks(np.arange(len(tgt_categories))) ax.set_yticks(np.arange(len(ref_categories))) ax.set_xticklabels(tgt_categories, rotation=45, ha='right') ax.set_yticklabels(ref_categories) # 添加颜色条 plt.colorbar(im, ax=ax, label='Delta E') # Add numerical labels for i in range(len(ref_categories)): for j in range(len(tgt_categories)): text = ax.text(j, i, f'{matrix[i, j]:.2f}', ha="center", va="center", color="black", fontsize=8) ax.set_title("Pairwise Delta E Comparison Matrix") plt.tight_layout() # Save heatmap heatmap_path = output_path.with_suffix('.png') plt.savefig(heatmap_path, dpi=150, bbox_inches='tight') plt.close() print(f"Pairwise comparison heatmap saved: {heatmap_path}") except Exception as e: print(f"Error generating pairwise comparison heatmap: {str(e)}") def parse_arguments(): """Parse command line arguments""" parser = argparse.ArgumentParser( description='Delta E* 色差计算工具 - 完整版', formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" 使用示例: 1. Calculate color differences between image and standard colors: python delta_e_tool.py --mode image --image input.lab --standards colors.csv --output result.dat 2. Calculate color differences for specified standard color range: python delta_e_tool.py --mode image --image input.lab --standards colors.csv --standards-range "0,1,2,5-10" --output result.dat --method CIE94 3. Generate heatmap and histogram: python delta_e_tool.py --mode image --image input.lab --standards colors.csv --output result.dat --create-heatmap --create-histogram 4. Calculate pairwise color differences between standard colors: python delta_e_tool.py --mode pairwise --standards colors.csv --output pairwise.csv 5. Calculate color differences between two groups of standard colors: python delta_e_tool.py --mode pairwise --standards colors.csv --reference-range "0-5" --target-range "6-10" --output pairwise.csv """ ) # 基本参数 parser.add_argument('--mode', required=True, choices=['image', 'pairwise'], help='Calculation mode: image (image vs standard colors) or pairwise (pairwise comparison)') # Input parameters parser.add_argument('--input', required=True, help='Input file path (ENVI format LAB image or CSV file)') parser.add_argument('--standards', required=True, help='Standard colors CSV file path') # Output parameters parser.add_argument('--output-dir', default='./results', help='Output directory path') parser.add_argument('--create-heatmap', action='store_true', help='Generate heatmap') parser.add_argument('--create-histogram', action='store_true', help='Generate histogram') # Calculation parameters parser.add_argument('--method', default='CIEDE2000', choices=['CIE76', 'CIE94', 'CIEDE2000'], help='Color difference calculation method (default: CIEDE2000)') # Range selection parameters parser.add_argument('--standards-range', help='Standard color range (e.g.: "0,1,2" or "0-5" or "all")') parser.add_argument('--reference-range', help='Reference color range (pairwise mode)') parser.add_argument('--target-range', help='Target color range (pairwise mode)') # Other parameters parser.add_argument('--no-progress', action='store_true', help='Disable progress bar display') return parser.parse_args() # ============================================================================= # 直接函数调用接口 # ============================================================================= def calculate_delta_e_image(image_path: Union[str, Path], standards_path: Union[str, Path], output_path: Union[str, Path], method: str = 'CIEDE2000', standards_range: Optional[str] = None, create_heatmap: bool = False, create_histogram: bool = False, no_progress: bool = False) -> np.ndarray: """ Directly calculate Delta E color differences between image and standard colors Parameters: image_path: LAB图像文件路径 (ENVI格式) standards_path: 标准色CSV文件路径 output_path: 输出文件路径 method: 色差计算方法 ('CIE76', 'CIE94', 'CIEDE2000') standards_range: 标准色范围 ("0,1,2" 或 "0-5" 或 "all") create_heatmap: 是否生成热图 create_histogram: 是否生成直方图 no_progress: 是否禁用进度条 返回: delta_e_image: Delta E图像数组 (height, width, n_standards) 示例: >>> delta_e = calculate_delta_e_image( ... image_path="input.lab", ... standards_path="standards.csv", ... output_path="result.dat", ... method="CIEDE2000", ... create_heatmap=True ... ) """ # 验证依赖 if not SPECTRAL_AVAILABLE: raise ImportError("需要安装spectral库: pip install spectral") if not COLOUR_AVAILABLE: raise ImportError("需要安装colour-science库: pip install colour-science") # 创建应用实例 app = DeltaEApp() try: # 初始化计算器 app.calculator = DeltaECalculator(method=method) # 加载图像 image_data, metadata = app.envi_handler.load_image(image_path) # 加载标准色 standards_df = app.standard_manager.load_from_csv(standards_path) # 验证数据 LabDataValidator.validate_lab_range(image_data, "输入图像", warn_only=True) # 解析标准色范围 standard_indices = app._parse_range_param(standards_range, len(standards_df)) standard_colors = app.standard_manager.get_standard_colors(standard_indices) # 计算Delta E delta_e_image = app.calculator.calculate_image_vs_standards( image_data, standard_colors, use_progress_bar=not no_progress ) # 保存结果 app.envi_handler.save_delta_e_image( delta_e_image, output_path, standard_colors.categories or [f"Standard_{i}" for i in range(len(standard_indices))], method, metadata ) # 生成可视化 if create_heatmap and app.visualizer: heatmap_path = Path(output_path).with_suffix('.png') app.visualizer.create_heatmap( delta_e_image, standard_colors.categories or [f"Standard_{i}" for i in range(len(standard_indices))], heatmap_path, title=f"Delta E ({method}) 热图" ) if create_histogram and app.visualizer: histogram_path = Path(output_path).with_name(f"{Path(output_path).stem}_histogram.png") app.visualizer.create_delta_e_histogram( delta_e_image, histogram_path, title=f"Delta E ({method}) 分布" ) print(f"色差计算完成! 结果已保存到: {output_path}") return delta_e_image except Exception as e: print(f"计算失败: {str(e)}") raise def calculate_delta_e_pairwise(standards_path: Union[str, Path], output_path: Union[str, Path], method: str = 'CIEDE2000', reference_range: Optional[str] = None, target_range: Optional[str] = None, create_heatmap: bool = False) -> pd.DataFrame: """ 直接计算标准色之间的两两Delta E 参数: standards_path: 标准色CSV文件路径 output_path: 输出CSV文件路径 method: 色差计算方法 ('CIE76', 'CIE94', 'CIEDE2000') reference_range: 参考色范围 ("0,1,2" 或 "0-5" 或 "all") target_range: 目标色范围 ("0,1,2" 或 "0-5" 或 "all") create_heatmap: 是否生成热图 返回: result_df: 包含Delta E结果的DataFrame 示例: >>> df = calculate_delta_e_pairwise( ... standards_path="standards.csv", ... output_path="pairwise.csv", ... method="CIEDE2000" ... ) """ if not COLOUR_AVAILABLE: raise ImportError("需要安装colour-science库: pip install colour-science") # 创建应用实例 app = DeltaEApp() try: # 初始化计算器 app.calculator = DeltaECalculator(method=method) # 加载标准色 standards_df = app.standard_manager.load_from_csv(standards_path) # 解析范围参数 all_indices = list(range(len(standards_df))) if reference_range and target_range: ref_indices = app._parse_range_param(reference_range, len(standards_df)) tgt_indices = app._parse_range_param(target_range, len(standards_df)) ref_colors = app.standard_manager.get_standard_colors(ref_indices) tgt_colors = app.standard_manager.get_standard_colors(tgt_indices) # 计算两组之间的Delta E result_df = app.calculator.calculate_pairwise(ref_colors, tgt_colors) else: # 计算所有标准色内部的两两Delta E all_colors = app.standard_manager.get_standard_colors(all_indices) result_df = app.calculator.calculate_pairwise(all_colors) # 保存结果 result_df.to_csv(output_path, index=False) print(f"两两比较结果已保存到: {output_path}") # 生成热图（如果颜色数量合理且启用） if create_heatmap and app.visualizer and len(standards_df) <= 20: app._create_pairwise_heatmap(result_df, Path(output_path)) return result_df except Exception as e: print(f"计算失败: {str(e)}") raise def calculate_delta_e_from_arrays(lab_array: np.ndarray, standard_lab: np.ndarray, method: str = 'CIEDE2000', standard_categories: Optional[List[str]] = None) -> Union[np.ndarray, pd.DataFrame]: """ 直接从LAB数组计算Delta E 参数: lab_array: LAB数组 (..., 3) 或 ColorData对象 standard_lab: 标准色LAB数组 (n_standards, 3) method: 色差计算方法 ('CIE76', 'CIE94', 'CIEDE2000') standard_categories: 标准色类别列表 返回: 如果lab_array是图像数据: Delta E数组 (height, width, n_standards) 如果lab_array是一维数据: 包含Delta E结果的DataFrame 示例: >>> # 计算图像与标准色的色差 >>> image_lab = np.random.rand(100, 100, 3) * 100 # 模拟图像数据 >>> standards = np.array([[50, 0, 0], [70, 20, 10]]) # 两个标准色 >>> delta_e = calculate_delta_e_from_arrays(image_lab, standards) >>> # 计算样本与标准色的色差 >>> samples = np.array([[60, 5, 5], [80, -10, 15]]) >>> df = calculate_delta_e_from_arrays(samples, standards) """ if not COLOUR_AVAILABLE: raise ImportError("需要安装colour-science库: pip install colour-science") # 创建计算器 calculator = DeltaECalculator(method=method) # 处理输入数据 if isinstance(lab_array, ColorData): lab_data = lab_array else: lab_data = ColorData.from_array(lab_array) if isinstance(standard_lab, ColorData): std_data = standard_lab else: std_data = ColorData.from_array(standard_lab, standard_categories) # 验证数据 LabDataValidator.validate_lab_range(lab_data, "输入数据", warn_only=True) LabDataValidator.validate_lab_range(std_data, "标准色数据", warn_only=True) # 根据数据维度选择计算方式 if lab_data.shape[0] > 1 and len(lab_data.shape) == 1: # 一维数据（多个样本），返回DataFrame return calculator.calculate_pairwise(lab_data, std_data) else: # 二维或三维数据（图像），返回数组 return calculator.calculate_image_vs_standards(lab_data, std_data) def main(): """主函数""" try: # 解析命令行参数 args = parse_arguments() # 验证必要参数 if args.mode == 'image' and not args.input: print("错误: 图像模式需要指定 --image 参数") sys.exit(1) # 创建并运行应用程序 app = DeltaEApp() app.run(args) except ImportError as e: print(f"导入错误: {str(e)}") print("请确保已安装所有必需的库:") print(" pip install numpy pandas colour-science matplotlib spectral") if TQDM_AVAILABLE: print(" pip install tqdm # 可选，用于进度条") sys.exit(1) except FileNotFoundError as e: print(f"文件错误: 找不到文件 - {str(e)}") sys.exit(1) except ValueError as e: print(f"数据错误: {str(e)}") sys.exit(1) except Exception as e: print(f"未预期的错误: {str(e)}") import traceback traceback.print_exc() sys.exit(1) # ============================================================================= # 直接运行示例（可修改参数后直接运行） # ============================================================================= if __name__ == '__main__': exit(main())