# Version: 5.5 (Final) - Bilingual UI & Comments # Author: overcloud81(@github @modelscope) with deepseek # Copyright (c) 2025 overcloud81. All rights reserved. # 功能：支持亮度(L)、色相(H)、饱和度(S)独立匹配，新增“色彩精确”模式（色相/饱和度像素级精确，亮度不变） # 所有参数已设为合理默认值，开箱即用 # Features: Independent matching of Luminance (L), Hue (H), Saturation (S). New "Color Exact" mode (pixel-perfect hue/saturation, luminance unchanged). # All parameters have sensible defaults for out-of-the-box use. import torch import numpy as np from scipy.ndimage import gaussian_filter import folder_paths import os class ColorConsistencyHSLAdvanced: """ HSL-based color consistency node. Supports independent matching of Luminance, Hue, Saturation. Four anchor modes: statistical match, pixel-perfect, luminance stat + color exact, color exact. Bilingual UI (Chinese/English) with automatic adaptation based on ComfyUI language setting. """ @classmethod def INPUT_TYPES(cls): # 检测 ComfyUI 语言设置 / Detect ComfyUI language setting is_chinese = cls._is_chinese_locale() # 根据语言设置选择菜单文字 / Select menu text based on language if is_chinese: mode_list = ["亮度", "色相", "饱和度", "亮度+色相", "亮度+饱和度", "色相+饱和度", "亮度+色相+饱和度"] anchor_mode_list = ["统计匹配", "像素级精确", "亮度统计+色彩精确", "色彩精确"] luma_space_list = ["LAB L通道", "线性RGB亮度"] interpolation_list = ["bilinear", "nearest"] mode_default = "亮度+色相+饱和度" anchor_default = "统计匹配" luma_default = "LAB L通道" else: mode_list = ["luminance", "hue", "saturation", "luminance+hue", "luminance+saturation", "hue+saturation", "luminance+hue+saturation"] anchor_mode_list = ["statistical match", "pixel-perfect", "luminance stat + color exact", "color exact"] luma_space_list = ["LAB L channel", "linear RGB luminance"] interpolation_list = ["bilinear", "nearest"] mode_default = "luminance+hue+saturation" anchor_default = "statistical match" luma_default = "LAB L channel" return { "required": { "reference": ("IMAGE",), "target": ("IMAGE",), "mode": (mode_list, {"default": mode_default}), "anchor_mode": (anchor_mode_list, { "default": anchor_default, "tooltip": "色彩精确：色相和饱和度像素级精确，亮度不变 / Color exact: pixel-perfect hue/saturation, luminance unchanged" }), "luma_space": (luma_space_list, { "default": luma_default, "tooltip": "亮度统计匹配的空间（仅当亮度参与匹配时有效） / Space for luminance statistical matching (only when luminance is matched)" }), "align_corners": ("BOOLEAN", {"default": True, "tooltip": "对齐四角，True可减少像素偏移 / Align corners, True reduces pixel shift"}), "interpolation": (interpolation_list, {"default": "bilinear", "tooltip": "缩放插值方式 / Interpolation method for scaling"}), "force_match_size": ("BOOLEAN", {"default": False, "tooltip": "强制尺寸一致（不一致时自动缩放） / Force size match (auto-scale if different)"}), "luma_strength": ("FLOAT", { "default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01, "display": "slider", "tooltip": "亮度统计匹配强度（仅亮度参与统计匹配时有效） / Strength of luminance statistical matching (only when luminance is matched statistically)" }), "strength": ("FLOAT", { "default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01, "display": "slider", "tooltip": "整图混合强度 / Global blend strength" }), "protect_strength": ("FLOAT", { "default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01, "display": "slider", "tooltip": "编辑区域保留原图的比例 / Proportion of original image retained in edit area" }), "feather_radius": ("INT", { "default": 10, "min": 0, "max": 100, "step": 1, "display": "slider", "tooltip": "蒙版羽化半径（像素） / Mask feather radius (pixels)" }), "auto_mask": ("BOOLEAN", {"default": False, "tooltip": "启用自动蒙版 / Enable auto mask"}), "mask_threshold": ("FLOAT", { "default": 0.1, "min": 0.0, "max": 1.0, "step": 0.01, "display": "slider", "tooltip": "自动蒙版阈值 / Auto mask threshold" }), }, "optional": { "external_mask": ("MASK",), } } RETURN_TYPES = ("IMAGE",) FUNCTION = "blend" CATEGORY = "image/postprocessing" @staticmethod def _is_chinese_locale(): """检测是否为中文界面 / Detect if UI is in Chinese""" try: import json # 方法1: 检查用户目录下的配置文件 / Check user config file user_dir = os.path.join(folder_paths.base_path, "user", "default") config_path = os.path.join(user_dir, "comfy.settings.json") if not os.path.exists(config_path): # 尝试其他可能的路径 / Try alternative paths config_path = os.path.join(folder_paths.base_path, "comfy.settings.json") if os.path.exists(config_path): with open(config_path, 'r', encoding='utf-8') as f: config = json.load(f) # 尝试多种可能的键名 / Try multiple possible key names lang = None if "Comfy.Locale" in config: lang_value = config["Comfy.Locale"] if isinstance(lang_value, dict): lang = lang_value.get("value", lang_value.get("selected", "en")) elif isinstance(lang_value, str): lang = lang_value if lang and isinstance(lang, str): return lang.startswith('zh') or 'chinese' in lang.lower() # 方法2: 检查环境变量 / Check environment variable lang_env = os.environ.get('COMFYUI_LANG', os.environ.get('LANG', '')) if lang_env and (lang_env.startswith('zh') or 'chinese' in lang_env.lower()): return True # 默认中文（更符合国内用户使用习惯）/ Default to Chinese (more suitable for Chinese users) return True except Exception as e: print(f"[ColorConsistencyHSL] Language detection error: {e}") return True # 出错时默认中文 / Default to Chinese on error def blend(self, reference, target, mode, anchor_mode, luma_space, align_corners, interpolation, force_match_size, luma_strength, strength, protect_strength, feather_radius, auto_mask, mask_threshold, external_mask=None): # 参数有效性验证 / Parameter validation valid_interpolations = ["bilinear", "nearest"] if interpolation not in valid_interpolations: print(f"警告: interpolation '{interpolation}' 无效，使用默认 'bilinear' / Warning: interpolation '{interpolation}' invalid, using default 'bilinear'") interpolation = "bilinear" # 安全裁剪数值参数 / Safely clip numeric parameters luma_strength = np.clip(luma_strength, 0.0, 1.0) protect_strength = np.clip(protect_strength, 0.0, 1.0) strength = np.clip(strength, 0.0, 1.0) feather_radius = max(0, int(feather_radius)) mask_threshold = np.clip(mask_threshold, 0.0, 1.0) # 将中英文模式映射到通道索引列表 / Map Chinese/English mode to channel indices mode_map = { "亮度": [0], "luminance": [0], "色相": [1], "hue": [1], "饱和度": [2], "saturation": [2], "亮度+色相": [0, 1], "luminance+hue": [0, 1], "亮度+饱和度": [0, 2], "luminance+saturation": [0, 2], "色相+饱和度": [1, 2], "hue+saturation": [1, 2], "亮度+色相+饱和度": [0, 1, 2], "luminance+hue+saturation": [0, 1, 2], } channels_to_match = mode_map.get(mode, [0, 1, 2]) # 默认全通道 / default all channels # 转换为 (B,H,W,C) float32 0-1 / Convert to (B,H,W,C) float32 0-1 ref_np = self._prepare_image(reference) tgt_np = self._prepare_image(target) # 批次兼容 / Batch compatibility if ref_np.shape[0] == 1 and tgt_np.shape[0] > 1: ref_np = np.repeat(ref_np, tgt_np.shape[0], axis=0) elif tgt_np.shape[0] == 1 and ref_np.shape[0] > 1: tgt_np = np.repeat(tgt_np, ref_np.shape[0], axis=0) elif ref_np.shape[0] != tgt_np.shape[0]: raise ValueError(f"批次不匹配: ref {ref_np.shape[0]}, tgt {tgt_np.shape[0]} / Batch mismatch: ref {ref_np.shape[0]}, tgt {tgt_np.shape[0]}") # 尺寸检查与处理 / Size check and handling if ref_np.shape[1:3] != tgt_np.shape[1:3]: if force_match_size: print(f"警告: force_match_size=True 但尺寸不一致，将自动缩放参考图以匹配目标图。 / Warning: force_match_size=True but sizes differ, auto-scaling reference to match target.") ref_tensor = torch.from_numpy(ref_np).permute(0, 3, 1, 2) mode_map_interp = {"bilinear": "bilinear", "nearest": "nearest"} ref_tensor = torch.nn.functional.interpolate(ref_tensor, size=tgt_np.shape[1:3], mode=mode_map_interp[interpolation], align_corners=align_corners if interpolation == "bilinear" else None) ref_np = ref_tensor.permute(0, 2, 3, 1).numpy() # 获取原始蒙版（白色=编辑区域，黑色=稳定区域） / Get raw mask (white=edit area, black=stable area) raw_mask = self._get_mask(ref_np, tgt_np, auto_mask, mask_threshold, external_mask) # 羽化蒙版 / Feather mask mask = self._feather_mask(raw_mask, feather_radius) if raw_mask is not None else None # 色相/饱和度处理始终在 LAB 空间进行，亮度处理根据 luma_space 选择 # Hue/saturation always processed in LAB space, luminance processing depends on luma_space ref_lab = self._rgb_to_lab(ref_np) tgt_lab = self._rgb_to_lab(tgt_np) # 将 a,b 转换为极坐标：色相 H (角度) 和 饱和度 S (模长) # Convert a,b to polar: Hue H (angle) and Saturation S (magnitude) ref_H, ref_S = self._cartesian_to_polar(ref_lab[..., 1], ref_lab[..., 2]) tgt_H, tgt_S = self._cartesian_to_polar(tgt_lab[..., 1], tgt_lab[..., 2]) # 构建 HSL 堆叠：L, H, S（L 可能来自 LAB 或 线性亮度） # Build HSL stack: L, H, S (L may come from LAB or linear luminance) if luma_space in ["LAB L通道", "LAB L channel"]: ref_luma = ref_lab[..., 0] tgt_luma = tgt_lab[..., 0] else: # 线性RGB亮度 / linear RGB luminance ref_lin = self._srgb_to_linear(ref_np) tgt_lin = self._srgb_to_linear(tgt_np) ref_luma = 0.2126 * ref_lin[..., 0] + 0.7152 * ref_lin[..., 1] + 0.0722 * ref_lin[..., 2] tgt_luma = 0.2126 * tgt_lin[..., 0] + 0.7152 * tgt_lin[..., 1] + 0.0722 * tgt_lin[..., 2] ref_hsl = np.stack([ref_luma, ref_H, ref_S], axis=-1) tgt_hsl = np.stack([tgt_luma, tgt_H, tgt_S], axis=-1) # 根据锚定模式生成匹配结果 / Generate matching result based on anchor mode matched_hsl = tgt_hsl.copy() if anchor_mode in ["统计匹配", "statistical match"]: matched_hsl = self._match_channels_hsl(ref_hsl, tgt_hsl, mask, channels_to_match, luma_strength) elif anchor_mode in ["像素级精确", "pixel-perfect"]: for ch in channels_to_match: matched_hsl[..., ch] = ref_hsl[..., ch] elif anchor_mode in ["亮度统计+色彩精确", "luminance stat + color exact"]: # 亮度统计匹配，色相/饱和度精确 / luminance statistical match, hue/saturation exact for ch in channels_to_match: if ch == 0: # 亮度 / luminance if mask is None: ref_mean = ref_hsl[..., ch].mean(axis=(1,2), keepdims=True) ref_std = ref_hsl[..., ch].std(axis=(1,2), keepdims=True) tgt_mean = tgt_hsl[..., ch].mean(axis=(1,2), keepdims=True) tgt_std = tgt_hsl[..., ch].std(axis=(1,2), keepdims=True) adjusted = (tgt_hsl[..., ch] - tgt_mean.squeeze()) / (tgt_std.squeeze() + 1e-8) * ref_std.squeeze() + ref_mean.squeeze() matched_hsl[..., ch] = luma_strength * adjusted + (1 - luma_strength) * tgt_hsl[..., ch] else: for i in range(ref_hsl.shape[0]): stable = mask[i] < 0.5 if np.sum(stable) == 0: stable = np.ones_like(mask[i], dtype=bool) ref_vals = ref_hsl[i, ..., ch][stable] tgt_vals = tgt_hsl[i, ..., ch][stable] ref_mean = ref_vals.mean() ref_std = ref_vals.std() tgt_mean = tgt_vals.mean() tgt_std = tgt_vals.std() adjusted = (tgt_hsl[i, ..., ch] - tgt_mean) / (tgt_std + 1e-8) * ref_std + ref_mean matched_hsl[i, ..., ch] = luma_strength * adjusted + (1 - luma_strength) * tgt_hsl[i, ..., ch] else: # 色相或饱和度 / hue or saturation matched_hsl[..., ch] = ref_hsl[..., ch] else: # "色彩精确" / "color exact" # 只对色相(1)和饱和度(2)进行像素级精确替换 / pixel-perfect replacement only for hue(1) and saturation(2) for ch in [1, 2]: if ch in channels_to_match: matched_hsl[..., ch] = ref_hsl[..., ch] # 亮度(0)保持原样 / luminance(0) unchanged # 从匹配后的 HSL 分离出 L、H、S / Extract L, H, S from matched HSL matched_luma = matched_hsl[..., 0] matched_H = matched_hsl[..., 1] matched_S = matched_hsl[..., 2] # 将极坐标转换回 a,b / Convert polar back to a,b matched_a, matched_b = self._polar_to_cartesian(matched_H, matched_S) # 根据 luma_space 重建最终图像 / Reconstruct final image based on luma_space if luma_space in ["LAB L通道", "LAB L channel"]: matched_lab = np.stack([matched_luma, matched_a, matched_b], axis=-1) matched_rgb = self._lab_to_rgb(matched_lab) else: # 线性RGB亮度 / linear RGB luminance tgt_lin = self._srgb_to_linear(tgt_np) eps = 1e-8 scale = matched_luma / (tgt_luma + eps) scale = scale[..., np.newaxis] matched_lin = tgt_lin * scale matched_rgb = self._linear_to_srgb(matched_lin) # 合成最终结果：背景区域完全使用 matched_rgb，编辑区域根据 protect_strength 混合 matched_rgb 和原图 # Composite final result: background uses matched_rgb fully, edit area blends matched_rgb and original based on protect_strength if mask is None: final_rgb = matched_rgb else: mask_exp = mask[..., np.newaxis] edit_blend = protect_strength * tgt_np + (1 - protect_strength) * matched_rgb final_rgb = (1 - mask_exp) * matched_rgb + mask_exp * edit_blend # 强度混合（整图混合） / Strength blend (global) blended_rgb = strength * final_rgb + (1 - strength) * tgt_np blended_rgb = np.clip(blended_rgb, 0.0, 1.0) out_tensor = torch.from_numpy(blended_rgb).to(reference.device) return (out_tensor,) # ---------- 辅助函数 / Helper functions ---------- def _prepare_image(self, img): """将输入图像统一为 (B,H,W,C) float32 0-1 格式 / Normalize input image to (B,H,W,C) float32 0-1""" if isinstance(img, torch.Tensor): img = img.cpu().numpy() img = img.astype(np.float32) if img.ndim == 4 and img.shape[1] in (1, 3, 4) and img.shape[3] not in (1, 3, 4): img = np.transpose(img, (0, 2, 3, 1)) elif img.ndim == 3: img = img[np.newaxis, ...] if img.max() > 1.0: img = img / 255.0 return img def _get_mask(self, ref, tgt, auto_mask, threshold, external_mask): """获取蒙版：白色=编辑区域，黑色=稳定区域 / Get mask: white=edit area, black=stable area""" if external_mask is not None: mask = self._prepare_mask(external_mask, tgt.shape[1:3]) return mask elif auto_mask: diff = np.mean(np.abs(ref - tgt), axis=-1) mask = (diff > threshold).astype(np.float32) return mask else: return None def _prepare_mask(self, mask, target_size): """将蒙版转为 (B,H,W) float32 0-1 并调整尺寸 / Convert mask to (B,H,W) float32 0-1 and resize""" if isinstance(mask, torch.Tensor): mask = mask.cpu().numpy() mask = mask.astype(np.float32) if mask.ndim == 4: if mask.shape[1] == 1: mask = mask[:, 0, :, :] elif mask.shape[-1] == 1: mask = mask[..., 0] elif mask.ndim == 2: mask = mask[np.newaxis, ...] if mask.max() > 1.0: mask = mask / 255.0 if mask.shape[1:3] != target_size: mask_tensor = torch.from_numpy(mask).unsqueeze(1) mask_tensor = torch.nn.functional.interpolate(mask_tensor, size=target_size, mode='bilinear', align_corners=False) mask = mask_tensor.squeeze(1).numpy() return mask def _feather_mask(self, mask, radius): """对蒙版进行高斯模糊羽化 / Gaussian blur feathering on mask""" if radius <= 0 or mask is None: return mask B, H, W = mask.shape feathered = np.zeros_like(mask) for i in range(B): feathered[i] = gaussian_filter(mask[i], sigma=radius, mode='reflect') return feathered def _cartesian_to_polar(self, a, b): """笛卡尔坐标 (a,b) 转极坐标 (角度, 模长) / Cartesian to polar (angle, magnitude)""" H = np.arctan2(b, a) S = np.sqrt(a**2 + b**2) return H, S def _polar_to_cartesian(self, H, S): """极坐标 (角度, 模长) 转笛卡尔坐标 (a,b) / Polar to Cartesian (a,b)""" a = S * np.cos(H) b = S * np.sin(H) return a, b def _match_channels_hsl(self, ref_hsl, tgt_hsl, mask, channels, luma_strength=1.0): """ 对指定通道进行统计匹配（带蒙版） / Statistical matching on specified channels (with mask) channels: list of channel indices to match (0=L, 1=H, 2=S) """ result = tgt_hsl.copy() B, H, W, C = ref_hsl.shape if mask is None: for ch in channels: ref_mean = ref_hsl[..., ch].mean(axis=(1,2), keepdims=True) ref_std = ref_hsl[..., ch].std(axis=(1,2), keepdims=True) tgt_mean = tgt_hsl[..., ch].mean(axis=(1,2), keepdims=True) tgt_std = tgt_hsl[..., ch].std(axis=(1,2), keepdims=True) adjusted = (tgt_hsl[..., ch] - tgt_mean.squeeze()) / (tgt_std.squeeze() + 1e-8) * ref_std.squeeze() + ref_mean.squeeze() if ch == 0: result[..., ch] = luma_strength * adjusted + (1 - luma_strength) * tgt_hsl[..., ch] else: result[..., ch] = adjusted else: for i in range(B): stable = mask[i] < 0.5 if np.sum(stable) == 0: stable = np.ones_like(mask[i], dtype=bool) for ch in channels: ref_vals = ref_hsl[i, ..., ch][stable] tgt_vals = tgt_hsl[i, ..., ch][stable] ref_mean = ref_vals.mean() ref_std = ref_vals.std() tgt_mean = tgt_vals.mean() tgt_std = tgt_vals.std() adjusted = (tgt_hsl[i, ..., ch] - tgt_mean) / (tgt_std + 1e-8) * ref_std + ref_mean if ch == 0: result[i, ..., ch] = luma_strength * adjusted + (1 - luma_strength) * tgt_hsl[i, ..., ch] else: result[i, ..., ch] = adjusted return result # ---------- sRGB 与线性 RGB 转换 / sRGB to/from linear RGB ---------- def _srgb_to_linear(self, rgb): """sRGB 非线性转线性 RGB (OETF逆变换) / sRGB to linear RGB (inverse OETF)""" rgb = np.clip(rgb, 0.0, 1.0) linear = np.where(rgb <= 0.04045, rgb / 12.92, ((rgb + 0.055) / 1.055) ** 2.4) return linear.astype(np.float32) def _linear_to_srgb(self, linear): """线性 RGB 转 sRGB 非线性 (EOTF变换) / Linear RGB to sRGB (EOTF)""" linear = np.clip(linear, 0.0, 1.0) srgb = np.where(linear <= 0.0031308, linear * 12.92, 1.055 * (linear ** (1/2.4)) - 0.055) return srgb.astype(np.float32) # ---------- LAB 转换 / LAB conversion ---------- def _rgb_to_lab(self, rgb): """RGB 转 LAB (近似公式，基于D65) / RGB to LAB (approximate, D65)""" r, g, b = rgb[..., 0], rgb[..., 1], rgb[..., 2] # 转 XYZ / to XYZ x = 0.412453 * r + 0.357580 * g + 0.180423 * b y = 0.212671 * r + 0.715160 * g + 0.072169 * b z = 0.019334 * r + 0.119193 * g + 0.950227 * b # 归一化 D65 / normalize D65 x /= 0.950456 z /= 1.088754 # 非线性变换 / nonlinear transform eps = 0.008856 k = 903.3 def f(t): return np.where(t > eps, t ** (1/3), (k * t + 16) / 116) fx = f(x) fy = f(y) fz = f(z) L = 116 * fy - 16 a = 500 * (fx - fy) b_lab = 200 * (fy - fz) return np.stack([L, a, b_lab], axis=-1) def _lab_to_rgb(self, lab): """LAB 转 RGB / LAB to RGB""" L, a, b_lab = lab[..., 0], lab[..., 1], lab[..., 2] fy = (L + 16) / 116 fx = a / 500 + fy fz = fy - b_lab / 200 eps = 0.008856 k = 903.3 def finv(t): return np.where(t > eps, t ** 3, (116 * t - 16) / k) x = finv(fx) * 0.950456 y = finv(fy) z = finv(fz) * 1.088754 # XYZ 转 RGB / XYZ to RGB r = 3.240479 * x - 1.537150 * y - 0.498535 * z g = -0.969256 * x + 1.875992 * y + 0.041556 * z b = 0.055648 * x - 0.204043 * y + 1.057311 * z return np.stack([r, g, b], axis=-1) NODE_CLASS_MAPPINGS = { "Color Consistency HSL Advanced": ColorConsistencyHSLAdvanced, } NODE_DISPLAY_NAME_MAPPINGS = { "Color Consistency HSL Advanced": "色彩亮度一致性混合 (HSL高级版)", }