The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
Add color space conversion node. (#16135)
comfyanonymous7b3b262bcb9d
diff --git a/comfy_extras/nodes_images.py b/comfy_extras/nodes_images.pyindex 8e49e30ed..91a3f990c 100644--- a/comfy_extras/nodes_images.py+++ b/comfy_extras/nodes_images.py@@ -1055,6 +1055,124 @@ def hlg_to_linear(t: torch.Tensor) -> torch.Tensor:return torch.where(t <= 0.5, low, high)+_REC709_TO_REC2020 = (+ (0.6274038959346991, 0.3292830383778837, 0.0433130656874172),+ (0.0690972893582320, 0.9195403950754587, 0.0113623155663092),+ (0.0163914388751503, 0.0880133078772259, 0.8955952532476238),+)+_REC2020_TO_REC709 = (+ (1.6604910021084338, -0.5876411387885494, -0.0728498633198846),+ (-0.1245504745215905, 1.1328998971259600, -0.0083494226043695),+ (-0.0181507633549053, -0.1005788980080076, 1.1187296613629125),+)+_REC709_LUMA = (0.2126390058715103, 0.7151686787677559, 0.0721923153607337)+_REC2020_LUMA = (0.2627, 0.6780, 0.0593)+_PQ_M1, _PQ_M2 = 2610 / 16384, 2523 / 32+_PQ_C1, _PQ_C2, _PQ_C3 = 3424 / 4096, 2413 / 128, 2392 / 128+_SDR_WHITE_NITS = 203.0+_HLG_PEAK_NITS = 1000.0+_HLG_GAMMA = 1.2+++def _convert_rgb_primaries(rgb, matrix):+ r, g, b = rgb.unbind(dim=-1)+ return torch.stack([r * row[0] + g * row[1] + b * row[2] for row in matrix], dim=-1)+++def _rgb_luminance(rgb, weights):+ return (rgb * rgb.new_tensor(weights)).sum(dim=-1, keepdim=True)+++def _tone_map_luminance(rgb, weights):+ luminance = _rgb_luminance(rgb, weights).clamp_min(0.0)+ # Extended Reinhard, sharing a white point across the batch to avoid frame-by-frame exposure changes.+ peak = luminance.amax().clamp_min(1.0)+ scale = (1.0 + luminance / peak.square()) / (1.0 + luminance)+ # Allow transfer-function roundoff at SDR white without engaging tone mapping.+ return rgb * torch.where(peak > 1.0001, scale, 1.0)+++def _compress_rgb_gamut(rgb, weights):+ luminance = _rgb_luminance(rgb, weights).clamp(0.0, 1.0)+ chroma = rgb - luminance+ tiny = torch.finfo(rgb.dtype).tiny+ minimum = rgb.amin(dim=-1, keepdim=True)+ maximum = rgb.amax(dim=-1, keepdim=True)+ upper = (1.0 - luminance) / (maximum - luminance).clamp_min(tiny)+ lower = luminance / (luminance - minimum).clamp_min(tiny)+ saturation = torch.minimum(upper, lower).clamp(0.0, 1.0)+ # Do not desaturate boundary colors for transfer-function roundoff.+ in_gamut = (minimum >= -1e-5) & (maximum <= 1.00001)+ return torch.where(in_gamut, rgb, torch.addcmul(luminance, chroma, saturation)).clamp(0.0, 1.0)+++class ImageColorSpace(IO.ComfyNode):+ @classmethod+ def define_schema(cls):+ spaces = ["sRGB", "HDR", "HDR PQ"]+ return IO.Schema(+ node_id="ImageColorSpace",+ display_name="Convert Image Color Space",+ category="image/color",+ description="Convert sRGB (Rec.709), HDR (Rec.2020 HLG), and HDR PQ (Rec.2020 PQ). Uses 203-nit SDR white and a 1000-nit HLG reference display. Narrowing tone-maps excess luminance across the batch and compresses out-of-gamut colors. Conversions compute in float32 and return the intermediate device and dtype. Straight alpha is not color-transformed.",+ inputs=[+ IO.Image.Input("image"),+ IO.Combo.Input("source", options=spaces, default="sRGB", tooltip="Color space of the input pixels."),+ IO.Combo.Input("destination", options=spaces, default="sRGB", tooltip="Color space of the output pixels. Set the save node to this same color space."),+ ],+ outputs=[IO.Image.Output()],+ )++ @classmethod+ def execute(cls, image, source, destination) -> IO.NodeOutput:+ if source == destination:+ return IO.NodeOutput(image.to(device=comfy.model_management.intermediate_device(), dtype=comfy.model_management.intermediate_dtype()))++ # PQ's exponents and near-cancelling constants need more precision than float16/bfloat16.+ rgb = image[..., :3].float()++ # Convert to display-linear Rec.2020 in cd/m² (BT.2100 EOTFs).+ if source == "sRGB":+ rgb = _convert_rgb_primaries(srgb_to_linear(rgb), _REC709_TO_REC2020) * _SDR_WHITE_NITS+ elif source == "HDR":+ rgb = hlg_to_linear(rgb)+ luminance = _rgb_luminance(rgb, _REC2020_LUMA).clamp_min(0.0)+ rgb = rgb * (luminance.pow(_HLG_GAMMA - 1.0) * _HLG_PEAK_NITS)+ elif source == "HDR PQ":+ # Evaluate PQ around 1 to avoid cancellation in float32.+ p = (rgb.clamp_min(0.0).log() / _PQ_M2).expm1()+ rgb = ((p + (1.0 - _PQ_C1)).clamp_min(0.0) / ((_PQ_C2 - _PQ_C3) - _PQ_C3 * p)).pow(1.0 / _PQ_M1) * 10000.0+ else:+ raise ValueError(f"Unsupported source color space: {source}")++ if destination == "sRGB":+ rgb = _convert_rgb_primaries(rgb / _SDR_WHITE_NITS, _REC2020_TO_REC709)+ rgb = _tone_map_luminance(rgb, _REC709_LUMA)+ rgb = _compress_rgb_gamut(rgb, _REC709_LUMA)+ rgb = torch.where(rgb <= 0.0031308, rgb * 12.92, 1.055 * rgb.pow(1.0 / 2.4) - 0.055)+ elif destination == "HDR":+ rgb = rgb / _HLG_PEAK_NITS+ if source == "HDR PQ":+ rgb = _tone_map_luminance(rgb, _REC2020_LUMA)+ luminance = _rgb_luminance(rgb, _REC2020_LUMA).clamp_min(torch.finfo(rgb.dtype).tiny)+ rgb = rgb * luminance.pow(1.0 / _HLG_GAMMA - 1.0)+ if source == "HDR PQ":+ rgb = _compress_rgb_gamut(rgb, _REC2020_LUMA)+ low = (3.0 * rgb.clamp_min(0.0)).sqrt()+ high = _HLG_A * (12.0 * rgb.clamp_min(1.0 / 12.0) - _HLG_B).log() + _HLG_C+ rgb = torch.where(rgb <= 1.0 / 12.0, low, high)+ elif destination == "HDR PQ":+ p = (rgb.clamp_min(0.0) / 10000.0).pow(_PQ_M1)+ p = ((_PQ_C1 - 1.0) + (_PQ_C2 - _PQ_C3) * p) / (1.0 + _PQ_C3 * p)+ rgb = (p.log1p() * _PQ_M2).exp()+ else:+ raise ValueError(f"Unsupported destination color space: {destination}")++ if image.shape[-1] == 4:+ rgb = torch.cat((rgb, image[..., 3:]), dim=-1)+ return IO.NodeOutput(rgb.to(device=comfy.model_management.intermediate_device(), dtype=comfy.model_management.intermediate_dtype()))++# ---------------------------------------------------------------------------# Metadata injection# ---------------------------------------------------------------------------@@ -1768,6 +1886,7 @@ class ImagesExtension(ComfyExtension):RepeatImageBatch,ImageFromBatch,ImageAddNoise,+ ImageColorSpace,SaveAnimatedWEBP,SaveAnimatedPNG,SaveImageAdvanced,