The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
[Partner Nodes] feat: ImageCompositor node with layer-state compositing, layer from bbox and Seedream Layer Separation node (#15317)
Terry Jia8fadc7b5be50
diff --git a/comfy_api/latest/_io.py b/comfy_api/latest/_io.pyindex 58e49d8e2..6d9e08f47 100644--- a/comfy_api/latest/_io.py+++ b/comfy_api/latest/_io.py@@ -847,6 +847,61 @@ class Load3DAnimation(Load3D):...+@comfytype(io_type="LAYERS")+class Layers(ComfyTypeIO):+ BlendMode = Literal[+ "normal", "multiply", "screen", "overlay", "darken", "lighten",+ "color-dodge", "color-burn", "hard-light", "soft-light", "difference",+ "exclusion", "linear-dodge", "linear-burn", "vivid-light", "pin-light",+ "linear-light", "hard-mix", "subtract", "divide", "grain-extract",+ "grain-merge", "hue", "saturation", "color", "luminosity",+ ]++ class LayerItem(TypedDict):+ image: torch.Tensor+ type: Literal["raster"]+ x: NotRequired[int]+ y: NotRequired[int]+ mask: NotRequired[torch.Tensor]+ z_index: int+ name: NotRequired[str]+ opacity: NotRequired[float]+ blend_mode: NotRequired["Layers.BlendMode"]+ visible: NotRequired[bool]+ flip_h: NotRequired[bool]+ flip_v: NotRequired[bool]+ rotation: NotRequired[float]+ w: NotRequired[int]+ h: NotRequired[int]++ class Document(TypedDict):+ version: int+ canvas: NotRequired[tuple[int, int]]+ layers: list["Layers.LayerItem"]++ Type = Document+++@comfytype(io_type="COMPOSITOR")+class Compositor(ComfyTypeIO):+ class LayerState(TypedDict):+ version: NotRequired[int]+ canvas: dict+ background: NotRequired[dict]+ inputs: NotRequired[list[str]]+ order: NotRequired[list[int]]+ layers: list[dict]++ Type = LayerState++ class Input(WidgetInput):+ def __init__(self, id: str, display_name: str=None, optional=False, tooltip: str=None,+ socketless: bool=True, default: dict=None, advanced: bool=None):+ super().__init__(id, display_name, optional, tooltip, None, default, socketless, None, None, None, None, advanced)+ if default is None:+ self.default = {}++@comfytype(io_type="PHOTOMAKER")class Photomaker(ComfyTypeIO):Type = Any@@ -2403,6 +2458,8 @@ __all__ = ["Load3DModelInfo","Load3D","Load3DAnimation",+ "Compositor",+ "Layers","Photomaker","Point","FaceAnalysis",diff --git a/comfy_api_nodes/apis/bytedance.py b/comfy_api_nodes/apis/bytedance.pyindex b83bb99ce..7ee83e5f3 100644--- a/comfy_api_nodes/apis/bytedance.py+++ b/comfy_api_nodes/apis/bytedance.py@@ -35,6 +35,23 @@ class Seedream4TaskCreationRequest(BaseModel):optimize_prompt_options: Seedream5OptimizePromptOptions | None = None+class Seedream5LayerOptimizePromptOptions(BaseModel):+ mode: Literal["standard", "fast"] = Field(...)+++class Seedream5LayerSeparationRequest(BaseModel):+ model: str = Field(...)+ prompt: str | None = Field(None)+ image: str = Field(..., description="Single image URL")+ size: str = Field("auto")+ seed: int = Field(..., ge=0, le=2147483647)+ response_format: str = Field("url")+ output_format: str = Field("png")+ layer_decomposition: bool = Field(True)+ watermark: bool = Field(False)+ optimize_prompt_options: Seedream5LayerOptimizePromptOptions | None = Field(None)++class ImageTaskCreationResponse(BaseModel):model: str = Field(...)created: int = Field(..., description="Unix timestamp (in seconds) indicating time when the request was created.")diff --git a/comfy_api_nodes/nodes_bytedance.py b/comfy_api_nodes/nodes_bytedance.pyindex f321a496b..09fc445d8 100644--- a/comfy_api_nodes/nodes_bytedance.py+++ b/comfy_api_nodes/nodes_bytedance.py@@ -1,3 +1,4 @@+import asyncioimport base64import hashlibimport logging@@ -34,6 +35,8 @@ from comfy_api_nodes.apis.bytedance import (SeedanceVirtualLibraryCreateAssetRequest,Seedream4Options,Seedream4TaskCreationRequest,+ Seedream5LayerOptimizePromptOptions,+ Seedream5LayerSeparationRequest,Seedream5OptimizePromptOptions,TaskAudioContent,TaskAudioContentUrl,@@ -75,6 +78,7 @@ from comfy_api_nodes.util import (validate_video_dimensions,validate_video_duration,)+from comfy_api_nodes.util.common_exceptions import ProcessingInterruptedfrom server import PromptServerBYTEPLUS_IMAGE_ENDPOINT = "/proxy/byteplus/api/v3/images/generations"@@ -96,6 +100,8 @@ SEEDREAM_PRESETS = {"seedream-4-0-250828": RECOMMENDED_PRESETS_SEEDREAM_4_0,}+SEEDREAM_LAYER_SEPARATION_MODEL = "seedream-5-0-pro-260628"+# Long-running tasks endpoints(e.g., video)BYTEPLUS_TASK_ENDPOINT = "/proxy/byteplus/api/v3/contents/generations/tasks"BYTEPLUS_TASK_STATUS_ENDPOINT = "/proxy/byteplus/api/v3/contents/generations/tasks" # + /{task_id}@@ -1044,6 +1050,369 @@ class ByteDanceSeedreamNodeV2(IO.ComfyNode):return IO.NodeOutput(torch.cat([await download_url_to_image_tensor(i) for i in urls]))+class ByteDanceSeedreamLayerSeparationNode(IO.ComfyNode):++ @classmethod+ def define_schema(cls):+ return IO.Schema(+ node_id="ByteDanceSeedreamLayerSeparationNode",+ display_name="ByteDance Seedream 5.0 Pro Layer Separation",+ category="partner/image/ByteDance",+ search_aliases=["layer separation", "split layers", "decompose", "cutout", "RGBA layers"],+ description=(+ "Decompose an image into a background plate plus up to 16 repositionable transparent layers, "+ "each with stacking order, bounding box, name and description."+ ),+ inputs=[+ IO.Image.Input(+ "image",+ tooltip=(+ "The image to separate. Exactly one image, at least 512x512 pixels, aspect ratio "+ "between 1:16 and 16:1. Inputs larger than about 4MP are downscaled before upload."+ ),+ ),+ IO.String.Input(+ "prompt",+ multiline=True,+ default="",+ tooltip=(+ "How to separate the image. Leave empty to auto-detect and separate all major elements. "+ "Describe elements in natural language to control the separation, or target exact regions "+ "with <bbox>left top right bottom</bbox> tags (0-1000 per-mille coordinates)."+ ),+ ),+ IO.Combo.Input(+ "size",+ options=["auto", "1K", "1.5K", "2K"],+ default="auto",+ tooltip="Output resolution level. 'auto' follows the input image size (clamped to the 1K-2K range).",+ ),+ IO.Int.Input(+ "seed",+ default=0,+ min=0,+ max=2147483647,+ step=1,+ display_mode=IO.NumberDisplay.number,+ control_after_generate=True,+ tooltip="Seed to use for generation.",+ ),+ IO.Combo.Input(+ "prompt_optimization",+ options=["standard", "fast"],+ default="standard",+ optional=True,+ advanced=True,+ tooltip="Prompt-optimization mode: 'standard' gives higher quality, 'fast' shorter generation time.",+ ),+ IO.Boolean.Input(+ "watermark",+ default=False,+ optional=True,+ advanced=True,+ tooltip='Whether to add an "AI generated" watermark to the images.',+ ),+ IO.Boolean.Input(+ "crop_layers",+ default=False,+ optional=True,+ label_on="minimal size",+ label_off="full canvas",+ tooltip=(+ "Geometry of the layers/masks batch outputs (layer_stack is unaffected and always "+ "tight). Full canvas: each layer on a base-sized canvas at its bounding-box position - "+ "recompose directly with ImageCompositeMasked. Minimal size: each layer cropped to its "+ "bounding box (padded to the largest layer for batching) - much smaller tensors; "+ "rebuild placement with Layers From Bounding Boxes using the bboxes output."+ ),+ ),+ ],+ outputs=[+ IO.Image.Output(+ display_name="base_image",+ tooltip="The base image (background plate) the layers stack onto.",+ ),+ IO.Mask.Output(+ display_name="base_mask",+ tooltip=(+ "Transparency of the base image (1 = transparent, LoadImage convention); currently "+ "always fully opaque."+ ),+ ),+ IO.Image.Output(+ display_name="layers",+ tooltip=(+ "Transparent layers ordered bottom to top. Full canvas mode: placed on a black "+ "base-sized canvas at their bounding-box position. Minimal size mode: cropped to "+ "their bounding box, anchored top-left, padded to the largest layer."+ ),+ ),+ IO.Mask.Output(+ display_name="masks",+ tooltip=(+ "Per-layer transparency, index-aligned with the layers batch (1 = transparent, "+ "LoadImage convention). For ImageCompositeMasked-style compositing, add InvertMask first."+ ),+ ),+ IO.BoundingBox.Output(+ display_name="bboxes",+ tooltip=(+ "One placement box per layer, index-aligned with the layers batch (feed both, plus "+ "masks, into Layers From Bounding Boxes to rebuild per-layer placement): {x, y, width, "+ "height, metadata: {name, desc, z_index, native_size, content_rect, flags}}. "+ "content_rect = [left, top, width, height] is the layer's content region within its "+ "own frame; it lands on the canvas at the box position plus that offset."+ ),+ ),+ IO.Layers.Output(+ display_name="layer_stack",+ tooltip=(+ "Ready-to-edit layer document for Create Layered Image: the base plate plus each "+ "element as its own named, tight-cropped layer at its true position and stacking "+ "order. Connect directly, or extend with Add Layer."+ ),+ ),+ ],+ hidden=[+ IO.Hidden.auth_token_comfy_org,+ IO.Hidden.api_key_comfy_org,+ IO.Hidden.unique_id,+ ],+ is_api_node=True,+ price_badge=IO.PriceBadge(+ depends_on=IO.PriceBadgeDepends(widgets=["size"]),+ expr="""+ (+ widgets.size in ["1k", "1.5k"]+ ? {+ "type": "usd",+ "usd": 0.032,+ "format": { "suffix": " x images/Run", "approximate": true }+ }+ : {+ "type": "range_usd",+ "min_usd": 0.032,+ "max_usd": 0.064,+ "format": { "suffix": " x images/Run", "approximate": true }+ }+ )+ """,+ ),+ )++ @classmethod+ async def execute(+ cls,+ image: Input.Image,+ prompt: str = "",+ size: str = "auto",+ seed: int = 0,+ prompt_optimization: str = "standard",+ watermark: bool = False,+ crop_layers: bool = False,+ ) -> IO.NodeOutput:+ if get_number_of_images(image) != 1:+ raise ValueError("Only a single input image is supported.")+ validate_image_aspect_ratio(image, (1, 16), (16, 1), strict=False)+ validate_image_dimensions(image, min_width=512, min_height=512)++ request = Seedream5LayerSeparationRequest(+ model=SEEDREAM_LAYER_SEPARATION_MODEL,+ prompt=prompt.strip() or None,+ image=await upload_image_to_comfyapi(cls, image),+ size=size,+ seed=seed,+ watermark=watermark,+ optimize_prompt_options=Seedream5LayerOptimizePromptOptions(mode=prompt_optimization),+ )+ response = await sync_op(+ cls,+ ApiEndpoint(path=BYTEPLUS_IMAGE_ENDPOINT, method="POST"),+ response_model=ImageTaskCreationResponse,+ data=request,+ wait_label="Separating layers",+ )+ if response.error:+ raise RuntimeError(+ f"ByteDance request failed. Code: {response.error['code']}, message: {response.error['message']}"+ )++ def z_index_of(d: dict) -> int:+ v = d.get("z_index")+ if isinstance(v, bool):+ return 1_000_000+ if isinstance(v, (int, float)):+ return int(v)+ if isinstance(v, str):+ try:+ return int(v.strip())+ except ValueError:+ return 1_000_000+ return 1_000_000++ data = [d for d in (response.data or []) if isinstance(d, dict)]+ if not data or "url" not in data[0]:+ raise RuntimeError("Unexpected response: no base image returned.")+ base_item = data[0]+ if base_item.get("bounding_box") is not None:+ logging.warning(+ "ByteDance layer separation: base item unexpectedly carries a bounding_box; ignoring it."+ )+ if z_index_of(base_item) not in (0, 1_000_000):+ raise RuntimeError("Unexpected response: the first item is not the base image.")+ layer_items = [d for d in data[1:] if "url" in d]+ dropped = len(data) - 1 - len(layer_items)+ if dropped > 0:+ logging.warning(+ "ByteDance layer separation: %d of %d returned elements had no 'url' and were dropped.",+ dropped,+ len(data) - 1,+ )+ if not layer_items:+ raise RuntimeError("The model returned no layers. Try a different prompt or input image.")+ layer_items.sort(key=z_index_of)++ base_image = (await download_url_to_image_tensor(str(base_item["url"])))[..., :3].contiguous()+ height, width = base_image.shape[1], base_image.shape[2]++ specs = []+ for item in layer_items:+ flags = []+ bbox = item.get("bounding_box")+ absolute = bbox.get("absolute") if isinstance(bbox, dict) else None+ if (+ isinstance(absolute, (list, tuple))+ and len(absolute) == 4+ and all(isinstance(v, (int, float)) and not isinstance(v, bool) for v in absolute)+ ):+ left, top, right, bottom = (int(round(v)) for v in absolute)+ rect_w, rect_h = right - left, bottom - top # exclusive right/bottom+ if rect_w > width or rect_h > height:+ rect_w, rect_h = min(rect_w, width), min(rect_h, height)+ flags.append("bbox_clamped")+ if rect_w <= 0 or rect_h <= 0:+ flags.append("bbox_degenerate")+ else:+ flags.append("bbox_missing")+ left, top, rect_w, rect_h = 0, 0, width, height+ specs.append({"item": item, "flags": flags, "left": left, "top": top,+ "rect_w": rect_w, "rect_h": rect_h, "native_size": "", "stack_item": None})++ if crop_layers:+ canvas_w = max((s["rect_w"] for s in specs if "bbox_degenerate" not in s["flags"]), default=1)+ canvas_h = max((s["rect_h"] for s in specs if "bbox_degenerate" not in s["flags"]), default=1)+ else:+ canvas_w, canvas_h = width, height+ base_mask = torch.zeros((1, height, width))+ layers = torch.zeros((len(specs), canvas_h, canvas_w, 3))+ # Create Layered Image / LoadImage mask convention: 1 = transparent+ masks = torch.ones((len(specs), canvas_h, canvas_w))++ semaphore = asyncio.Semaphore(4)++ async def fetch_and_place(i: int, spec: dict) -> None:+ item, flags = spec["item"], spec["flags"]+ left, top, rect_w, rect_h = spec["left"], spec["top"], spec["rect_w"], spec["rect_h"]+ async with semaphore:+ try:+ rgba = (await download_url_to_image_tensor(str(item["url"])))[0]+ except ProcessingInterrupted:+ raise+ except Exception as exc:+ raise RuntimeError(+ f"Failed to download layer {i + 1} of {len(specs)} (name={item.get('name')!r}): {exc} "+ "The generation completed and was billed; the response with all layer URLs "+ "is in ComfyUI/temp/api_logs/."+ ) from exc+ spec["native_size"] = f"{rgba.shape[1]}x{rgba.shape[0]}"+ if "bbox_degenerate" in flags:+ return+ if (rgba.shape[1], rgba.shape[0]) != (rect_w, rect_h):+ # premultiply before resizing: interpolating straight alpha bleeds the undefined+ # colors of transparent pixels into the anti-aliased edges+ rgba = rgba.clone()+ rgba[..., :3] *= rgba[..., 3:4]+ rgba = (+ torch.nn.functional.interpolate(+ rgba.permute(2, 0, 1).unsqueeze(0),+ size=(rect_h, rect_w),+ mode="bilinear",+ antialias=True,+ )+ .squeeze(0)+ .permute(1, 2, 0)+ )+ alpha = rgba[..., 3:4]+ rgba = torch.cat([rgba[..., :3] / alpha.clamp(min=1e-6), alpha], dim=-1).clamp(0, 1)+ flags.append("resized_to_bbox")+ # straight (unpremultiplied) RGB: downstream compositing applies the mask itself+ if crop_layers:+ layers[i, :rect_h, :rect_w] = rgba[..., :3]+ masks[i, :rect_h, :rect_w] = 1.0 - rgba[..., 3]+ else:+ x0, y0 = max(left, 0), max(top, 0)+ x1, y1 = min(left + rect_w, width), min(top + rect_h, height)+ if x0 < x1 and y0 < y1:+ patch = rgba[y0 - top : y1 - top, x0 - left : x1 - left]+ layers[i, y0:y1, x0:x1] = patch[..., :3]+ masks[i, y0:y1, x0:x1] = 1.0 - patch[..., 3]+ else:+ flags.append("bbox_out_of_canvas")+ zi = z_index_of(item)+ stack_item = {+ "image": rgba[..., :3].unsqueeze(0).contiguous(),+ "type": "raster",+ "x": left,+ "y": top,+ "z_index": zi if zi != 1_000_000 else i + 1,+ "mask": (1.0 - rgba[..., 3]).unsqueeze(0),+ }+ if isinstance(item.get("name"), str):+ stack_item["name"] = item["name"]+ spec["stack_item"] = stack_item++ await asyncio.gather(*(fetch_and_place(i, s) for i, s in enumerate(specs)))++ stack_items = [{"image": base_image, "type": "raster", "x": 0, "y": 0, "z_index": 0, "name": "background"}]+ boxes = []+ for i, s in enumerate(specs):+ abnormal = [f for f in s["flags"] if f != "resized_to_bbox"]+ if abnormal:+ logging.warning(+ "ByteDance layer separation: layer %d (%r) flagged %s.",+ i + 1,+ s["item"].get("name"),+ ", ".join(abnormal),+ )+ if s["stack_item"] is not None:+ stack_items.append(s["stack_item"])+ zi = z_index_of(s["item"])+ # placement box sized to this layer's tensor so Create Layered Image renders it 1:1;+ # the true content rect travels in metadata, frame-relative+ rect_x, rect_y = (0, 0) if crop_layers else (s["left"], s["top"])+ boxes.append(+ {+ "x": s["left"] if crop_layers else 0,+ "y": s["top"] if crop_layers else 0,+ "width": canvas_w,+ "height": canvas_h,+ "metadata": {+ "name": s["item"].get("name"),+ "desc": s["item"].get("description"),+ "z_index": zi if zi != 1_000_000 else None,+ "native_size": s["native_size"],+ "content_rect": [rect_x, rect_y, max(s["rect_w"], 0), max(s["rect_h"], 0)],+ "flags": s["flags"],+ },+ }+ )+ # a single frame holding every box: the per-frame BOUNDING_BOX shape for boxes that+ # annotate one image, as emitted and consumed by CreateBoundingBoxes+ bboxes = [boxes]+ layer_stack = {"version": 1, "canvas": (width, height), "layers": stack_items}+ return IO.NodeOutput(base_image, base_mask, layers, masks, bboxes, layer_stack)++class ByteDanceTextToVideoNode(IO.ComfyNode):@classmethod@@ -3036,6 +3405,7 @@ class ByteDanceExtension(ComfyExtension):ByteDanceImageNode,ByteDanceSeedreamNode,ByteDanceSeedreamNodeV2,+ ByteDanceSeedreamLayerSeparationNode,ByteDanceTextToVideoNode,ByteDanceImageToVideoNode,ByteDanceFirstLastFrameNode,diff --git a/comfy_extras/compositor_blend.py b/comfy_extras/compositor_blend.pynew file mode 100644index 000000000..13476e781--- /dev/null+++ b/comfy_extras/compositor_blend.py@@ -0,0 +1,331 @@+import math+from typing import NamedTuple, Optional, Union++import numpy as np++EPSILON = 1e-6++LUM_R = 0.2224884+LUM_G = 0.71690369+LUM_B = 0.06060791++ArrayLike = Union[np.ndarray, float]+++def srgb_to_linear(c: ArrayLike) -> np.ndarray:+ c = np.asarray(c, dtype=np.float32)+ high = ((np.maximum(c, 0.0) + 0.055) / 1.055) ** 2.4+ return np.where(c <= 0.04045, c / 12.92, high).astype(np.float32)+++def linear_to_srgb(c: ArrayLike) -> np.ndarray:+ c = np.asarray(c, dtype=np.float32)+ high = 1.055 * np.maximum(c, 0.0) ** (1.0 / 2.4) - 0.055+ return np.where(c <= 0.0031308, 12.92 * c, high).astype(np.float32)+++def luminance(rgb: np.ndarray) -> np.ndarray:+ return rgb[..., 0] * LUM_R + rgb[..., 1] * LUM_G + rgb[..., 2] * LUM_B+++def safe_div(a: ArrayLike, b: ArrayLike) -> np.ndarray:+ a, b = np.broadcast_arrays(+ np.asarray(a, dtype=np.float32), np.asarray(b, dtype=np.float32)+ )+ out = np.zeros(b.shape, dtype=np.float32)+ np.divide(a, b, out=out, where=np.abs(b) >= EPSILON)+ return out+++CHANNEL_BLEND = {+ "normal": lambda i, l: l,+ "multiply": lambda i, l: i * l,+ "screen": lambda i, l: 1 - (1 - i) * (1 - l),+ "overlay": lambda i, l: np.where(i < 0.5, 2 * i * l, 1 - 2 * (1 - l) * (1 - i)),+ "darken": lambda i, l: np.minimum(i, l),+ "lighten": lambda i, l: np.maximum(i, l),+ "color-dodge": lambda i, l: np.where(+ i <= 0,+ 0.0,+ np.where(1 - l <= EPSILON, 1.0, np.minimum(safe_div(i, 1 - l), 1.0)),+ ),+ "color-burn": lambda i, l: np.where(+ i >= 1,+ 1.0,+ np.where(l <= EPSILON, 0.0, 1 - np.minimum(safe_div(1 - i, l), 1.0)),+ ),+ "hard-light": lambda i, l: np.where(+ l > 0.5,+ np.minimum(1 - (1 - i) * (1 - (l - 0.5) * 2), 1),+ np.minimum(i * (l * 2), 1),+ ),+ "soft-light": lambda i, l: (1 - i) * (i * l) + i * (1 - (1 - i) * (1 - l)),+ "difference": lambda i, l: np.abs(i - l),+ "exclusion": lambda i, l: 0.5 - 2 * (i - 0.5) * (l - 0.5),+ "linear-dodge": lambda i, l: i + l,+ "linear-burn": lambda i, l: i + l - 1,+ "vivid-light": lambda i, l: np.where(+ l <= 0.5,+ np.where(+ i >= 1,+ 1.0,+ np.where(+ 2 * l <= EPSILON,+ 0.0,+ np.maximum(1 - safe_div(1 - i, 2 * l), 0.0),+ ),+ ),+ np.where(+ i <= 0,+ 0.0,+ np.where(+ 2 * (1 - l) <= EPSILON,+ 1.0,+ np.minimum(safe_div(i, 2 * (1 - l)), 1.0),+ ),+ ),+ ),+ "pin-light": lambda i, l: np.where(+ l > 0.5, np.maximum(i, 2 * (l - 0.5)), np.minimum(i, 2 * l)+ ),+ "linear-light": lambda i, l: i + 2 * l - 1,+ "hard-mix": lambda i, l: np.where(i + l < 1, 0.0, 1.0),+ "subtract": lambda i, l: np.maximum(i - l, 0),+ "divide": lambda i, l: np.clip(i / np.maximum(l, EPSILON), 0, 1),+ "grain-extract": lambda i, l: i - l + 0.5,+ "grain-merge": lambda i, l: i + l - 0.5,+}+++def _blend_hue(i: np.ndarray, l: np.ndarray) -> np.ndarray:+ src_min = l.min(axis=-1)+ src_max = l.max(axis=-1)+ src_delta = src_max - src_min+ achromatic = src_delta <= EPSILON+ dest_max = i.max(axis=-1)+ dest_delta = dest_max - i.min(axis=-1)+ dest_s = np.where(dest_max != 0, dest_delta / np.where(dest_max != 0, dest_max, 1), 0)+ ratio = np.where(+ achromatic, 0, dest_s * dest_max / np.where(achromatic, 1, src_delta)+ )+ offset = dest_max - src_max * ratio+ return np.where(achromatic[..., None], i, l * ratio[..., None] + offset[..., None])+++def _blend_saturation(i: np.ndarray, l: np.ndarray) -> np.ndarray:+ dest_max = i.max(axis=-1)+ dest_delta = dest_max - i.min(axis=-1)+ flat = dest_delta <= EPSILON+ src_max = l.max(axis=-1)+ src_delta = src_max - l.min(axis=-1)+ src_s = np.where(src_max != 0, src_delta / np.where(src_max != 0, src_max, 1), 0)+ ratio = np.where(flat, 0, src_s * dest_max / np.where(flat, 1, dest_delta))+ offset = (1 - ratio) * dest_max+ return np.where(+ flat[..., None],+ np.broadcast_to(dest_max[..., None], i.shape),+ i * ratio[..., None] + offset[..., None],+ )+++def _blend_color(i: np.ndarray, l: np.ndarray) -> np.ndarray:+ dest_l = (i.min(axis=-1) + i.max(axis=-1)) / 2+ src_l = (l.min(axis=-1) + l.max(axis=-1)) / 2+ gray = (np.abs(src_l) <= EPSILON) | (np.abs(1 - src_l) <= EPSILON)+ dest_high = dest_l > 0.5+ src_high = src_l > 0.5+ dl = np.minimum(dest_l, 1 - dest_l)+ sl = np.minimum(src_l, 1 - src_l)+ ratio = dl / np.where(gray, 1, sl)+ offset = np.where(dest_high, 1 - 2 * dl, 0) + np.where(src_high, 2 * dl - ratio, 0)+ return np.where(+ gray[..., None],+ np.broadcast_to(dest_l[..., None], i.shape),+ l * ratio[..., None] + offset[..., None],+ )+++def _blend_luminosity(i: np.ndarray, l: np.ndarray) -> np.ndarray:+ # Scale the backdrop so it carries the layer's luminance. Where the backdrop+ # has no luminance to scale there is no hue or saturation to preserve either,+ # so the result is a neutral grey at the layer's luminance - which is also the+ # analytic limit of i * lum(l)/lum(i) as a grey backdrop approaches black.+ # Guarding the numerator here instead (returning black) makes a luminosity+ # layer disappear over dark backdrops; see tests-unit/comfy_extras_test/+ # compositor_blend_golden.json.+ lum_i = luminance(i)+ lum_l = luminance(l)+ degenerate = lum_i <= EPSILON+ ratio = np.where(degenerate, 0.0, lum_l / np.where(degenerate, 1.0, lum_i))+ return np.where(+ degenerate[..., None],+ np.broadcast_to(lum_l[..., None], i.shape),+ i * ratio[..., None],+ )+++HSL_BLEND = {+ "hue": _blend_hue,+ "saturation": _blend_saturation,+ "color": _blend_color,+ "luminosity": _blend_luminosity,+}+++def blend_pixel(blend: str, in_rgb: np.ndarray, layer_rgb: np.ndarray) -> np.ndarray:+ in_rgb = np.asarray(in_rgb, dtype=np.float32)+ layer_rgb = np.asarray(layer_rgb, dtype=np.float32)+ hsl = HSL_BLEND.get(blend)+ if hsl is not None:+ return np.asarray(hsl(in_rgb, layer_rgb), dtype=np.float32)+ fn = CHANNEL_BLEND.get(blend, CHANNEL_BLEND["normal"])+ return np.asarray(fn(in_rgb, layer_rgb), dtype=np.float32)+++def _composite_union(in_c, layer, comp, cov):+ in_a = in_c[..., 3]+ layer_a = layer[..., 3] * cov+ new_a = layer_a + (1 - layer_a) * in_a+ ratio = np.where(new_a != 0, layer_a / np.where(new_a != 0, new_a, 1), 0)+ blended = (+ ratio[..., None]+ * (in_a[..., None] * (comp - layer[..., :3]) + layer[..., :3] - in_c[..., :3])+ + in_c[..., :3]+ )+ keep = (layer_a == 0) | (new_a == 0)+ rgb = np.where(+ keep[..., None],+ in_c[..., :3],+ np.where((in_a == 0)[..., None], layer[..., :3], blended),+ )+ return np.concatenate([rgb, new_a[..., None]], axis=-1)+++def _composite_clip_to_backdrop(in_c, layer, comp, cov):+ in_a = in_c[..., 3]+ layer_a = layer[..., 3] * cov+ mixed = comp * layer_a[..., None] + in_c[..., :3] * (1 - layer_a[..., None])+ keep = (in_a == 0) | (layer_a == 0)+ rgb = np.where(keep[..., None], in_c[..., :3], mixed)+ return np.concatenate([rgb, in_a[..., None]], axis=-1)+++def _composite_clip_to_layer(in_c, layer, comp, cov):+ in_a = in_c[..., 3]+ layer_a = layer[..., 3] * cov+ mixed = comp * in_a[..., None] + layer[..., :3] * (1 - in_a[..., None])+ rgb = np.where(+ (layer_a == 0)[..., None],+ in_c[..., :3],+ np.where((in_a == 0)[..., None], layer[..., :3], mixed),+ )+ return np.concatenate([rgb, layer_a[..., None]], axis=-1)+++def _composite_intersection(in_c, layer, comp, cov):+ new_a = in_c[..., 3] * layer[..., 3] * cov+ rgb = np.where((new_a == 0)[..., None], in_c[..., :3], comp)+ return np.concatenate([rgb, new_a[..., None]], axis=-1)+++_COMPOSITE = {+ "union": _composite_union,+ "clip-to-backdrop": _composite_clip_to_backdrop,+ "clip-to-layer": _composite_clip_to_layer,+ "intersection": _composite_intersection,+}+++def run_composite(mode: str, in_c, layer, comp, cov) -> np.ndarray:+ fn = _COMPOSITE.get(mode, _composite_union)+ return fn(in_c, layer, comp, cov)+++def _to_space(rgb: np.ndarray, space: str) -> np.ndarray:+ return rgb if space == "linear" else linear_to_srgb(rgb)+++def _from_space(rgb: np.ndarray, space: str) -> np.ndarray:+ return rgb if space == "linear" else srgb_to_linear(rgb)+++class EffectiveMode(NamedTuple):+ blend: str+ blend_space: str+ composite: str+++_LAYER_MODES = {+ "normal": ("linear", "union"),+ "multiply": ("linear", "clip-to-backdrop"),+ "screen": ("perceptual", "clip-to-backdrop"),+ "overlay": ("perceptual", "clip-to-backdrop"),+ "darken": ("linear", "clip-to-backdrop"),+ "lighten": ("linear", "clip-to-backdrop"),+ "color-dodge": ("perceptual", "clip-to-backdrop"),+ "color-burn": ("perceptual", "clip-to-backdrop"),+ "hard-light": ("perceptual", "clip-to-backdrop"),+ "soft-light": ("perceptual", "clip-to-backdrop"),+ "difference": ("perceptual", "clip-to-backdrop"),+ "exclusion": ("perceptual", "clip-to-backdrop"),+ "linear-dodge": ("linear", "clip-to-backdrop"),+ "linear-burn": ("perceptual", "clip-to-backdrop"),+ "vivid-light": ("perceptual", "clip-to-backdrop"),+ "pin-light": ("perceptual", "clip-to-backdrop"),+ "linear-light": ("perceptual", "clip-to-backdrop"),+ "hard-mix": ("perceptual", "clip-to-backdrop"),+ "subtract": ("linear", "clip-to-backdrop"),+ "divide": ("linear", "clip-to-backdrop"),+ "grain-extract": ("perceptual", "clip-to-backdrop"),+ "grain-merge": ("perceptual", "clip-to-backdrop"),+ "hue": ("perceptual", "clip-to-backdrop"),+ "saturation": ("perceptual", "clip-to-backdrop"),+ "color": ("perceptual", "clip-to-backdrop"),+ "luminosity": ("linear", "clip-to-backdrop"),+}+++def resolve_mode(blend: str = "normal") -> EffectiveMode:+ blend_space, composite = _LAYER_MODES.get(blend, _LAYER_MODES["normal"])+ return EffectiveMode(+ blend=blend,+ blend_space=blend_space,+ composite=composite,+ )+++def blend_composite(+ mode: EffectiveMode,+ backdrop: np.ndarray,+ layer: np.ndarray,+ opacity: float,+ mask: Optional[ArrayLike] = None,+) -> np.ndarray:+ backdrop = np.asarray(backdrop, dtype=np.float32)+ layer = np.asarray(layer, dtype=np.float32)+ cov = opacity * (1.0 if mask is None else mask)++ in_b = _to_space(backdrop[..., :3], mode.blend_space)+ layer_b = _to_space(layer[..., :3], mode.blend_space)+ comp = _from_space(blend_pixel(mode.blend, in_b, layer_b), mode.blend_space)++ return run_composite(mode.composite, backdrop, layer, comp, cov)+++def placed_bounds(+ x: float, y: float, w: float, h: float, rotation: float+) -> tuple[int, int, int, int]:+ cx = x + w / 2+ cy = y + h / 2+ cos = math.cos(rotation)+ sin = math.sin(rotation)+ hw = w / 2+ hh = h / 2+ corners = ((-hw, -hh), (hw, -hh), (hw, hh), (-hw, hh))+ xs = [cx + dx * cos - dy * sin for dx, dy in corners]+ ys = [cy + dx * sin + dy * cos for dx, dy in corners]+ bx = math.floor(min(xs))+ by = math.floor(min(ys))+ bw = max(1, math.ceil(max(xs)) - bx)+ bh = max(1, math.ceil(max(ys)) - by)+ return bx, by, bw, bhdiff --git a/comfy_extras/nodes_compositor.py b/comfy_extras/nodes_compositor.pynew file mode 100644index 000000000..10cea3adc--- /dev/null+++ b/comfy_extras/nodes_compositor.py@@ -0,0 +1,852 @@+import hashlib+import json+import math++import numpy as np+import torch+from PIL import Image++from comfy_api.latest import ComfyExtension, io, UI+from comfy_extras.compositor_blend import (+ _LAYER_MODES,+ blend_composite,+ linear_to_srgb,+ placed_bounds,+ resolve_mode,+ srgb_to_linear,+)+from comfy_extras.color_util import hex_to_rgb+from comfy_extras.nodes_bounding_boxes import boxes_from_input+from nodes import MAX_RESOLUTION+from typing_extensions import override+++MAX_LAYERS = 50+++def document_items(doc) -> list[dict]:+ if not isinstance(doc, dict):+ return []+ version = doc.get("version")+ if version is not None and version != 1:+ raise ValueError(f"LAYERS document version {version!r} is not supported")+ items = []+ for item in doc.get("layers") or []:+ if not isinstance(item, dict):+ continue+ item_type = item.get("type", "raster")+ if item_type != "raster":+ raise ValueError(f"LAYERS item type {item_type!r} is not supported yet")+ if not isinstance(item.get("image"), torch.Tensor):+ continue+ blend = item.get("blend_mode")+ if blend is not None and blend not in _LAYER_MODES:+ raise ValueError(f"LAYERS item blend_mode {blend!r} is not a known blend mode")+ items.append(item)+ return sorted(items, key=lambda item: _int(item.get("z_index"), 0))+++def document_canvas(doc) -> tuple[int, int] | None:+ if not isinstance(doc, dict):+ return None+ canvas = doc.get("canvas")+ if not isinstance(canvas, (tuple, list)) or len(canvas) != 2:+ return None+ w, h = _int(canvas[0], 0), _int(canvas[1], 0)+ return (w, h) if w > 0 and h > 0 else None+++def _int(value, default: int) -> int:+ return int(value) if isinstance(value, (int, float)) and not isinstance(value, bool) else default+++def _bbox_list(bboxes, canvas_width: int, canvas_height: int) -> list[dict]:+ if bboxes is None:+ return []+ if isinstance(bboxes, str):+ text = bboxes.strip()+ if not text:+ return []+ try:+ bboxes = json.loads(text)+ except (json.JSONDecodeError, ValueError) as exc:+ raise ValueError(f"bboxes string input is not valid JSON: {exc}") from exc+ probe = bboxes if isinstance(bboxes, list) else [bboxes]+ if probe and isinstance(probe[0], list):+ probe = probe[0]+ has_elements = any(+ isinstance(box, dict) and isinstance(box.get("bbox"), (list, tuple))+ for box in probe+ )+ if has_elements and (canvas_width <= 0 or canvas_height <= 0):+ raise ValueError(+ "normalized element boxes need canvas_width and canvas_height to resolve to pixels"+ )+ return boxes_from_input(bboxes, canvas_width, canvas_height)+++def _item_mask_frame(mask, index: int) -> torch.Tensor | None:+ if not isinstance(mask, torch.Tensor):+ return None+ if mask.shape[0] == 1:+ return mask[:1]+ if index < mask.shape[0]:+ return mask[index : index + 1]+ return None+++def expand_item_frames(items: list[dict]) -> list[dict]:+ frames = []+ for item in items:+ image = item["image"]+ for index in range(image.shape[0]):+ width = _int(item.get("w"), 0)+ height = _int(item.get("h"), 0)+ rotation = item.get("rotation")+ frames.append({+ "tensor": image[index : index + 1],+ "mask": _item_mask_frame(item.get("mask"), index),+ "name": item.get("name") if isinstance(item.get("name"), str) else None,+ "x": _int(item.get("x"), 0),+ "y": _int(item.get("y"), 0),+ "w": width if width > 0 else int(image.shape[2]),+ "h": height if height > 0 else int(image.shape[1]),+ "rotation": float(rotation)+ if isinstance(rotation, (int, float)) and not isinstance(rotation, bool)+ else 0.0,+ "opacity": item.get("opacity", 1.0),+ "blend": item.get("blend_mode", "normal"),+ "visible": item.get("visible", True),+ "flip_h": bool(item.get("flip_h", False)),+ "flip_v": bool(item.get("flip_v", False)),+ })+ if len(frames) > MAX_LAYERS:+ raise ValueError(+ f"Compositor supports at most {MAX_LAYERS} layers, got {len(frames)}"+ )+ return frames+++def frame_alpha(+ tensor: torch.Tensor, mask: torch.Tensor | None+) -> torch.Tensor | None:+ alpha = tensor[:1, :, :, 3] if tensor.shape[-1] == 4 else None+ if mask is None:+ return alpha+ h, w = tensor.shape[1], tensor.shape[2]+ m = mask[:1].to(device=tensor.device, dtype=torch.float32)+ if m.shape[1] != h or m.shape[2] != w:+ m = torch.nn.functional.interpolate(+ m.unsqueeze(1), size=(h, w), mode="bilinear"+ ).squeeze(1)+ inv = torch.clamp(1.0 - m, 0.0, 1.0)+ return inv if alpha is None else alpha * inv+++def layer_preview_tensor(+ tensor: torch.Tensor, alpha: torch.Tensor | None+) -> torch.Tensor:+ rgb = tensor[:1, :, :, :3]+ if alpha is None:+ return rgb+ return torch.cat([rgb, alpha.unsqueeze(-1)], dim=-1)+++def canvas_extent(frames: list[dict]) -> tuple[int, int]:+ right = 1+ bottom = 1+ for frame in frames:+ bx, by, bw, bh = placed_bounds(+ frame["x"], frame["y"], frame["w"], frame["h"], frame["rotation"]+ )+ right = max(right, bx + bw)+ bottom = max(bottom, by + bh)+ return (right, bottom)+++def input_fingerprints(+ frames: list[dict], alphas: list[torch.Tensor | None]+) -> list[str]:+ fingerprints = []+ for frame, alpha in zip(frames, alphas):+ tensor = frame["tensor"]+ rgb = tensor[0, :, :, :3].detach().cpu().numpy()+ rgb8 = np.clip(np.rint(rgb * 255.0), 0, 255).astype(np.uint8)+ digest = hashlib.sha256()+ digest.update(repr(tuple(tensor.shape)).encode())+ digest.update(rgb8.tobytes())+ if alpha is not None:+ alpha8 = np.clip(+ np.rint(alpha[0].detach().cpu().numpy() * 255.0), 0, 255+ ).astype(np.uint8)+ digest.update(alpha8.tobytes())+ digest.update(+ repr((+ frame["x"],+ frame["y"],+ frame["w"],+ frame["h"],+ frame["rotation"],+ frame["opacity"],+ frame["blend"],+ bool(frame["visible"]),+ frame["flip_h"],+ frame["flip_v"],+ )).encode()+ )+ fingerprints.append(digest.hexdigest()[:16])+ return fingerprints+++def state_from_items(frames: list[dict], canvas: tuple[int, int]) -> dict:+ layers = []+ for frame in frames:+ layers.append({+ "name": frame["name"],+ "visible": bool(frame["visible"]),+ "opacity": frame["opacity"],+ "blend": frame["blend"],+ "flipH": frame["flip_h"],+ "flipV": frame["flip_v"],+ "transform": {+ "x": frame["x"],+ "y": frame["y"],+ "w": frame["w"],+ "h": frame["h"],+ "rotation": frame["rotation"],+ },+ })+ return {+ "canvas": canvas,+ "layers": layers,+ "inputs": None,+ "background": {"color": "#ffffff", "opacity": 1.0, "visible": False},+ }+++def layer_ui_entries(frames: list[dict]) -> list:+ entries = []+ for frame in frames:+ entries.append({+ "x": frame["x"],+ "y": frame["y"],+ "width": int(frame["w"]),+ "height": int(frame["h"]),+ "rotation": frame["rotation"],+ "name": frame["name"],+ "visible": bool(frame["visible"]),+ "opacity": frame["opacity"] if isinstance(frame["opacity"], (int, float)) else 1.0,+ "blend": frame["blend"] if isinstance(frame["blend"], str) else "normal",+ "flipH": frame["flip_h"],+ "flipV": frame["flip_v"],+ })+ return entries+++_HEX_DIGITS = set("0123456789abcdef")+++def _normalize_hex_color(value) -> str:+ if isinstance(value, str):+ text = value.strip().lower()+ if text.startswith("#"):+ digits = text[1:]+ if len(digits) == 3 and set(digits) <= _HEX_DIGITS:+ digits = "".join(ch * 2 for ch in digits)+ if len(digits) == 6 and set(digits) <= _HEX_DIGITS:+ return "#" + digits+ return "#ffffff"+++def _parse_background(entry) -> dict | None:+ if not isinstance(entry, dict):+ return None+ return {+ "color": _normalize_hex_color(entry.get("color")),+ "opacity": min(max(_number(entry, "opacity", 1.0), 0.0), 1.0),+ "visible": bool(entry.get("visible", True)),+ }+++def _parse_order(value, layer_count: int) -> list[int] | None:+ if not isinstance(value, list) or not value:+ return None+ if not all(+ isinstance(item, int) and not isinstance(item, bool) for item in value+ ):+ return None+ if sorted(value) != list(range(layer_count)):+ return None+ return value+++def layer_state_provided(raw) -> bool:+ if isinstance(raw, dict):+ return bool(raw)+ if isinstance(raw, str):+ return raw not in ("", "{}")+ return False+++def parse_layer_state(raw) -> dict | None:+ if isinstance(raw, str):+ if not raw.strip():+ return None+ try:+ raw = json.loads(raw)+ except (json.JSONDecodeError, ValueError):+ return None+ if not isinstance(raw, dict):+ return None+ state = raw+ version = state.get("version")+ if version is not None and version != 1:+ return None+ canvas = state.get("canvas")+ layers = state.get("layers")+ if not isinstance(canvas, dict) or not isinstance(layers, list) or not layers:+ return None+ try:+ w = int(round(float(canvas.get("w"))))+ h = int(round(float(canvas.get("h"))))+ except (TypeError, ValueError, OverflowError):+ return None+ if w <= 0 or h <= 0:+ return None+ inputs = state.get("inputs")+ if (+ not isinstance(inputs, list)+ or len(inputs) != len(layers)+ or not all(isinstance(entry, str) for entry in inputs)+ ):+ inputs = None+ return {+ "canvas": (w, h),+ "layers": layers,+ "inputs": inputs,+ "background": _parse_background(state.get("background")),+ "order": _parse_order(state.get("order"), len(layers)),+ }+++def _number(source: dict, key: str, default: float) -> float:+ value = source.get(key, default)+ if not isinstance(value, (int, float)) or not math.isfinite(value):+ return float(default)+ return float(value)+++def _clamped_size(value: float, natural: int) -> float:+ return float(natural) if value <= 0 else min(value, float(MAX_RESOLUTION))+++def _layer_params(entry, natural_w: int, natural_h: int) -> dict:+ if not isinstance(entry, dict):+ entry = {}+ transform = entry.get("transform")+ if not isinstance(transform, dict):+ transform = {}+ blend = entry.get("blend")+ return {+ "visible": bool(entry.get("visible", True)),+ # The layer state is untrusted input: it round-trips through the saved+ # workflow and can be posted directly to /prompt. An out-of-range opacity+ # would otherwise reach blend_composite as a raw coverage multiplier and+ # produce negative or greater-than-white RGB. _parse_background already+ # clamps the same field.+ "opacity": min(max(_number(entry, "opacity", 1.0), 0.0), 1.0),+ "blend": blend if isinstance(blend, str) else "normal",+ "x": min(max(_number(transform, "x", 0.0), -MAX_RESOLUTION), MAX_RESOLUTION),+ "y": min(max(_number(transform, "y", 0.0), -MAX_RESOLUTION), MAX_RESOLUTION),+ "w": _clamped_size(_number(transform, "w", natural_w), natural_w),+ "h": _clamped_size(_number(transform, "h", natural_h), natural_h),+ "rotation": _number(transform, "rotation", 0.0),+ "flip_h": bool(entry.get("flipH", False)),+ "flip_v": bool(entry.get("flipV", False)),+ }+++def _prepare_layer_bitmap(+ tensor: torch.Tensor, params: dict, alpha: torch.Tensor | None+) -> Image.Image:+ frame = tensor[0, :, :, :3].detach().cpu().numpy()+ rgb8 = np.clip(np.rint(frame * 255.0), 0, 255).astype(np.uint8)+ if alpha is None:+ img = Image.fromarray(rgb8, "RGB").convert("RGBA")+ else:+ alpha8 = np.clip(+ np.rint(alpha[0].detach().cpu().numpy() * 255.0), 0, 255+ ).astype(np.uint8)+ img = Image.fromarray(np.dstack([rgb8, alpha8]), "RGBA")+ if params["flip_h"]:+ img = img.transpose(Image.Transpose.FLIP_LEFT_RIGHT)+ if params["flip_v"]:+ img = img.transpose(Image.Transpose.FLIP_TOP_BOTTOM)+ target = (max(1, round(params["w"])), max(1, round(params["h"])))+ if img.size != target:+ img = img.resize(target, Image.Resampling.LANCZOS)+ if params["rotation"] != 0:+ img = img.rotate(+ -math.degrees(params["rotation"]),+ expand=True,+ resample=Image.Resampling.BICUBIC,+ fillcolor=(0, 0, 0, 0),+ )+ return img+++def _place_in_bounds(img: Image.Image, bw: int, bh: int) -> np.ndarray:+ arr = np.asarray(img, dtype=np.float32) / 255.0+ rgba = np.concatenate([srgb_to_linear(arr[..., :3]), arr[..., 3:4]], axis=-1)+ aw, ah = img.size+ buf = np.zeros((bh, bw, 4), dtype=np.float32)+ ox = (bw - aw) // 2+ oy = (bh - ah) // 2+ dx0, dy0 = max(ox, 0), max(oy, 0)+ dx1, dy1 = min(ox + aw, bw), min(oy + ah, bh)+ if dx0 < dx1 and dy0 < dy1:+ buf[dy0:dy1, dx0:dx1] = rgba[dy0 - oy : dy1 - oy, dx0 - ox : dx1 - ox]+ return buf+++def _fill_background(canvas: np.ndarray, background: dict) -> np.ndarray:+ layer = np.empty(canvas.shape, dtype=np.float32)+ layer[..., :3] = srgb_to_linear(+ np.array(hex_to_rgb(background["color"]), dtype=np.float32) / 255.0+ )+ layer[..., 3] = 1.0+ return blend_composite(+ resolve_mode("normal"), canvas, layer, background["opacity"]+ )+++def composite_from_state(+ tensors: list[torch.Tensor],+ state: dict,+ alphas: list[torch.Tensor | None],+) -> torch.Tensor:+ cw, ch = state["canvas"]+ if cw > MAX_RESOLUTION or ch > MAX_RESOLUTION:+ raise ValueError(+ f"Compositor canvas {cw}x{ch} exceeds the maximum supported size of "+ f"{MAX_RESOLUTION}x{MAX_RESOLUTION}"+ )+ canvas = np.zeros((ch, cw, 4), dtype=np.float32)+ background = state.get("background")+ if background is not None and background["visible"] and background["opacity"] > 0:+ canvas = _fill_background(canvas, background)+ layers = state["layers"]+ order = state.get("order") or range(len(tensors))+ for index in order:+ if index < 0 or index >= len(tensors):+ continue+ tensor = tensors[index]+ entry = layers[index] if index < len(layers) else None+ params = _layer_params(entry, tensor.shape[2], tensor.shape[1])+ if not params["visible"]:+ continue+ img = _prepare_layer_bitmap(+ tensor, params, alphas[index] if index < len(alphas) else None+ )+ bx, by, bw, bh = placed_bounds(+ params["x"], params["y"], params["w"], params["h"], params["rotation"]+ )+ buf = _place_in_bounds(img, bw, bh)+ x0, y0 = max(bx, 0), max(by, 0)+ x1, y1 = min(bx + bw, cw), min(by + bh, ch)+ if x0 >= x1 or y0 >= y1:+ continue+ region = buf[y0 - by : y1 - by, x0 - bx : x1 - bx]+ mode = resolve_mode(params["blend"])+ canvas[y0:y1, x0:x1] = blend_composite(+ mode, canvas[y0:y1, x0:x1], region, params["opacity"]+ )+ rgb = linear_to_srgb(np.clip(canvas[..., :3], 0.0, 1.0))+ alpha = np.clip(canvas[..., 3:4], 0.0, 1.0)+ rgba = np.concatenate([rgb, alpha], axis=-1)+ return torch.from_numpy(rgba.astype(np.float32)).unsqueeze(0)+++OPAQUE_EPSILON = 1e-3+++def composite_outputs(out: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:+ if out.shape[-1] != 4:+ return out, torch.zeros(out.shape[:3], dtype=torch.float32)+ alpha = out[..., 3]+ if bool((alpha >= 1.0 - OPAQUE_EPSILON).all()):+ return out[..., :3], torch.zeros_like(alpha)+ return out, torch.clamp(1.0 - alpha, 0.0, 1.0)+++class ImageCompositor(io.ComfyNode):+ @classmethod+ def define_schema(cls):+ return io.Schema(+ node_id="ImageCompositor",+ display_name="Create Layered Image",+ category="image",+ is_experimental=True,+ is_output_node=True,+ has_intermediate_output=True,+ inputs=[+ io.Layers.Input(+ "layers",+ tooltip="Layer stack to composite; build it with Add Layer. Items are stacked by z_index, batch frames inside an item expand to consecutive layers, and item placement, opacity, and blend mode define the initial composition. Without an explicit document canvas the size is a best-effort maximum extent of the placed layers. A saved composition that matches the current inputs takes priority.",+ ),+ io.Compositor.Input(+ "compositor",+ tooltip="Layered composition saved by the compositor editor.",+ ),+ ],+ outputs=[+ io.Image.Output(+ tooltip="Composited image. Carries an alpha channel when the composite has transparent areas (e.g. hidden background), otherwise plain RGB."+ ),+ io.Mask.Output(+ tooltip="Transparency of the composite (1 = fully transparent). All zeros when the composite is opaque."+ ),+ ],+ )++ @classmethod+ def execute(cls, layers: io.Layers.Type, compositor: io.Compositor.Type = None) -> io.NodeOutput:+ frames = expand_item_frames(document_items(layers))+ tensors = [frame["tensor"] for frame in frames]+ alphas = [frame_alpha(frame["tensor"], frame["mask"]) for frame in frames]++ layer_refs = []+ for tensor, alpha in zip(tensors, alphas):+ layer_refs.extend(+ UI.PreviewImage(layer_preview_tensor(tensor, alpha), cls=cls).values+ )++ fp = input_fingerprints(frames, alphas)+ raw_state = compositor+ state = parse_layer_state(raw_state)+ replay = bool(state is not None and tensors and state["inputs"] == fp)+ if replay:+ out = composite_from_state(tensors, state, alphas)+ elif tensors:+ canvas = document_canvas(layers) or canvas_extent(frames)+ out = composite_from_state(+ tensors, state_from_items(frames, canvas), alphas+ )+ else:+ out = torch.zeros((1, 64, 64, 3), dtype=torch.float32)+ state_stale = layer_state_provided(raw_state) and not replay+ out, mask = composite_outputs(out)++ ui_dict = UI.PreviewImage(out, cls=cls).as_dict()+ ui_dict["compositor_layers"] = layer_refs+ ui_dict["compositor_inputs"] = fp+ ui_dict["compositor_bboxes"] = layer_ui_entries(frames)+ if state_stale:+ ui_dict["compositor_state_stale"] = [True]+ return io.NodeOutput(out, mask, ui=ui_dict)+++class AddLayer(io.ComfyNode):+ @classmethod+ def define_schema(cls):+ return io.Schema(+ node_id="AddLayer",+ display_name="Add Layer",+ category="image",+ is_experimental=True,+ inputs=[+ io.Layers.Input(+ "layers",+ optional=True,+ tooltip="Layer stack to append to. Leave unconnected to start a new stack.",+ ),+ io.Image.Input(+ "image",+ tooltip="Layer content at its native size. A batch expands to consecutive layers.",+ ),+ io.Mask.Input(+ "mask",+ optional=True,+ tooltip="Transparency mask for this layer. Masked areas (value 1) become transparent, multiplying with any alpha channel the image already carries.",+ ),+ io.String.Input(+ "name",+ optional=True,+ default="",+ tooltip="Layer name shown in the compositor editor.",+ ),+ io.Int.Input(+ "x",+ optional=True,+ default=0,+ min=-MAX_RESOLUTION,+ max=MAX_RESOLUTION,+ tooltip="Initial horizontal placement on the canvas.",+ ),+ io.Int.Input(+ "y",+ optional=True,+ default=0,+ min=-MAX_RESOLUTION,+ max=MAX_RESOLUTION,+ tooltip="Initial vertical placement on the canvas.",+ ),+ io.Float.Input(+ "opacity",+ optional=True,+ default=1.0,+ min=0.0,+ max=1.0,+ step=0.01,+ tooltip="Initial layer opacity.",+ ),+ io.Combo.Input(+ "blend_mode",+ options=list(_LAYER_MODES),+ default="normal",+ optional=True,+ tooltip="Initial blend mode.",+ ),+ io.Float.Input(+ "rotation",+ optional=True,+ default=0.0,+ min=-360.0,+ max=360.0,+ step=1.0,+ tooltip="Initial rotation in degrees, clockwise.",+ ),+ io.Int.Input(+ "width",+ optional=True,+ default=0,+ min=0,+ max=MAX_RESOLUTION,+ tooltip="Initial display width. 0 keeps the image's native width.",+ ),+ io.Int.Input(+ "height",+ optional=True,+ default=0,+ min=0,+ max=MAX_RESOLUTION,+ tooltip="Initial display height. 0 keeps the image's native height.",+ ),+ io.Int.Input(+ "z_index",+ optional=True,+ default=0,+ min=-1000,+ max=1000,+ tooltip="Stacking override. Layers are stable-sorted by z_index; equal values keep their list order.",+ ),+ io.Boolean.Input(+ "flip_h",+ optional=True,+ default=False,+ tooltip="Flip the layer horizontally.",+ ),+ io.Boolean.Input(+ "flip_v",+ optional=True,+ default=False,+ tooltip="Flip the layer vertically.",+ ),+ ],+ outputs=[+ io.Layers.Output(tooltip="The layer stack with this layer appended."),+ ],+ )++ @classmethod+ def execute(cls, image: io.Image.Type, layers: io.Layers.Type = None, mask: io.Mask.Type = None, name: str = "", x: int = 0, y: int = 0, opacity: float = 1.0, blend_mode: str = "normal", rotation: float = 0.0, width: int = 0, height: int = 0, z_index: int = 0, flip_h: bool = False, flip_v: bool = False) -> io.NodeOutput:+ item: dict = {+ "image": image,+ "type": "raster",+ "x": int(x),+ "y": int(y),+ "z_index": int(z_index),+ }+ if mask is not None:+ item["mask"] = mask+ if name:+ item["name"] = name+ if opacity != 1.0:+ item["opacity"] = float(opacity)+ if blend_mode != "normal":+ item["blend_mode"] = blend_mode+ if rotation != 0.0:+ item["rotation"] = math.radians(rotation)+ if width > 0:+ item["w"] = int(width)+ if height > 0:+ item["h"] = int(height)+ if flip_h:+ item["flip_h"] = True+ if flip_v:+ item["flip_v"] = True+ previous = layers if isinstance(layers, dict) else None+ document: dict = {+ "version": 1,+ "layers": [*(previous.get("layers") or []), item] if previous else [item],+ }+ previous_canvas = document_canvas(previous)+ if previous_canvas:+ document["canvas"] = previous_canvas+ return io.NodeOutput(document)+++class LayersFromBoundingBoxes(io.ComfyNode):+ @classmethod+ def define_schema(cls):+ return io.Schema(+ node_id="LayersFromBoundingBoxes",+ display_name="Layers From Bounding Boxes",+ category="image",+ is_experimental=True,+ description=(+ "Turn an image batch plus its bounding boxes into a layer stack, one layer per frame, "+ "each placed by its own box. Use this when a node emits layers as a batch - a batch "+ "carries a single placement for every frame, so the individual positions are otherwise lost."+ ),+ inputs=[+ io.Image.Input(+ "image",+ tooltip="Image batch; each frame becomes one layer.",+ ),+ io.MultiType.Input(+ "bboxes",+ [io.BoundingBox, io.Array, io.String],+ tooltip=(+ "Placement boxes, index-aligned with the image batch. Accepts bounding boxes "+ "(x, y, width, height), normalized elements (with a 'bbox' - these need "+ "canvas_width/canvas_height to resolve to pixels), or a JSON string of either. "+ "Frames without a matching box are placed at the origin. A box's width/height "+ "scales the layer to fit it. metadata.name (or desc) and metadata.z_index are "+ "used when present, and metadata.content_rect (frame-relative) crops the frame "+ "to its real content."+ ),+ ),+ io.Mask.Input(+ "mask",+ optional=True,+ tooltip=(+ "Per-frame transparency, index-aligned with the image batch "+ "(1 = transparent, LoadImage convention)."+ ),+ ),+ io.Layers.Input(+ "layers",+ optional=True,+ tooltip="Layer stack to append to. Leave unconnected to start a new stack.",+ ),+ io.Boolean.Input(+ "crop_to_content",+ default=True,+ optional=True,+ tooltip=(+ "Crop each frame to metadata.content_rect where present and place the content "+ "at the box position plus the rect offset. Leave on for batches whose frames "+ "are padded - it keeps only the real content at its true spot."+ ),+ ),+ io.Int.Input(+ "canvas_width",+ default=0,+ min=0,+ max=MAX_RESOLUTION,+ optional=True,+ tooltip="Document canvas width. 0 derives it from the placed layers.",+ ),+ io.Int.Input(+ "canvas_height",+ default=0,+ min=0,+ max=MAX_RESOLUTION,+ optional=True,+ tooltip="Document canvas height. 0 derives it from the placed layers.",+ ),+ ],+ outputs=[+ io.Layers.Output(tooltip="The layer stack, ready for Create Layered Image."),+ ],+ )++ @classmethod+ def execute(+ cls,+ image: io.Image.Type,+ bboxes: io.MultiType.Type,+ mask: io.Mask.Type = None,+ layers: io.Layers.Type = None,+ crop_to_content: bool = True,+ canvas_width: int = 0,+ canvas_height: int = 0,+ ) -> io.NodeOutput:+ boxes = _bbox_list(bboxes, canvas_width, canvas_height)+ previous = layers if isinstance(layers, dict) else None+ items: list[dict] = list((previous.get("layers") or []) if previous else [])+ base_z = max((_int(i.get("z_index"), 0) for i in items), default=-1) + 1++ for index in range(image.shape[0]):+ box = boxes[index] if index < len(boxes) else {}+ meta = box.get("metadata") if isinstance(box.get("metadata"), dict) else {}+ frame = image[index : index + 1]+ frame_mask = _item_mask_frame(mask, index)++ x, y = _int(box.get("x"), 0), _int(box.get("y"), 0)+ box_w, box_h = _int(box.get("width"), 0), _int(box.get("height"), 0)+ cropped = False+ rect = meta.get("content_rect")+ if crop_to_content and isinstance(rect, (list, tuple)) and len(rect) == 4:+ left, top, cw, ch = (_int(v, 0) for v in rect)+ left = min(max(left, 0), int(frame.shape[2]))+ top = min(max(top, 0), int(frame.shape[1]))+ cw = min(max(cw, 0), int(frame.shape[2]) - left)+ ch = min(max(ch, 0), int(frame.shape[1]) - top)+ if cw > 0 and ch > 0:+ frame = frame[:, top : top + ch, left : left + cw]+ if frame_mask is not None:+ frame_mask = frame_mask[:, top : top + ch, left : left + cw]+ x, y = x + left, y + top+ cropped = True++ item: dict = {+ "image": frame,+ "type": "raster",+ "x": x,+ "y": y,+ "z_index": _int(meta.get("z_index"), base_z + index),+ }+ if not cropped:+ if box_w > 0:+ item["w"] = box_w+ if box_h > 0:+ item["h"] = box_h+ if frame_mask is not None:+ item["mask"] = frame_mask+ name = meta.get("name")+ if not (isinstance(name, str) and name):+ name = meta.get("desc")+ if isinstance(name, str) and name:+ item["name"] = name+ items.append(item)++ document: dict = {"version": 1, "layers": items}+ if canvas_width > 0 and canvas_height > 0:+ document["canvas"] = (canvas_width, canvas_height)+ else:+ inherited = document_canvas(previous)+ if inherited:+ document["canvas"] = inherited+ return io.NodeOutput(document)+++class CompositorExtension(ComfyExtension):+ @override+ async def get_node_list(self) -> list[type[io.ComfyNode]]:+ return [ImageCompositor, AddLayer, LayersFromBoundingBoxes]+++async def comfy_entrypoint() -> CompositorExtension:+ return CompositorExtension()diff --git a/nodes.py b/nodes.pyindex 08529d8dc..432f04d89 100644--- a/nodes.py+++ b/nodes.py@@ -2501,6 +2501,7 @@ async def init_builtin_extra_nodes():"nodes_math.py","nodes_number_convert.py","nodes_painter.py",+ "nodes_compositor.py","nodes_curve.py","nodes_bg_removal.py","nodes_rtdetr.py",diff --git a/tests-unit/comfy_extras_test/compositor_blend_fixture_gen.py b/tests-unit/comfy_extras_test/compositor_blend_fixture_gen.pynew file mode 100644index 000000000..ea7a110e4--- /dev/null+++ b/tests-unit/comfy_extras_test/compositor_blend_fixture_gen.py@@ -0,0 +1,111 @@+"""Regenerate ``compositor_blend_golden.json``.++The golden file is the *shared contract* for layer blending. Every+implementation of these 26 modes must reproduce it within ``tolerance``:++* ``comfy_extras/compositor_blend.py`` - numpy, server-side compositing+* ``layerBlend.frag`` - GLSL, the live preview in the layer editor+* any future CPU reference in the frontend++Run from the repository root::++ python tests-unit/comfy_extras_test/compositor_blend_fixture_gen.py++and review the diff. A change to this file is a change to user-visible+blending behaviour in every implementation, so it should never be+regenerated just to make a test pass.+"""++import json+import os+import sys++import numpy as np++sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))++from comfy_extras.compositor_blend import CHANNEL_BLEND, HSL_BLEND, blend_pixel # noqa: E402++GOLDEN_PATH = os.path.join(os.path.dirname(__file__), "compositor_blend_golden.json")++# Scalar grid for the per-channel modes: both endpoints, the midpoint, values+# just inside each endpoint, and values inside the 1e-6 epsilon guards.+SCALARS = [0.0, 1e-7, 0.001, 0.25, 0.5, 0.75, 0.999, 1.0 - 1e-7, 1.0]++# Colour pairs for the HSL modes, which read all three channels at once.+COLORS = [+ [0.0, 0.0, 0.0],+ [1.0, 1.0, 1.0],+ [0.5, 0.5, 0.5],+ [1.0, 0.0, 0.0],+ [0.0, 0.0, 1.0],+ [0.2, 0.4, 0.6],+ [0.9, 0.1, 0.35],+ [1e-7, 1e-7, 1e-7],+ [1e-7, 0.0, 0.0],+ [0.05, 0.05, 0.05],+]+++def _round(value) -> float:+ return round(float(value), 7)+++def build() -> dict:+ channel = {}+ for mode in CHANNEL_BLEND:+ rows = []+ for i in SCALARS:+ for l in SCALARS:+ out = blend_pixel(mode, np.float32([i] * 3), np.float32([l] * 3))+ rows.append([_round(i), _round(l), _round(np.asarray(out).reshape(3)[0])])+ channel[mode] = rows+ hsl = {}+ for mode in HSL_BLEND:+ rows = []+ for i in COLORS:+ for l in COLORS:+ out = blend_pixel(mode, np.float32(i), np.float32(l))+ rows.append([+ [_round(v) for v in i],+ [_round(v) for v in l],+ [_round(v) for v in np.asarray(out).reshape(3)],+ ])+ hsl[mode] = rows+ return {+ "_comment": (+ "Golden blend values shared by comfy_extras/compositor_blend.py and "+ "layerBlend.frag. Inputs are unpremultiplied colours already in the "+ "blend space; outputs are unclamped (the compositor clamps once, at "+ "the end). 'channel' rows are [i, l, out] applied per channel; 'hsl' "+ "rows are [rgb_backdrop, rgb_layer, rgb_out]. Regenerate with "+ "tests-unit/comfy_extras_test/compositor_blend_fixture_gen.py."+ ),+ "tolerance": 1e-4,+ "channel": channel,+ "hsl": hsl,+ }+++def dumps(data: dict) -> str:+ """One row per line, so a behaviour change shows up as a readable diff."""+ lines = ["{", f' "_comment": {json.dumps(data["_comment"])},', f' "tolerance": {data["tolerance"]},']+ for section in ("channel", "hsl"):+ lines.append(f' "{section}": {{')+ modes = sorted(data[section])+ for m_index, mode in enumerate(modes):+ lines.append(f' "{mode}": [')+ rows = data[section][mode]+ for r_index, row in enumerate(rows):+ comma = "" if r_index == len(rows) - 1 else ","+ lines.append(f" {json.dumps(row)}{comma}")+ lines.append(" ]" + ("" if m_index == len(modes) - 1 else ","))+ lines.append(" }" + ("," if section == "channel" else ""))+ lines.append("}")+ return "\n".join(lines) + "\n"+++if __name__ == "__main__":+ with open(GOLDEN_PATH, "w") as handle:+ handle.write(dumps(build()))+ sys.stdout.write(f"wrote {GOLDEN_PATH}\n")diff --git a/tests-unit/comfy_extras_test/compositor_blend_golden.json b/tests-unit/comfy_extras_test/compositor_blend_golden.jsonnew file mode 100644index 000000000..65a06ead7--- /dev/null+++ b/tests-unit/comfy_extras_test/compositor_blend_golden.json@@ -0,0 +1,2242 @@+{+ "_comment": "Golden blend values shared by comfy_extras/compositor_blend.py and layerBlend.frag. Inputs are unpremultiplied colours already in the blend space; outputs are unclamped (the compositor clamps once, at the end). 'channel' rows are [i, l, out] applied per channel; 'hsl' rows are [rgb_backdrop, rgb_layer, rgb_out]. Regenerate with tests-unit/comfy_extras_test/compositor_blend_fixture_gen.py.",+ "tolerance": 0.0001,+ "channel": {+ "color-burn": [+ [0.0, 0.0, 0.0],+ [0.0, 1e-07, 0.0],+ [0.0, 0.001, 0.0],+ [0.0, 0.25, 0.0],+ [0.0, 0.5, 0.0],+ [0.0, 0.75, 0.0],+ [0.0, 0.999, 0.0],+ [0.0, 0.9999999, 0.0],+ [0.0, 1.0, 0.0],+ [1e-07, 0.0, 0.0],+ [1e-07, 1e-07, 0.0],+ [1e-07, 0.001, 0.0],+ [1e-07, 0.25, 0.0],+ [1e-07, 0.5, 0.0],+ [1e-07, 0.75, 0.0],+ [1e-07, 0.999, 0.0],+ [1e-07, 0.9999999, 0.0],+ [1e-07, 1.0, 1e-07],+ [0.001, 0.0, 0.0],+ [0.001, 1e-07, 0.0],+ [0.001, 0.001, 0.0],+ [0.001, 0.25, 0.0],+ [0.001, 0.5, 0.0],+ [0.001, 0.75, 0.0],+ [0.001, 0.999, 0.0],+ [0.001, 0.9999999, 0.0009999],+ [0.001, 1.0, 0.001],+ [0.25, 0.0, 0.0],+ [0.25, 1e-07, 0.0],+ [0.25, 0.001, 0.0],+ [0.25, 0.25, 0.0],+ [0.25, 0.5, 0.0],+ [0.25, 0.75, 0.0],+ [0.25, 0.999, 0.2492493],+ [0.25, 0.9999999, 0.2499999],+ [0.25, 1.0, 0.25],+ [0.5, 0.0, 0.0],+ [0.5, 1e-07, 0.0],+ [0.5, 0.001, 0.0],+ [0.5, 0.25, 0.0],+ [0.5, 0.5, 0.0],+ [0.5, 0.75, 0.3333333],+ [0.5, 0.999, 0.4994995],+ [0.5, 0.9999999, 0.4999999],+ [0.5, 1.0, 0.5],+ [0.75, 0.0, 0.0],+ [0.75, 1e-07, 0.0],+ [0.75, 0.001, 0.0],+ [0.75, 0.25, 0.0],+ [0.75, 0.5, 0.5],+ [0.75, 0.75, 0.6666666],+ [0.75, 0.999, 0.7497498],+ [0.75, 0.9999999, 0.75],+ [0.75, 1.0, 0.75],+ [0.999, 0.0, 0.0],+ [0.999, 1e-07, 0.0],+ [0.999, 0.001, 1.29e-05],+ [0.999, 0.25, 0.9960001],+ [0.999, 0.5, 0.998],+ [0.999, 0.75, 0.9986667],+ [0.999, 0.999, 0.998999],+ [0.999, 0.9999999, 0.999],+ [0.999, 1.0, 0.999],+ [0.9999999, 0.0, 0.0],+ [0.9999999, 1e-07, 0.0],+ [0.9999999, 0.001, 0.9998808],+ [0.9999999, 0.25, 0.9999995],+ [0.9999999, 0.5, 0.9999998],+ [0.9999999, 0.75, 0.9999998],+ [0.9999999, 0.999, 0.9999999],+ [0.9999999, 0.9999999, 0.9999999],+ [0.9999999, 1.0, 0.9999999],+ [1.0, 0.0, 1.0],+ [1.0, 1e-07, 1.0],+ [1.0, 0.001, 1.0],+ [1.0, 0.25, 1.0],+ [1.0, 0.5, 1.0],+ [1.0, 0.75, 1.0],+ [1.0, 0.999, 1.0],+ [1.0, 0.9999999, 1.0],+ [1.0, 1.0, 1.0]+ ],+ "color-dodge": [+ [0.0, 0.0, 0.0],+ [0.0, 1e-07, 0.0],+ [0.0, 0.001, 0.0],+ [0.0, 0.25, 0.0],+ [0.0, 0.5, 0.0],+ [0.0, 0.75, 0.0],+ [0.0, 0.999, 0.0],+ [0.0, 0.9999999, 0.0],+ [0.0, 1.0, 0.0],+ [1e-07, 0.0, 1e-07],+ [1e-07, 1e-07, 1e-07],+ [1e-07, 0.001, 1e-07],+ [1e-07, 0.25, 1e-07],+ [1e-07, 0.5, 2e-07],+ [1e-07, 0.75, 4e-07],+ [1e-07, 0.999, 0.0001],+ [1e-07, 0.9999999, 1.0],+ [1e-07, 1.0, 1.0],+ [0.001, 0.0, 0.001],+ [0.001, 1e-07, 0.001],+ [0.001, 0.001, 0.001001],+ [0.001, 0.25, 0.0013333],+ [0.001, 0.5, 0.002],+ [0.001, 0.75, 0.004],+ [0.001, 0.999, 1.0],+ [0.001, 0.9999999, 1.0],+ [0.001, 1.0, 1.0],+ [0.25, 0.0, 0.25],+ [0.25, 1e-07, 0.25],+ [0.25, 0.001, 0.2502503],+ [0.25, 0.25, 0.3333333],+ [0.25, 0.5, 0.5],+ [0.25, 0.75, 1.0],+ [0.25, 0.999, 1.0],+ [0.25, 0.9999999, 1.0],+ [0.25, 1.0, 1.0],+ [0.5, 0.0, 0.5],+ [0.5, 1e-07, 0.5000001],+ [0.5, 0.001, 0.5005005],+ [0.5, 0.25, 0.6666667],+ [0.5, 0.5, 1.0],+ [0.5, 0.75, 1.0],+ [0.5, 0.999, 1.0],+ [0.5, 0.9999999, 1.0],+ [0.5, 1.0, 1.0],+ [0.75, 0.0, 0.75],+ [0.75, 1e-07, 0.7500001],+ [0.75, 0.001, 0.7507507],+ [0.75, 0.25, 1.0],+ [0.75, 0.5, 1.0],+ [0.75, 0.75, 1.0],+ [0.75, 0.999, 1.0],+ [0.75, 0.9999999, 1.0],+ [0.75, 1.0, 1.0],+ [0.999, 0.0, 0.999],+ [0.999, 1e-07, 0.9990001],+ [0.999, 0.001, 1.0],+ [0.999, 0.25, 1.0],+ [0.999, 0.5, 1.0],+ [0.999, 0.75, 1.0],+ [0.999, 0.999, 1.0],+ [0.999, 0.9999999, 1.0],+ [0.999, 1.0, 1.0],+ [0.9999999, 0.0, 0.9999999],+ [0.9999999, 1e-07, 1.0],+ [0.9999999, 0.001, 1.0],+ [0.9999999, 0.25, 1.0],+ [0.9999999, 0.5, 1.0],+ [0.9999999, 0.75, 1.0],+ [0.9999999, 0.999, 1.0],+ [0.9999999, 0.9999999, 1.0],+ [0.9999999, 1.0, 1.0],+ [1.0, 0.0, 1.0],+ [1.0, 1e-07, 1.0],+ [1.0, 0.001, 1.0],+ [1.0, 0.25, 1.0],+ [1.0, 0.5, 1.0],+ [1.0, 0.75, 1.0],+ [1.0, 0.999, 1.0],+ [1.0, 0.9999999, 1.0],+ [1.0, 1.0, 1.0]+ ],+ "darken": [+ [0.0, 0.0, 0.0],+ [0.0, 1e-07, 0.0],+ [0.0, 0.001, 0.0],+ [0.0, 0.25, 0.0],+ [0.0, 0.5, 0.0],+ [0.0, 0.75, 0.0],+ [0.0, 0.999, 0.0],+ [0.0, 0.9999999, 0.0],+ [0.0, 1.0, 0.0],+ [1e-07, 0.0, 0.0],+ [1e-07, 1e-07, 1e-07],+ [1e-07, 0.001, 1e-07],+ [1e-07, 0.25, 1e-07],+ [1e-07, 0.5, 1e-07],+ [1e-07, 0.75, 1e-07],+ [1e-07, 0.999, 1e-07],+ [1e-07, 0.9999999, 1e-07],+ [1e-07, 1.0, 1e-07],+ [0.001, 0.0, 0.0],+ [0.001, 1e-07, 1e-07],+ [0.001, 0.001, 0.001],+ [0.001, 0.25, 0.001],+ [0.001, 0.5, 0.001],+ [0.001, 0.75, 0.001],+ [0.001, 0.999, 0.001],+ [0.001, 0.9999999, 0.001],+ [0.001, 1.0, 0.001],+ [0.25, 0.0, 0.0],+ [0.25, 1e-07, 1e-07],+ [0.25, 0.001, 0.001],+ [0.25, 0.25, 0.25],+ [0.25, 0.5, 0.25],+ [0.25, 0.75, 0.25],+ [0.25, 0.999, 0.25],+ [0.25, 0.9999999, 0.25],+ [0.25, 1.0, 0.25],+ [0.5, 0.0, 0.0],+ [0.5, 1e-07, 1e-07],+ [0.5, 0.001, 0.001],+ [0.5, 0.25, 0.25],+ [0.5, 0.5, 0.5],+ [0.5, 0.75, 0.5],+ [0.5, 0.999, 0.5],+ [0.5, 0.9999999, 0.5],+ [0.5, 1.0, 0.5],+ [0.75, 0.0, 0.0],+ [0.75, 1e-07, 1e-07],+ [0.75, 0.001, 0.001],+ [0.75, 0.25, 0.25],+ [0.75, 0.5, 0.5],+ [0.75, 0.75, 0.75],+ [0.75, 0.999, 0.75],+ [0.75, 0.9999999, 0.75],+ [0.75, 1.0, 0.75],+ [0.999, 0.0, 0.0],+ [0.999, 1e-07, 1e-07],+ [0.999, 0.001, 0.001],+ [0.999, 0.25, 0.25],+ [0.999, 0.5, 0.5],+ [0.999, 0.75, 0.75],+ [0.999, 0.999, 0.999],+ [0.999, 0.9999999, 0.999],+ [0.999, 1.0, 0.999],+ [0.9999999, 0.0, 0.0],+ [0.9999999, 1e-07, 1e-07],+ [0.9999999, 0.001, 0.001],+ [0.9999999, 0.25, 0.25],+ [0.9999999, 0.5, 0.5],+ [0.9999999, 0.75, 0.75],+ [0.9999999, 0.999, 0.999],+ [0.9999999, 0.9999999, 0.9999999],+ [0.9999999, 1.0, 0.9999999],+ [1.0, 0.0, 0.0],+ [1.0, 1e-07, 1e-07],+ [1.0, 0.001, 0.001],+ [1.0, 0.25, 0.25],+ [1.0, 0.5, 0.5],+ [1.0, 0.75, 0.75],+ [1.0, 0.999, 0.999],+ [1.0, 0.9999999, 0.9999999],+ [1.0, 1.0, 1.0]+ ],+ "difference": [+ [0.0, 0.0, 0.0],+ [0.0, 1e-07, 1e-07],+ [0.0, 0.001, 0.001],+ [0.0, 0.25, 0.25],+ [0.0, 0.5, 0.5],+ [0.0, 0.75, 0.75],+ [0.0, 0.999, 0.999],+ [0.0, 0.9999999, 0.9999999],+ [0.0, 1.0, 1.0],+ [1e-07, 0.0, 1e-07],+ [1e-07, 1e-07, 0.0],+ [1e-07, 0.001, 0.0009999],+ [1e-07, 0.25, 0.2499999],+ [1e-07, 0.5, 0.4999999],+ [1e-07, 0.75, 0.7499999],+ [1e-07, 0.999, 0.9989999],+ [1e-07, 0.9999999, 0.9999998],+ [1e-07, 1.0, 0.9999999],+ [0.001, 0.0, 0.001],+ [0.001, 1e-07, 0.0009999],+ [0.001, 0.001, 0.0],+ [0.001, 0.25, 0.249],+ [0.001, 0.5, 0.499],+ [0.001, 0.75, 0.749],+ [0.001, 0.999, 0.998],+ [0.001, 0.9999999, 0.9989999],+ [0.001, 1.0, 0.999],+ [0.25, 0.0, 0.25],+ [0.25, 1e-07, 0.2499999],+ [0.25, 0.001, 0.249],+ [0.25, 0.25, 0.0],+ [0.25, 0.5, 0.25],+ [0.25, 0.75, 0.5],+ [0.25, 0.999, 0.749],+ [0.25, 0.9999999, 0.7499999],+ [0.25, 1.0, 0.75],+ [0.5, 0.0, 0.5],+ [0.5, 1e-07, 0.4999999],+ [0.5, 0.001, 0.499],+ [0.5, 0.25, 0.25],+ [0.5, 0.5, 0.0],+ [0.5, 0.75, 0.25],+ [0.5, 0.999, 0.499],+ [0.5, 0.9999999, 0.4999999],+ [0.5, 1.0, 0.5],+ [0.75, 0.0, 0.75],+ [0.75, 1e-07, 0.7499999],+ [0.75, 0.001, 0.749],+ [0.75, 0.25, 0.5],+ [0.75, 0.5, 0.25],+ [0.75, 0.75, 0.0],+ [0.75, 0.999, 0.249],+ [0.75, 0.9999999, 0.2499999],+ [0.75, 1.0, 0.25],+ [0.999, 0.0, 0.999],+ [0.999, 1e-07, 0.9989999],+ [0.999, 0.001, 0.998],+ [0.999, 0.25, 0.749],+ [0.999, 0.5, 0.499],+ [0.999, 0.75, 0.249],+ [0.999, 0.999, 0.0],+ [0.999, 0.9999999, 0.0009999],+ [0.999, 1.0, 0.001],+ [0.9999999, 0.0, 0.9999999],+ [0.9999999, 1e-07, 0.9999998],+ [0.9999999, 0.001, 0.9989999],+ [0.9999999, 0.25, 0.7499999],+ [0.9999999, 0.5, 0.4999999],+ [0.9999999, 0.75, 0.2499999],+ [0.9999999, 0.999, 0.0009999],+ [0.9999999, 0.9999999, 0.0],+ [0.9999999, 1.0, 1e-07],+ [1.0, 0.0, 1.0],+ [1.0, 1e-07, 0.9999999],+ [1.0, 0.001, 0.999],+ [1.0, 0.25, 0.75],+ [1.0, 0.5, 0.5],+ [1.0, 0.75, 0.25],+ [1.0, 0.999, 0.001],+ [1.0, 0.9999999, 1e-07],+ [1.0, 1.0, 0.0]+ ],+ "divide": [+ [0.0, 0.0, 0.0],+ [0.0, 1e-07, 0.0],+ [0.0, 0.001, 0.0],+ [0.0, 0.25, 0.0],+ [0.0, 0.5, 0.0],+ [0.0, 0.75, 0.0],+ [0.0, 0.999, 0.0],+ [0.0, 0.9999999, 0.0],+ [0.0, 1.0, 0.0],+ [1e-07, 0.0, 0.1],+ [1e-07, 1e-07, 0.1],+ [1e-07, 0.001, 0.0001],+ [1e-07, 0.25, 4e-07],+ [1e-07, 0.5, 2e-07],+ [1e-07, 0.75, 1e-07],+ [1e-07, 0.999, 1e-07],+ [1e-07, 0.9999999, 1e-07],+ [1e-07, 1.0, 1e-07],+ [0.001, 0.0, 1.0],+ [0.001, 1e-07, 1.0],+ [0.001, 0.001, 1.0],+ [0.001, 0.25, 0.004],+ [0.001, 0.5, 0.002],+ [0.001, 0.75, 0.0013333],+ [0.001, 0.999, 0.001001],+ [0.001, 0.9999999, 0.001],+ [0.001, 1.0, 0.001],+ [0.25, 0.0, 1.0],+ [0.25, 1e-07, 1.0],+ [0.25, 0.001, 1.0],+ [0.25, 0.25, 1.0],+ [0.25, 0.5, 0.5],+ [0.25, 0.75, 0.3333333],+ [0.25, 0.999, 0.2502503],+ [0.25, 0.9999999, 0.25],+ [0.25, 1.0, 0.25],+ [0.5, 0.0, 1.0],+ [0.5, 1e-07, 1.0],+ [0.5, 0.001, 1.0],+ [0.5, 0.25, 1.0],+ [0.5, 0.5, 1.0],+ [0.5, 0.75, 0.6666667],+ [0.5, 0.999, 0.5005005],+ [0.5, 0.9999999, 0.5000001],+ [0.5, 1.0, 0.5],+ [0.75, 0.0, 1.0],+ [0.75, 1e-07, 1.0],+ [0.75, 0.001, 1.0],+ [0.75, 0.25, 1.0],+ [0.75, 0.5, 1.0],+ [0.75, 0.75, 1.0],+ [0.75, 0.999, 0.7507507],+ [0.75, 0.9999999, 0.7500001],+ [0.75, 1.0, 0.75],+ [0.999, 0.0, 1.0],+ [0.999, 1e-07, 1.0],+ [0.999, 0.001, 1.0],+ [0.999, 0.25, 1.0],+ [0.999, 0.5, 1.0],+ [0.999, 0.75, 1.0],+ [0.999, 0.999, 1.0],+ [0.999, 0.9999999, 0.9990001],+ [0.999, 1.0, 0.999],+ [0.9999999, 0.0, 1.0],+ [0.9999999, 1e-07, 1.0],+ [0.9999999, 0.001, 1.0],+ [0.9999999, 0.25, 1.0],+ [0.9999999, 0.5, 1.0],+ [0.9999999, 0.75, 1.0],+ [0.9999999, 0.999, 1.0],+ [0.9999999, 0.9999999, 1.0],+ [0.9999999, 1.0, 0.9999999],+ [1.0, 0.0, 1.0],+ [1.0, 1e-07, 1.0],+ [1.0, 0.001, 1.0],+ [1.0, 0.25, 1.0],+ [1.0, 0.5, 1.0],+ [1.0, 0.75, 1.0],+ [1.0, 0.999, 1.0],+ [1.0, 0.9999999, 1.0],+ [1.0, 1.0, 1.0]+ ],+ "exclusion": [+ [0.0, 0.0, 0.0],+ [0.0, 1e-07, 1e-07],+ [0.0, 0.001, 0.001],+ [0.0, 0.25, 0.25],+ [0.0, 0.5, 0.5],+ [0.0, 0.75, 0.75],+ [0.0, 0.999, 0.999],+ [0.0, 0.9999999, 0.9999999],+ [0.0, 1.0, 1.0],+ [1e-07, 0.0, 1e-07],+ [1e-07, 1e-07, 2e-07],+ [1e-07, 0.001, 0.0010001],+ [1e-07, 0.25, 0.2500001],+ [1e-07, 0.5, 0.5],+ [1e-07, 0.75, 0.7499999],+ [1e-07, 0.999, 0.999],+ [1e-07, 0.9999999, 0.9999998],+ [1e-07, 1.0, 0.9999999],+ [0.001, 0.0, 0.001],+ [0.001, 1e-07, 0.0010001],+ [0.001, 0.001, 0.001998],+ [0.001, 0.25, 0.2505],+ [0.001, 0.5, 0.5],+ [0.001, 0.75, 0.7495],+ [0.001, 0.999, 0.9980021],+ [0.001, 0.9999999, 0.9989999],+ [0.001, 1.0, 0.999],+ [0.25, 0.0, 0.25],+ [0.25, 1e-07, 0.2500001],+ [0.25, 0.001, 0.2505],+ [0.25, 0.25, 0.375],+ [0.25, 0.5, 0.5],+ [0.25, 0.75, 0.625],+ [0.25, 0.999, 0.7495],+ [0.25, 0.9999999, 0.7499999],+ [0.25, 1.0, 0.75],+ [0.5, 0.0, 0.5],+ [0.5, 1e-07, 0.5],+ [0.5, 0.001, 0.5],+ [0.5, 0.25, 0.5],+ [0.5, 0.5, 0.5],+ [0.5, 0.75, 0.5],+ [0.5, 0.999, 0.5],+ [0.5, 0.9999999, 0.5],+ [0.5, 1.0, 0.5],+ [0.75, 0.0, 0.75],+ [0.75, 1e-07, 0.7499999],+ [0.75, 0.001, 0.7495],+ [0.75, 0.25, 0.625],+ [0.75, 0.5, 0.5],+ [0.75, 0.75, 0.375],+ [0.75, 0.999, 0.2505],+ [0.75, 0.9999999, 0.2500001],+ [0.75, 1.0, 0.25],+ [0.999, 0.0, 0.999],+ [0.999, 1e-07, 0.999],+ [0.999, 0.001, 0.9980021],+ [0.999, 0.25, 0.7495],+ [0.999, 0.5, 0.5],+ [0.999, 0.75, 0.2505],+ [0.999, 0.999, 0.001998],+ [0.999, 0.9999999, 0.0010001],+ [0.999, 1.0, 0.001],+ [0.9999999, 0.0, 0.9999999],+ [0.9999999, 1e-07, 0.9999998],+ [0.9999999, 0.001, 0.9989999],+ [0.9999999, 0.25, 0.7499999],+ [0.9999999, 0.5, 0.5],+ [0.9999999, 0.75, 0.2500001],+ [0.9999999, 0.999, 0.0010001],+ [0.9999999, 0.9999999, 2e-07],+ [0.9999999, 1.0, 1e-07],+ [1.0, 0.0, 1.0],+ [1.0, 1e-07, 0.9999999],+ [1.0, 0.001, 0.999],+ [1.0, 0.25, 0.75],+ [1.0, 0.5, 0.5],+ [1.0, 0.75, 0.25],+ [1.0, 0.999, 0.001],+ [1.0, 0.9999999, 1e-07],+ [1.0, 1.0, 0.0]+ ],+ "grain-extract": [+ [0.0, 0.0, 0.5],+ [0.0, 1e-07, 0.4999999],+ [0.0, 0.001, 0.499],+ [0.0, 0.25, 0.25],+ [0.0, 0.5, 0.0],+ [0.0, 0.75, -0.25],+ [0.0, 0.999, -0.499],+ [0.0, 0.9999999, -0.4999999],+ [0.0, 1.0, -0.5],+ [1e-07, 0.0, 0.5000001],+ [1e-07, 1e-07, 0.5],+ [1e-07, 0.001, 0.4990001],+ [1e-07, 0.25, 0.2500001],+ [1e-07, 0.5, 1e-07],+ [1e-07, 0.75, -0.2499999],+ [1e-07, 0.999, -0.4989999],+ [1e-07, 0.9999999, -0.4999998],+ [1e-07, 1.0, -0.4999999],+ [0.001, 0.0, 0.501],+ [0.001, 1e-07, 0.5009999],+ [0.001, 0.001, 0.5],+ [0.001, 0.25, 0.251],+ [0.001, 0.5, 0.001],+ [0.001, 0.75, -0.249],+ [0.001, 0.999, -0.498],+ [0.001, 0.9999999, -0.4989999],+ [0.001, 1.0, -0.499],+ [0.25, 0.0, 0.75],+ [0.25, 1e-07, 0.7499999],+ [0.25, 0.001, 0.749],+ [0.25, 0.25, 0.5],+ [0.25, 0.5, 0.25],+ [0.25, 0.75, 0.0],+ [0.25, 0.999, -0.249],+ [0.25, 0.9999999, -0.2499999],+ [0.25, 1.0, -0.25],+ [0.5, 0.0, 1.0],+ [0.5, 1e-07, 0.9999999],+ [0.5, 0.001, 0.999],+ [0.5, 0.25, 0.75],+ [0.5, 0.5, 0.5],+ [0.5, 0.75, 0.25],+ [0.5, 0.999, 0.001],+ [0.5, 0.9999999, 1e-07],+ [0.5, 1.0, 0.0],+ [0.75, 0.0, 1.25],+ [0.75, 1e-07, 1.2499999],+ [0.75, 0.001, 1.2490001],+ [0.75, 0.25, 1.0],+ [0.75, 0.5, 0.75],+ [0.75, 0.75, 0.5],+ [0.75, 0.999, 0.251],+ [0.75, 0.9999999, 0.2500001],+ [0.75, 1.0, 0.25],+ [0.999, 0.0, 1.4990001],+ [0.999, 1e-07, 1.4989998],+ [0.999, 0.001, 1.498],+ [0.999, 0.25, 1.2490001],+ [0.999, 0.5, 0.999],+ [0.999, 0.75, 0.749],+ [0.999, 0.999, 0.5],+ [0.999, 0.9999999, 0.4990001],+ [0.999, 1.0, 0.499],+ [0.9999999, 0.0, 1.4999999],+ [0.9999999, 1e-07, 1.4999998],+ [0.9999999, 0.001, 1.4989998],+ [0.9999999, 0.25, 1.2499999],+ [0.9999999, 0.5, 0.9999999],+ [0.9999999, 0.75, 0.7499999],+ [0.9999999, 0.999, 0.5009999],+ [0.9999999, 0.9999999, 0.5],+ [0.9999999, 1.0, 0.4999999],+ [1.0, 0.0, 1.5],+ [1.0, 1e-07, 1.4999999],+ [1.0, 0.001, 1.4990001],+ [1.0, 0.25, 1.25],+ [1.0, 0.5, 1.0],+ [1.0, 0.75, 0.75],+ [1.0, 0.999, 0.501],+ [1.0, 0.9999999, 0.5000001],+ [1.0, 1.0, 0.5]+ ],+ "grain-merge": [+ [0.0, 0.0, -0.5],+ [0.0, 1e-07, -0.4999999],+ [0.0, 0.001, -0.499],+ [0.0, 0.25, -0.25],+ [0.0, 0.5, 0.0],+ [0.0, 0.75, 0.25],+ [0.0, 0.999, 0.499],+ [0.0, 0.9999999, 0.4999999],+ [0.0, 1.0, 0.5],+ [1e-07, 0.0, -0.4999999],+ [1e-07, 1e-07, -0.4999998],+ [1e-07, 0.001, -0.4989999],+ [1e-07, 0.25, -0.2499999],+ [1e-07, 0.5, 1e-07],+ [1e-07, 0.75, 0.2500001],+ [1e-07, 0.999, 0.4990001],+ [1e-07, 0.9999999, 0.5],+ [1e-07, 1.0, 0.5000001],+ [0.001, 0.0, -0.499],+ [0.001, 1e-07, -0.4989999],+ [0.001, 0.001, -0.498],+ [0.001, 0.25, -0.249],+ [0.001, 0.5, 0.001],+ [0.001, 0.75, 0.251],+ [0.001, 0.999, 0.5],+ [0.001, 0.9999999, 0.5009999],+ [0.001, 1.0, 0.501],+ [0.25, 0.0, -0.25],+ [0.25, 1e-07, -0.2499999],+ [0.25, 0.001, -0.249],+ [0.25, 0.25, 0.0],+ [0.25, 0.5, 0.25],+ [0.25, 0.75, 0.5],+ [0.25, 0.999, 0.7490001],+ [0.25, 0.9999999, 0.7499999],+ [0.25, 1.0, 0.75],+ [0.5, 0.0, 0.0],+ [0.5, 1e-07, 1e-07],+ [0.5, 0.001, 0.001],+ [0.5, 0.25, 0.25],+ [0.5, 0.5, 0.5],+ [0.5, 0.75, 0.75],+ [0.5, 0.999, 0.9990001],+ [0.5, 0.9999999, 0.9999999],+ [0.5, 1.0, 1.0],+ [0.75, 0.0, 0.25],+ [0.75, 1e-07, 0.2500001],+ [0.75, 0.001, 0.251],+ [0.75, 0.25, 0.5],+ [0.75, 0.5, 0.75],+ [0.75, 0.75, 1.0],+ [0.75, 0.999, 1.2490001],+ [0.75, 0.9999999, 1.2499999],+ [0.75, 1.0, 1.25],+ [0.999, 0.0, 0.499],+ [0.999, 1e-07, 0.4990001],+ [0.999, 0.001, 0.5],+ [0.999, 0.25, 0.7490001],+ [0.999, 0.5, 0.9990001],+ [0.999, 0.75, 1.2490001],+ [0.999, 0.999, 1.498],+ [0.999, 0.9999999, 1.4989998],+ [0.999, 1.0, 1.4990001],+ [0.9999999, 0.0, 0.4999999],+ [0.9999999, 1e-07, 0.5],+ [0.9999999, 0.001, 0.5009999],+ [0.9999999, 0.25, 0.7499999],+ [0.9999999, 0.5, 0.9999999],+ [0.9999999, 0.75, 1.2499999],+ [0.9999999, 0.999, 1.4989998],+ [0.9999999, 0.9999999, 1.4999998],+ [0.9999999, 1.0, 1.4999999],+ [1.0, 0.0, 0.5],+ [1.0, 1e-07, 0.5000001],+ [1.0, 0.001, 0.501],+ [1.0, 0.25, 0.75],+ [1.0, 0.5, 1.0],+ [1.0, 0.75, 1.25],+ [1.0, 0.999, 1.4990001],+ [1.0, 0.9999999, 1.4999999],+ [1.0, 1.0, 1.5]+ ],+ "hard-light": [+ [0.0, 0.0, 0.0],+ [0.0, 1e-07, 0.0],+ [0.0, 0.001, 0.0],+ [0.0, 0.25, 0.0],+ [0.0, 0.5, 0.0],+ [0.0, 0.75, 0.5],+ [0.0, 0.999, 0.998],+ [0.0, 0.9999999, 0.9999998],+ [0.0, 1.0, 1.0],+ [1e-07, 0.0, 0.0],+ [1e-07, 1e-07, 0.0],+ [1e-07, 0.001, 0.0],+ [1e-07, 0.25, 1e-07],+ [1e-07, 0.5, 1e-07],+ [1e-07, 0.75, 0.5000001],+ [1e-07, 0.999, 0.998],+ [1e-07, 0.9999999, 0.9999998],+ [1e-07, 1.0, 1.0],+ [0.001, 0.0, 0.0],+ [0.001, 1e-07, 0.0],+ [0.001, 0.001, 2e-06],+ [0.001, 0.25, 0.0005],+ [0.001, 0.5, 0.001],+ [0.001, 0.75, 0.5005],+ [0.001, 0.999, 0.9980021],+ [0.001, 0.9999999, 0.9999998],+ [0.001, 1.0, 1.0],+ [0.25, 0.0, 0.0],+ [0.25, 1e-07, 1e-07],+ [0.25, 0.001, 0.0005],+ [0.25, 0.25, 0.125],+ [0.25, 0.5, 0.25],+ [0.25, 0.75, 0.625],+ [0.25, 0.999, 0.9985],+ [0.25, 0.9999999, 0.9999998],+ [0.25, 1.0, 1.0],+ [0.5, 0.0, 0.0],+ [0.5, 1e-07, 1e-07],+ [0.5, 0.001, 0.001],+ [0.5, 0.25, 0.25],+ [0.5, 0.5, 0.5],+ [0.5, 0.75, 0.75],+ [0.5, 0.999, 0.999],+ [0.5, 0.9999999, 0.9999999],+ [0.5, 1.0, 1.0],+ [0.75, 0.0, 0.0],+ [0.75, 1e-07, 2e-07],+ [0.75, 0.001, 0.0015],+ [0.75, 0.25, 0.375],+ [0.75, 0.5, 0.75],+ [0.75, 0.75, 0.875],+ [0.75, 0.999, 0.9995],+ [0.75, 0.9999999, 0.9999999],+ [0.75, 1.0, 1.0],+ [0.999, 0.0, 0.0],+ [0.999, 1e-07, 2e-07],+ [0.999, 0.001, 0.001998],+ [0.999, 0.25, 0.4995],+ [0.999, 0.5, 0.999],+ [0.999, 0.75, 0.9995],+ [0.999, 0.999, 0.999998],+ [0.999, 0.9999999, 1.0],+ [0.999, 1.0, 1.0],+ [0.9999999, 0.0, 0.0],+ [0.9999999, 1e-07, 2e-07],+ [0.9999999, 0.001, 0.002],+ [0.9999999, 0.25, 0.4999999],+ [0.9999999, 0.5, 0.9999999],+ [0.9999999, 0.75, 0.9999999],+ [0.9999999, 0.999, 1.0],+ [0.9999999, 0.9999999, 1.0],+ [0.9999999, 1.0, 1.0],+ [1.0, 0.0, 0.0],+ [1.0, 1e-07, 2e-07],+ [1.0, 0.001, 0.002],+ [1.0, 0.25, 0.5],+ [1.0, 0.5, 1.0],+ [1.0, 0.75, 1.0],+ [1.0, 0.999, 1.0],+ [1.0, 0.9999999, 1.0],+ [1.0, 1.0, 1.0]+ ],+ "hard-mix": [+ [0.0, 0.0, 0.0],+ [0.0, 1e-07, 0.0],+ [0.0, 0.001, 0.0],+ [0.0, 0.25, 0.0],+ [0.0, 0.5, 0.0],+ [0.0, 0.75, 0.0],+ [0.0, 0.999, 0.0],+ [0.0, 0.9999999, 0.0],+ [0.0, 1.0, 1.0],+ [1e-07, 0.0, 0.0],+ [1e-07, 1e-07, 0.0],+ [1e-07, 0.001, 0.0],+ [1e-07, 0.25, 0.0],+ [1e-07, 0.5, 0.0],+ [1e-07, 0.75, 0.0],+ [1e-07, 0.999, 0.0],+ [1e-07, 0.9999999, 1.0],+ [1e-07, 1.0, 1.0],+ [0.001, 0.0, 0.0],+ [0.001, 1e-07, 0.0],+ [0.001, 0.001, 0.0],+ [0.001, 0.25, 0.0],+ [0.001, 0.5, 0.0],+ [0.001, 0.75, 0.0],+ [0.001, 0.999, 1.0],+ [0.001, 0.9999999, 1.0],+ [0.001, 1.0, 1.0],+ [0.25, 0.0, 0.0],+ [0.25, 1e-07, 0.0],+ [0.25, 0.001, 0.0],+ [0.25, 0.25, 0.0],+ [0.25, 0.5, 0.0],+ [0.25, 0.75, 1.0],+ [0.25, 0.999, 1.0],+ [0.25, 0.9999999, 1.0],+ [0.25, 1.0, 1.0],+ [0.5, 0.0, 0.0],+ [0.5, 1e-07, 0.0],+ [0.5, 0.001, 0.0],+ [0.5, 0.25, 0.0],+ [0.5, 0.5, 1.0],+ [0.5, 0.75, 1.0],+ [0.5, 0.999, 1.0],+ [0.5, 0.9999999, 1.0],+ [0.5, 1.0, 1.0],+ [0.75, 0.0, 0.0],+ [0.75, 1e-07, 0.0],+ [0.75, 0.001, 0.0],+ [0.75, 0.25, 1.0],+ [0.75, 0.5, 1.0],+ [0.75, 0.75, 1.0],+ [0.75, 0.999, 1.0],+ [0.75, 0.9999999, 1.0],+ [0.75, 1.0, 1.0],+ [0.999, 0.0, 0.0],+ [0.999, 1e-07, 0.0],+ [0.999, 0.001, 1.0],+ [0.999, 0.25, 1.0],+ [0.999, 0.5, 1.0],+ [0.999, 0.75, 1.0],+ [0.999, 0.999, 1.0],+ [0.999, 0.9999999, 1.0],+ [0.999, 1.0, 1.0],+ [0.9999999, 0.0, 0.0],+ [0.9999999, 1e-07, 1.0],+ [0.9999999, 0.001, 1.0],+ [0.9999999, 0.25, 1.0],+ [0.9999999, 0.5, 1.0],+ [0.9999999, 0.75, 1.0],+ [0.9999999, 0.999, 1.0],+ [0.9999999, 0.9999999, 1.0],+ [0.9999999, 1.0, 1.0],+ [1.0, 0.0, 1.0],+ [1.0, 1e-07, 1.0],+ [1.0, 0.001, 1.0],+ [1.0, 0.25, 1.0],+ [1.0, 0.5, 1.0],+ [1.0, 0.75, 1.0],+ [1.0, 0.999, 1.0],+ [1.0, 0.9999999, 1.0],+ [1.0, 1.0, 1.0]+ ],+ "lighten": [+ [0.0, 0.0, 0.0],+ [0.0, 1e-07, 1e-07],+ [0.0, 0.001, 0.001],+ [0.0, 0.25, 0.25],+ [0.0, 0.5, 0.5],+ [0.0, 0.75, 0.75],+ [0.0, 0.999, 0.999],+ [0.0, 0.9999999, 0.9999999],+ [0.0, 1.0, 1.0],+ [1e-07, 0.0, 1e-07],+ [1e-07, 1e-07, 1e-07],+ [1e-07, 0.001, 0.001],+ [1e-07, 0.25, 0.25],+ [1e-07, 0.5, 0.5],+ [1e-07, 0.75, 0.75],+ [1e-07, 0.999, 0.999],+ [1e-07, 0.9999999, 0.9999999],+ [1e-07, 1.0, 1.0],+ [0.001, 0.0, 0.001],+ [0.001, 1e-07, 0.001],+ [0.001, 0.001, 0.001],+ [0.001, 0.25, 0.25],+ [0.001, 0.5, 0.5],+ [0.001, 0.75, 0.75],+ [0.001, 0.999, 0.999],+ [0.001, 0.9999999, 0.9999999],+ [0.001, 1.0, 1.0],+ [0.25, 0.0, 0.25],+ [0.25, 1e-07, 0.25],+ [0.25, 0.001, 0.25],+ [0.25, 0.25, 0.25],+ [0.25, 0.5, 0.5],+ [0.25, 0.75, 0.75],+ [0.25, 0.999, 0.999],+ [0.25, 0.9999999, 0.9999999],+ [0.25, 1.0, 1.0],+ [0.5, 0.0, 0.5],+ [0.5, 1e-07, 0.5],+ [0.5, 0.001, 0.5],+ [0.5, 0.25, 0.5],+ [0.5, 0.5, 0.5],+ [0.5, 0.75, 0.75],+ [0.5, 0.999, 0.999],+ [0.5, 0.9999999, 0.9999999],+ [0.5, 1.0, 1.0],+ [0.75, 0.0, 0.75],+ [0.75, 1e-07, 0.75],+ [0.75, 0.001, 0.75],+ [0.75, 0.25, 0.75],+ [0.75, 0.5, 0.75],+ [0.75, 0.75, 0.75],+ [0.75, 0.999, 0.999],+ [0.75, 0.9999999, 0.9999999],+ [0.75, 1.0, 1.0],+ [0.999, 0.0, 0.999],+ [0.999, 1e-07, 0.999],+ [0.999, 0.001, 0.999],+ [0.999, 0.25, 0.999],+ [0.999, 0.5, 0.999],+ [0.999, 0.75, 0.999],+ [0.999, 0.999, 0.999],+ [0.999, 0.9999999, 0.9999999],+ [0.999, 1.0, 1.0],+ [0.9999999, 0.0, 0.9999999],+ [0.9999999, 1e-07, 0.9999999],+ [0.9999999, 0.001, 0.9999999],+ [0.9999999, 0.25, 0.9999999],+ [0.9999999, 0.5, 0.9999999],+ [0.9999999, 0.75, 0.9999999],+ [0.9999999, 0.999, 0.9999999],+ [0.9999999, 0.9999999, 0.9999999],+ [0.9999999, 1.0, 1.0],+ [1.0, 0.0, 1.0],+ [1.0, 1e-07, 1.0],+ [1.0, 0.001, 1.0],+ [1.0, 0.25, 1.0],+ [1.0, 0.5, 1.0],+ [1.0, 0.75, 1.0],+ [1.0, 0.999, 1.0],+ [1.0, 0.9999999, 1.0],+ [1.0, 1.0, 1.0]+ ],+ "linear-burn": [+ [0.0, 0.0, -1.0],+ [0.0, 1e-07, -0.9999999],+ [0.0, 0.001, -0.999],+ [0.0, 0.25, -0.75],+ [0.0, 0.5, -0.5],+ [0.0, 0.75, -0.25],+ [0.0, 0.999, -0.001],+ [0.0, 0.9999999, -1e-07],+ [0.0, 1.0, 0.0],+ [1e-07, 0.0, -0.9999999],+ [1e-07, 1e-07, -0.9999998],+ [1e-07, 0.001, -0.9989999],+ [1e-07, 0.25, -0.7499999],+ [1e-07, 0.5, -0.4999999],+ [1e-07, 0.75, -0.2499999],+ [1e-07, 0.999, -0.0009999],+ [1e-07, 0.9999999, 0.0],+ [1e-07, 1.0, 1e-07],+ [0.001, 0.0, -0.999],+ [0.001, 1e-07, -0.9989999],+ [0.001, 0.001, -0.998],+ [0.001, 0.25, -0.749],+ [0.001, 0.5, -0.499],+ [0.001, 0.75, -0.249],+ [0.001, 0.999, 0.0],+ [0.001, 0.9999999, 0.0009999],+ [0.001, 1.0, 0.001],+ [0.25, 0.0, -0.75],+ [0.25, 1e-07, -0.7499999],+ [0.25, 0.001, -0.749],+ [0.25, 0.25, -0.5],+ [0.25, 0.5, -0.25],+ [0.25, 0.75, 0.0],+ [0.25, 0.999, 0.2490001],+ [0.25, 0.9999999, 0.2499999],+ [0.25, 1.0, 0.25],+ [0.5, 0.0, -0.5],+ [0.5, 1e-07, -0.4999999],+ [0.5, 0.001, -0.499],+ [0.5, 0.25, -0.25],+ [0.5, 0.5, 0.0],+ [0.5, 0.75, 0.25],+ [0.5, 0.999, 0.4990001],+ [0.5, 0.9999999, 0.4999999],+ [0.5, 1.0, 0.5],+ [0.75, 0.0, -0.25],+ [0.75, 1e-07, -0.2499999],+ [0.75, 0.001, -0.249],+ [0.75, 0.25, 0.0],+ [0.75, 0.5, 0.25],+ [0.75, 0.75, 0.5],+ [0.75, 0.999, 0.7490001],+ [0.75, 0.9999999, 0.7499999],+ [0.75, 1.0, 0.75],+ [0.999, 0.0, -0.001],+ [0.999, 1e-07, -0.0009999],+ [0.999, 0.001, 0.0],+ [0.999, 0.25, 0.2490001],+ [0.999, 0.5, 0.4990001],+ [0.999, 0.75, 0.7490001],+ [0.999, 0.999, 0.998],+ [0.999, 0.9999999, 0.9989998],+ [0.999, 1.0, 0.9990001],+ [0.9999999, 0.0, -1e-07],+ [0.9999999, 1e-07, 0.0],+ [0.9999999, 0.001, 0.0009999],+ [0.9999999, 0.25, 0.2499999],+ [0.9999999, 0.5, 0.4999999],+ [0.9999999, 0.75, 0.7499999],+ [0.9999999, 0.999, 0.9989998],+ [0.9999999, 0.9999999, 0.9999998],+ [0.9999999, 1.0, 0.9999999],+ [1.0, 0.0, 0.0],+ [1.0, 1e-07, 1e-07],+ [1.0, 0.001, 0.001],+ [1.0, 0.25, 0.25],+ [1.0, 0.5, 0.5],+ [1.0, 0.75, 0.75],+ [1.0, 0.999, 0.9990001],+ [1.0, 0.9999999, 0.9999999],+ [1.0, 1.0, 1.0]+ ],+ "linear-dodge": [+ [0.0, 0.0, 0.0],+ [0.0, 1e-07, 1e-07],+ [0.0, 0.001, 0.001],+ [0.0, 0.25, 0.25],+ [0.0, 0.5, 0.5],+ [0.0, 0.75, 0.75],+ [0.0, 0.999, 0.999],+ [0.0, 0.9999999, 0.9999999],+ [0.0, 1.0, 1.0],+ [1e-07, 0.0, 1e-07],+ [1e-07, 1e-07, 2e-07],+ [1e-07, 0.001, 0.0010001],+ [1e-07, 0.25, 0.2500001],+ [1e-07, 0.5, 0.5000001],+ [1e-07, 0.75, 0.7500001],+ [1e-07, 0.999, 0.9990001],+ [1e-07, 0.9999999, 1.0],+ [1e-07, 1.0, 1.0000001],+ [0.001, 0.0, 0.001],+ [0.001, 1e-07, 0.0010001],+ [0.001, 0.001, 0.002],+ [0.001, 0.25, 0.251],+ [0.001, 0.5, 0.501],+ [0.001, 0.75, 0.751],+ [0.001, 0.999, 1.0],+ [0.001, 0.9999999, 1.0009999],+ [0.001, 1.0, 1.001],+ [0.25, 0.0, 0.25],+ [0.25, 1e-07, 0.2500001],+ [0.25, 0.001, 0.251],+ [0.25, 0.25, 0.5],+ [0.25, 0.5, 0.75],+ [0.25, 0.75, 1.0],+ [0.25, 0.999, 1.2490001],+ [0.25, 0.9999999, 1.2499999],+ [0.25, 1.0, 1.25],+ [0.5, 0.0, 0.5],+ [0.5, 1e-07, 0.5000001],+ [0.5, 0.001, 0.501],+ [0.5, 0.25, 0.75],+ [0.5, 0.5, 1.0],+ [0.5, 0.75, 1.25],+ [0.5, 0.999, 1.4990001],+ [0.5, 0.9999999, 1.4999999],+ [0.5, 1.0, 1.5],+ [0.75, 0.0, 0.75],+ [0.75, 1e-07, 0.7500001],+ [0.75, 0.001, 0.751],+ [0.75, 0.25, 1.0],+ [0.75, 0.5, 1.25],+ [0.75, 0.75, 1.5],+ [0.75, 0.999, 1.7490001],+ [0.75, 0.9999999, 1.7499999],+ [0.75, 1.0, 1.75],+ [0.999, 0.0, 0.999],+ [0.999, 1e-07, 0.9990001],+ [0.999, 0.001, 1.0],+ [0.999, 0.25, 1.2490001],+ [0.999, 0.5, 1.4990001],+ [0.999, 0.75, 1.7490001],+ [0.999, 0.999, 1.998],+ [0.999, 0.9999999, 1.9989998],+ [0.999, 1.0, 1.9990001],+ [0.9999999, 0.0, 0.9999999],+ [0.9999999, 1e-07, 1.0],+ [0.9999999, 0.001, 1.0009999],+ [0.9999999, 0.25, 1.2499999],+ [0.9999999, 0.5, 1.4999999],+ [0.9999999, 0.75, 1.7499999],+ [0.9999999, 0.999, 1.9989998],+ [0.9999999, 0.9999999, 1.9999998],+ [0.9999999, 1.0, 1.9999999],+ [1.0, 0.0, 1.0],+ [1.0, 1e-07, 1.0000001],+ [1.0, 0.001, 1.001],+ [1.0, 0.25, 1.25],+ [1.0, 0.5, 1.5],+ [1.0, 0.75, 1.75],+ [1.0, 0.999, 1.9990001],+ [1.0, 0.9999999, 1.9999999],+ [1.0, 1.0, 2.0]+ ],+ "linear-light": [+ [0.0, 0.0, -1.0],+ [0.0, 1e-07, -0.9999998],+ [0.0, 0.001, -0.998],+ [0.0, 0.25, -0.5],+ [0.0, 0.5, 0.0],+ [0.0, 0.75, 0.5],+ [0.0, 0.999, 0.998],+ [0.0, 0.9999999, 0.9999998],+ [0.0, 1.0, 1.0],+ [1e-07, 0.0, -0.9999999],+ [1e-07, 1e-07, -0.9999997],+ [1e-07, 0.001, -0.9979999],+ [1e-07, 0.25, -0.4999999],+ [1e-07, 0.5, 1e-07],+ [1e-07, 0.75, 0.5000001],+ [1e-07, 0.999, 0.9980001],+ [1e-07, 0.9999999, 0.9999999],+ [1e-07, 1.0, 1.0],+ [0.001, 0.0, -0.999],+ [0.001, 1e-07, -0.9989998],+ [0.001, 0.001, -0.997],+ [0.001, 0.25, -0.499],+ [0.001, 0.5, 0.001],+ [0.001, 0.75, 0.501],+ [0.001, 0.999, 0.9990001],+ [0.001, 0.9999999, 1.0009997],+ [0.001, 1.0, 1.0009999],+ [0.25, 0.0, -0.75],+ [0.25, 1e-07, -0.7499998],+ [0.25, 0.001, -0.748],+ [0.25, 0.25, -0.25],+ [0.25, 0.5, 0.25],+ [0.25, 0.75, 0.75],+ [0.25, 0.999, 1.2480001],+ [0.25, 0.9999999, 1.2499998],+ [0.25, 1.0, 1.25],+ [0.5, 0.0, -0.5],+ [0.5, 1e-07, -0.4999998],+ [0.5, 0.001, -0.498],+ [0.5, 0.25, 0.0],+ [0.5, 0.5, 0.5],+ [0.5, 0.75, 1.0],+ [0.5, 0.999, 1.4980001],+ [0.5, 0.9999999, 1.4999998],+ [0.5, 1.0, 1.5],+ [0.75, 0.0, -0.25],+ [0.75, 1e-07, -0.2499998],+ [0.75, 0.001, -0.248],+ [0.75, 0.25, 0.25],+ [0.75, 0.5, 0.75],+ [0.75, 0.75, 1.25],+ [0.75, 0.999, 1.7480001],+ [0.75, 0.9999999, 1.7499998],+ [0.75, 1.0, 1.75],+ [0.999, 0.0, -0.001],+ [0.999, 1e-07, -0.0009998],+ [0.999, 0.001, 0.001],+ [0.999, 0.25, 0.4990001],+ [0.999, 0.5, 0.9990001],+ [0.999, 0.75, 1.4990001],+ [0.999, 0.999, 1.997],+ [0.999, 0.9999999, 1.9989998],+ [0.999, 1.0, 1.9990001],+ [0.9999999, 0.0, -1e-07],+ [0.9999999, 1e-07, 1e-07],+ [0.9999999, 0.001, 0.0019999],+ [0.9999999, 0.25, 0.4999999],+ [0.9999999, 0.5, 0.9999999],+ [0.9999999, 0.75, 1.5],+ [0.9999999, 0.999, 1.9979999],+ [0.9999999, 0.9999999, 1.9999995],+ [0.9999999, 1.0, 2.0],+ [1.0, 0.0, 0.0],+ [1.0, 1e-07, 2e-07],+ [1.0, 0.001, 0.002],+ [1.0, 0.25, 0.5],+ [1.0, 0.5, 1.0],+ [1.0, 0.75, 1.5],+ [1.0, 0.999, 1.9980001],+ [1.0, 0.9999999, 1.9999998],+ [1.0, 1.0, 2.0]+ ],+ "multiply": [+ [0.0, 0.0, 0.0],+ [0.0, 1e-07, 0.0],+ [0.0, 0.001, 0.0],+ [0.0, 0.25, 0.0],+ [0.0, 0.5, 0.0],+ [0.0, 0.75, 0.0],+ [0.0, 0.999, 0.0],+ [0.0, 0.9999999, 0.0],+ [0.0, 1.0, 0.0],+ [1e-07, 0.0, 0.0],+ [1e-07, 1e-07, 0.0],+ [1e-07, 0.001, 0.0],+ [1e-07, 0.25, 0.0],+ [1e-07, 0.5, 1e-07],+ [1e-07, 0.75, 1e-07],+ [1e-07, 0.999, 1e-07],+ [1e-07, 0.9999999, 1e-07],+ [1e-07, 1.0, 1e-07],+ [0.001, 0.0, 0.0],+ [0.001, 1e-07, 0.0],+ [0.001, 0.001, 1e-06],+ [0.001, 0.25, 0.00025],+ [0.001, 0.5, 0.0005],+ [0.001, 0.75, 0.00075],+ [0.001, 0.999, 0.000999],+ [0.001, 0.9999999, 0.001],+ [0.001, 1.0, 0.001],+ [0.25, 0.0, 0.0],+ [0.25, 1e-07, 0.0],+ [0.25, 0.001, 0.00025],+ [0.25, 0.25, 0.0625],+ [0.25, 0.5, 0.125],+ [0.25, 0.75, 0.1875],+ [0.25, 0.999, 0.24975],+ [0.25, 0.9999999, 0.25],+ [0.25, 1.0, 0.25],+ [0.5, 0.0, 0.0],+ [0.5, 1e-07, 1e-07],+ [0.5, 0.001, 0.0005],+ [0.5, 0.25, 0.125],+ [0.5, 0.5, 0.25],+ [0.5, 0.75, 0.375],+ [0.5, 0.999, 0.4995],+ [0.5, 0.9999999, 0.4999999],+ [0.5, 1.0, 0.5],+ [0.75, 0.0, 0.0],+ [0.75, 1e-07, 1e-07],+ [0.75, 0.001, 0.00075],+ [0.75, 0.25, 0.1875],+ [0.75, 0.5, 0.375],+ [0.75, 0.75, 0.5625],+ [0.75, 0.999, 0.74925],+ [0.75, 0.9999999, 0.7499999],+ [0.75, 1.0, 0.75],+ [0.999, 0.0, 0.0],+ [0.999, 1e-07, 1e-07],+ [0.999, 0.001, 0.000999],+ [0.999, 0.25, 0.24975],+ [0.999, 0.5, 0.4995],+ [0.999, 0.75, 0.74925],+ [0.999, 0.999, 0.998001],+ [0.999, 0.9999999, 0.9989999],+ [0.999, 1.0, 0.999],+ [0.9999999, 0.0, 0.0],+ [0.9999999, 1e-07, 1e-07],+ [0.9999999, 0.001, 0.001],+ [0.9999999, 0.25, 0.25],+ [0.9999999, 0.5, 0.4999999],+ [0.9999999, 0.75, 0.7499999],+ [0.9999999, 0.999, 0.9989999],+ [0.9999999, 0.9999999, 0.9999998],+ [0.9999999, 1.0, 0.9999999],+ [1.0, 0.0, 0.0],+ [1.0, 1e-07, 1e-07],+ [1.0, 0.001, 0.001],+ [1.0, 0.25, 0.25],+ [1.0, 0.5, 0.5],+ [1.0, 0.75, 0.75],+ [1.0, 0.999, 0.999],+ [1.0, 0.9999999, 0.9999999],+ [1.0, 1.0, 1.0]+ ],+ "normal": [+ [0.0, 0.0, 0.0],+ [0.0, 1e-07, 1e-07],+ [0.0, 0.001, 0.001],+ [0.0, 0.25, 0.25],+ [0.0, 0.5, 0.5],+ [0.0, 0.75, 0.75],+ [0.0, 0.999, 0.999],+ [0.0, 0.9999999, 0.9999999],+ [0.0, 1.0, 1.0],+ [1e-07, 0.0, 0.0],+ [1e-07, 1e-07, 1e-07],+ [1e-07, 0.001, 0.001],+ [1e-07, 0.25, 0.25],+ [1e-07, 0.5, 0.5],+ [1e-07, 0.75, 0.75],+ [1e-07, 0.999, 0.999],+ [1e-07, 0.9999999, 0.9999999],+ [1e-07, 1.0, 1.0],+ [0.001, 0.0, 0.0],+ [0.001, 1e-07, 1e-07],+ [0.001, 0.001, 0.001],+ [0.001, 0.25, 0.25],+ [0.001, 0.5, 0.5],+ [0.001, 0.75, 0.75],+ [0.001, 0.999, 0.999],+ [0.001, 0.9999999, 0.9999999],+ [0.001, 1.0, 1.0],+ [0.25, 0.0, 0.0],+ [0.25, 1e-07, 1e-07],+ [0.25, 0.001, 0.001],+ [0.25, 0.25, 0.25],+ [0.25, 0.5, 0.5],+ [0.25, 0.75, 0.75],+ [0.25, 0.999, 0.999],+ [0.25, 0.9999999, 0.9999999],+ [0.25, 1.0, 1.0],+ [0.5, 0.0, 0.0],+ [0.5, 1e-07, 1e-07],+ [0.5, 0.001, 0.001],+ [0.5, 0.25, 0.25],+ [0.5, 0.5, 0.5],+ [0.5, 0.75, 0.75],+ [0.5, 0.999, 0.999],+ [0.5, 0.9999999, 0.9999999],+ [0.5, 1.0, 1.0],+ [0.75, 0.0, 0.0],+ [0.75, 1e-07, 1e-07],+ [0.75, 0.001, 0.001],+ [0.75, 0.25, 0.25],+ [0.75, 0.5, 0.5],+ [0.75, 0.75, 0.75],+ [0.75, 0.999, 0.999],+ [0.75, 0.9999999, 0.9999999],+ [0.75, 1.0, 1.0],+ [0.999, 0.0, 0.0],+ [0.999, 1e-07, 1e-07],+ [0.999, 0.001, 0.001],+ [0.999, 0.25, 0.25],+ [0.999, 0.5, 0.5],+ [0.999, 0.75, 0.75],+ [0.999, 0.999, 0.999],+ [0.999, 0.9999999, 0.9999999],+ [0.999, 1.0, 1.0],+ [0.9999999, 0.0, 0.0],+ [0.9999999, 1e-07, 1e-07],+ [0.9999999, 0.001, 0.001],+ [0.9999999, 0.25, 0.25],+ [0.9999999, 0.5, 0.5],+ [0.9999999, 0.75, 0.75],+ [0.9999999, 0.999, 0.999],+ [0.9999999, 0.9999999, 0.9999999],+ [0.9999999, 1.0, 1.0],+ [1.0, 0.0, 0.0],+ [1.0, 1e-07, 1e-07],+ [1.0, 0.001, 0.001],+ [1.0, 0.25, 0.25],+ [1.0, 0.5, 0.5],+ [1.0, 0.75, 0.75],+ [1.0, 0.999, 0.999],+ [1.0, 0.9999999, 0.9999999],+ [1.0, 1.0, 1.0]+ ],+ "overlay": [+ [0.0, 0.0, 0.0],+ [0.0, 1e-07, 0.0],+ [0.0, 0.001, 0.0],+ [0.0, 0.25, 0.0],+ [0.0, 0.5, 0.0],+ [0.0, 0.75, 0.0],+ [0.0, 0.999, 0.0],+ [0.0, 0.9999999, 0.0],+ [0.0, 1.0, 0.0],+ [1e-07, 0.0, 0.0],+ [1e-07, 1e-07, 0.0],+ [1e-07, 0.001, 0.0],+ [1e-07, 0.25, 1e-07],+ [1e-07, 0.5, 1e-07],+ [1e-07, 0.75, 2e-07],+ [1e-07, 0.999, 2e-07],+ [1e-07, 0.9999999, 2e-07],+ [1e-07, 1.0, 2e-07],+ [0.001, 0.0, 0.0],+ [0.001, 1e-07, 0.0],+ [0.001, 0.001, 2e-06],+ [0.001, 0.25, 0.0005],+ [0.001, 0.5, 0.001],+ [0.001, 0.75, 0.0015],+ [0.001, 0.999, 0.001998],+ [0.001, 0.9999999, 0.002],+ [0.001, 1.0, 0.002],+ [0.25, 0.0, 0.0],+ [0.25, 1e-07, 1e-07],+ [0.25, 0.001, 0.0005],+ [0.25, 0.25, 0.125],+ [0.25, 0.5, 0.25],+ [0.25, 0.75, 0.375],+ [0.25, 0.999, 0.4995],+ [0.25, 0.9999999, 0.4999999],+ [0.25, 1.0, 0.5],+ [0.5, 0.0, 0.0],+ [0.5, 1e-07, 1e-07],+ [0.5, 0.001, 0.001],+ [0.5, 0.25, 0.25],+ [0.5, 0.5, 0.5],+ [0.5, 0.75, 0.75],+ [0.5, 0.999, 0.999],+ [0.5, 0.9999999, 0.9999999],+ [0.5, 1.0, 1.0],+ [0.75, 0.0, 0.5],+ [0.75, 1e-07, 0.5000001],+ [0.75, 0.001, 0.5005],+ [0.75, 0.25, 0.625],+ [0.75, 0.5, 0.75],+ [0.75, 0.75, 0.875],+ [0.75, 0.999, 0.9995],+ [0.75, 0.9999999, 0.9999999],+ [0.75, 1.0, 1.0],+ [0.999, 0.0, 0.998],+ [0.999, 1e-07, 0.998],+ [0.999, 0.001, 0.9980021],+ [0.999, 0.25, 0.9985],+ [0.999, 0.5, 0.999],+ [0.999, 0.75, 0.9995],+ [0.999, 0.999, 0.999998],+ [0.999, 0.9999999, 1.0],+ [0.999, 1.0, 1.0],+ [0.9999999, 0.0, 0.9999998],+ [0.9999999, 1e-07, 0.9999998],+ [0.9999999, 0.001, 0.9999998],+ [0.9999999, 0.25, 0.9999998],+ [0.9999999, 0.5, 0.9999999],+ [0.9999999, 0.75, 0.9999999],+ [0.9999999, 0.999, 1.0],+ [0.9999999, 0.9999999, 1.0],+ [0.9999999, 1.0, 1.0],+ [1.0, 0.0, 1.0],+ [1.0, 1e-07, 1.0],+ [1.0, 0.001, 1.0],+ [1.0, 0.25, 1.0],+ [1.0, 0.5, 1.0],+ [1.0, 0.75, 1.0],+ [1.0, 0.999, 1.0],+ [1.0, 0.9999999, 1.0],+ [1.0, 1.0, 1.0]+ ],+ "pin-light": [+ [0.0, 0.0, 0.0],+ [0.0, 1e-07, 0.0],+ [0.0, 0.001, 0.0],+ [0.0, 0.25, 0.0],+ [0.0, 0.5, 0.0],+ [0.0, 0.75, 0.5],+ [0.0, 0.999, 0.998],+ [0.0, 0.9999999, 0.9999998],+ [0.0, 1.0, 1.0],+ [1e-07, 0.0, 0.0],+ [1e-07, 1e-07, 1e-07],+ [1e-07, 0.001, 1e-07],+ [1e-07, 0.25, 1e-07],+ [1e-07, 0.5, 1e-07],+ [1e-07, 0.75, 0.5],+ [1e-07, 0.999, 0.998],+ [1e-07, 0.9999999, 0.9999998],+ [1e-07, 1.0, 1.0],+ [0.001, 0.0, 0.0],+ [0.001, 1e-07, 2e-07],+ [0.001, 0.001, 0.001],+ [0.001, 0.25, 0.001],+ [0.001, 0.5, 0.001],+ [0.001, 0.75, 0.5],+ [0.001, 0.999, 0.998],+ [0.001, 0.9999999, 0.9999998],+ [0.001, 1.0, 1.0],+ [0.25, 0.0, 0.0],+ [0.25, 1e-07, 2e-07],+ [0.25, 0.001, 0.002],+ [0.25, 0.25, 0.25],+ [0.25, 0.5, 0.25],+ [0.25, 0.75, 0.5],+ [0.25, 0.999, 0.998],+ [0.25, 0.9999999, 0.9999998],+ [0.25, 1.0, 1.0],+ [0.5, 0.0, 0.0],+ [0.5, 1e-07, 2e-07],+ [0.5, 0.001, 0.002],+ [0.5, 0.25, 0.5],+ [0.5, 0.5, 0.5],+ [0.5, 0.75, 0.5],+ [0.5, 0.999, 0.998],+ [0.5, 0.9999999, 0.9999998],+ [0.5, 1.0, 1.0],+ [0.75, 0.0, 0.0],+ [0.75, 1e-07, 2e-07],+ [0.75, 0.001, 0.002],+ [0.75, 0.25, 0.5],+ [0.75, 0.5, 0.75],+ [0.75, 0.75, 0.75],+ [0.75, 0.999, 0.998],+ [0.75, 0.9999999, 0.9999998],+ [0.75, 1.0, 1.0],+ [0.999, 0.0, 0.0],+ [0.999, 1e-07, 2e-07],+ [0.999, 0.001, 0.002],+ [0.999, 0.25, 0.5],+ [0.999, 0.5, 0.999],+ [0.999, 0.75, 0.999],+ [0.999, 0.999, 0.999],+ [0.999, 0.9999999, 0.9999998],+ [0.999, 1.0, 1.0],+ [0.9999999, 0.0, 0.0],+ [0.9999999, 1e-07, 2e-07],+ [0.9999999, 0.001, 0.002],+ [0.9999999, 0.25, 0.5],+ [0.9999999, 0.5, 0.9999999],+ [0.9999999, 0.75, 0.9999999],+ [0.9999999, 0.999, 0.9999999],+ [0.9999999, 0.9999999, 0.9999999],+ [0.9999999, 1.0, 1.0],+ [1.0, 0.0, 0.0],+ [1.0, 1e-07, 2e-07],+ [1.0, 0.001, 0.002],+ [1.0, 0.25, 0.5],+ [1.0, 0.5, 1.0],+ [1.0, 0.75, 1.0],+ [1.0, 0.999, 1.0],+ [1.0, 0.9999999, 1.0],+ [1.0, 1.0, 1.0]+ ],+ "screen": [+ [0.0, 0.0, 0.0],+ [0.0, 1e-07, 1e-07],+ [0.0, 0.001, 0.001],+ [0.0, 0.25, 0.25],+ [0.0, 0.5, 0.5],+ [0.0, 0.75, 0.75],+ [0.0, 0.999, 0.999],+ [0.0, 0.9999999, 0.9999999],+ [0.0, 1.0, 1.0],+ [1e-07, 0.0, 1e-07],+ [1e-07, 1e-07, 2e-07],+ [1e-07, 0.001, 0.0010001],+ [1e-07, 0.25, 0.2500001],+ [1e-07, 0.5, 0.5000001],+ [1e-07, 0.75, 0.75],+ [1e-07, 0.999, 0.999],+ [1e-07, 0.9999999, 0.9999999],+ [1e-07, 1.0, 1.0],+ [0.001, 0.0, 0.001],+ [0.001, 1e-07, 0.0010001],+ [0.001, 0.001, 0.001999],+ [0.001, 0.25, 0.25075],+ [0.001, 0.5, 0.5005],+ [0.001, 0.75, 0.75025],+ [0.001, 0.999, 0.999001],+ [0.001, 0.9999999, 0.9999999],+ [0.001, 1.0, 1.0],+ [0.25, 0.0, 0.25],+ [0.25, 1e-07, 0.2500001],+ [0.25, 0.001, 0.25075],+ [0.25, 0.25, 0.4375],+ [0.25, 0.5, 0.625],+ [0.25, 0.75, 0.8125],+ [0.25, 0.999, 0.99925],+ [0.25, 0.9999999, 0.9999999],+ [0.25, 1.0, 1.0],+ [0.5, 0.0, 0.5],+ [0.5, 1e-07, 0.5000001],+ [0.5, 0.001, 0.5005],+ [0.5, 0.25, 0.625],+ [0.5, 0.5, 0.75],+ [0.5, 0.75, 0.875],+ [0.5, 0.999, 0.9995],+ [0.5, 0.9999999, 0.9999999],+ [0.5, 1.0, 1.0],+ [0.75, 0.0, 0.75],+ [0.75, 1e-07, 0.75],+ [0.75, 0.001, 0.75025],+ [0.75, 0.25, 0.8125],+ [0.75, 0.5, 0.875],+ [0.75, 0.75, 0.9375],+ [0.75, 0.999, 0.99975],+ [0.75, 0.9999999, 1.0],+ [0.75, 1.0, 1.0],+ [0.999, 0.0, 0.999],+ [0.999, 1e-07, 0.999],+ [0.999, 0.001, 0.999001],+ [0.999, 0.25, 0.99925],+ [0.999, 0.5, 0.9995],+ [0.999, 0.75, 0.99975],+ [0.999, 0.999, 0.999999],+ [0.999, 0.9999999, 1.0],+ [0.999, 1.0, 1.0],+ [0.9999999, 0.0, 0.9999999],+ [0.9999999, 1e-07, 0.9999999],+ [0.9999999, 0.001, 0.9999999],+ [0.9999999, 0.25, 0.9999999],+ [0.9999999, 0.5, 0.9999999],+ [0.9999999, 0.75, 1.0],+ [0.9999999, 0.999, 1.0],+ [0.9999999, 0.9999999, 1.0],+ [0.9999999, 1.0, 1.0],+ [1.0, 0.0, 1.0],+ [1.0, 1e-07, 1.0],+ [1.0, 0.001, 1.0],+ [1.0, 0.25, 1.0],+ [1.0, 0.5, 1.0],+ [1.0, 0.75, 1.0],+ [1.0, 0.999, 1.0],+ [1.0, 0.9999999, 1.0],+ [1.0, 1.0, 1.0]+ ],+ "soft-light": [+ [0.0, 0.0, 0.0],+ [0.0, 1e-07, 0.0],+ [0.0, 0.001, 0.0],+ [0.0, 0.25, 0.0],+ [0.0, 0.5, 0.0],+ [0.0, 0.75, 0.0],+ [0.0, 0.999, 0.0],+ [0.0, 0.9999999, 0.0],+ [0.0, 1.0, 0.0],+ [1e-07, 0.0, 0.0],+ [1e-07, 1e-07, 0.0],+ [1e-07, 0.001, 0.0],+ [1e-07, 0.25, 1e-07],+ [1e-07, 0.5, 1e-07],+ [1e-07, 0.75, 2e-07],+ [1e-07, 0.999, 2e-07],+ [1e-07, 0.9999999, 2e-07],+ [1e-07, 1.0, 2e-07],+ [0.001, 0.0, 1e-06],+ [0.001, 1e-07, 1e-06],+ [0.001, 0.001, 3e-06],+ [0.001, 0.25, 0.0005005],+ [0.001, 0.5, 0.001],+ [0.001, 0.75, 0.0014995],+ [0.001, 0.999, 0.001997],+ [0.001, 0.9999999, 0.001999],+ [0.001, 1.0, 0.001999],+ [0.25, 0.0, 0.0625],+ [0.25, 1e-07, 0.0625001],+ [0.25, 0.001, 0.062875],+ [0.25, 0.25, 0.15625],+ [0.25, 0.5, 0.25],+ [0.25, 0.75, 0.34375],+ [0.25, 0.999, 0.437125],+ [0.25, 0.9999999, 0.4374999],+ [0.25, 1.0, 0.4375],+ [0.5, 0.0, 0.25],+ [0.5, 1e-07, 0.2500001],+ [0.5, 0.001, 0.2505],+ [0.5, 0.25, 0.375],+ [0.5, 0.5, 0.5],+ [0.5, 0.75, 0.625],+ [0.5, 0.999, 0.7495],+ [0.5, 0.9999999, 0.7499999],+ [0.5, 1.0, 0.75],+ [0.75, 0.0, 0.5625],+ [0.75, 1e-07, 0.5625],+ [0.75, 0.001, 0.562875],+ [0.75, 0.25, 0.65625],+ [0.75, 0.5, 0.75],+ [0.75, 0.75, 0.84375],+ [0.75, 0.999, 0.937125],+ [0.75, 0.9999999, 0.9375],+ [0.75, 1.0, 0.9375],+ [0.999, 0.0, 0.998001],+ [0.999, 1e-07, 0.998001],+ [0.999, 0.001, 0.9980031],+ [0.999, 0.25, 0.9985005],+ [0.999, 0.5, 0.999],+ [0.999, 0.75, 0.9994995],+ [0.999, 0.999, 0.999997],+ [0.999, 0.9999999, 0.999999],+ [0.999, 1.0, 0.999999],+ [0.9999999, 0.0, 0.9999998],+ [0.9999999, 1e-07, 0.9999998],+ [0.9999999, 0.001, 0.9999998],+ [0.9999999, 0.25, 0.9999998],+ [0.9999999, 0.5, 0.9999999],+ [0.9999999, 0.75, 0.9999999],+ [0.9999999, 0.999, 1.0],+ [0.9999999, 0.9999999, 1.0],+ [0.9999999, 1.0, 1.0],+ [1.0, 0.0, 1.0],+ [1.0, 1e-07, 1.0],+ [1.0, 0.001, 1.0],+ [1.0, 0.25, 1.0],+ [1.0, 0.5, 1.0],+ [1.0, 0.75, 1.0],+ [1.0, 0.999, 1.0],+ [1.0, 0.9999999, 1.0],+ [1.0, 1.0, 1.0]+ ],+ "subtract": [+ [0.0, 0.0, 0.0],+ [0.0, 1e-07, 0.0],+ [0.0, 0.001, 0.0],+ [0.0, 0.25, 0.0],+ [0.0, 0.5, 0.0],+ [0.0, 0.75, 0.0],+ [0.0, 0.999, 0.0],+ [0.0, 0.9999999, 0.0],+ [0.0, 1.0, 0.0],+ [1e-07, 0.0, 1e-07],+ [1e-07, 1e-07, 0.0],+ [1e-07, 0.001, 0.0],+ [1e-07, 0.25, 0.0],+ [1e-07, 0.5, 0.0],+ [1e-07, 0.75, 0.0],+ [1e-07, 0.999, 0.0],+ [1e-07, 0.9999999, 0.0],+ [1e-07, 1.0, 0.0],+ [0.001, 0.0, 0.001],+ [0.001, 1e-07, 0.0009999],+ [0.001, 0.001, 0.0],+ [0.001, 0.25, 0.0],+ [0.001, 0.5, 0.0],+ [0.001, 0.75, 0.0],+ [0.001, 0.999, 0.0],+ [0.001, 0.9999999, 0.0],+ [0.001, 1.0, 0.0],+ [0.25, 0.0, 0.25],+ [0.25, 1e-07, 0.2499999],+ [0.25, 0.001, 0.249],+ [0.25, 0.25, 0.0],+ [0.25, 0.5, 0.0],+ [0.25, 0.75, 0.0],+ [0.25, 0.999, 0.0],+ [0.25, 0.9999999, 0.0],+ [0.25, 1.0, 0.0],+ [0.5, 0.0, 0.5],+ [0.5, 1e-07, 0.4999999],+ [0.5, 0.001, 0.499],+ [0.5, 0.25, 0.25],+ [0.5, 0.5, 0.0],+ [0.5, 0.75, 0.0],+ [0.5, 0.999, 0.0],+ [0.5, 0.9999999, 0.0],+ [0.5, 1.0, 0.0],+ [0.75, 0.0, 0.75],+ [0.75, 1e-07, 0.7499999],+ [0.75, 0.001, 0.749],+ [0.75, 0.25, 0.5],+ [0.75, 0.5, 0.25],+ [0.75, 0.75, 0.0],+ [0.75, 0.999, 0.0],+ [0.75, 0.9999999, 0.0],+ [0.75, 1.0, 0.0],+ [0.999, 0.0, 0.999],+ [0.999, 1e-07, 0.9989999],+ [0.999, 0.001, 0.998],+ [0.999, 0.25, 0.749],+ [0.999, 0.5, 0.499],+ [0.999, 0.75, 0.249],+ [0.999, 0.999, 0.0],+ [0.999, 0.9999999, 0.0],+ [0.999, 1.0, 0.0],+ [0.9999999, 0.0, 0.9999999],+ [0.9999999, 1e-07, 0.9999998],+ [0.9999999, 0.001, 0.9989999],+ [0.9999999, 0.25, 0.7499999],+ [0.9999999, 0.5, 0.4999999],+ [0.9999999, 0.75, 0.2499999],+ [0.9999999, 0.999, 0.0009999],+ [0.9999999, 0.9999999, 0.0],+ [0.9999999, 1.0, 0.0],+ [1.0, 0.0, 1.0],+ [1.0, 1e-07, 0.9999999],+ [1.0, 0.001, 0.999],+ [1.0, 0.25, 0.75],+ [1.0, 0.5, 0.5],+ [1.0, 0.75, 0.25],+ [1.0, 0.999, 0.001],+ [1.0, 0.9999999, 1e-07],+ [1.0, 1.0, 0.0]+ ],+ "vivid-light": [+ [0.0, 0.0, 0.0],+ [0.0, 1e-07, 0.0],+ [0.0, 0.001, 0.0],+ [0.0, 0.25, 0.0],+ [0.0, 0.5, 0.0],+ [0.0, 0.75, 0.0],+ [0.0, 0.999, 0.0],+ [0.0, 0.9999999, 0.0],+ [0.0, 1.0, 0.0],+ [1e-07, 0.0, 0.0],+ [1e-07, 1e-07, 0.0],+ [1e-07, 0.001, 0.0],+ [1e-07, 0.25, 0.0],+ [1e-07, 0.5, 1e-07],+ [1e-07, 0.75, 2e-07],+ [1e-07, 0.999, 5e-05],+ [1e-07, 0.9999999, 1.0],+ [1e-07, 1.0, 1.0],+ [0.001, 0.0, 0.0],+ [0.001, 1e-07, 0.0],+ [0.001, 0.001, 0.0],+ [0.001, 0.25, 0.0],+ [0.001, 0.5, 0.001],+ [0.001, 0.75, 0.002],+ [0.001, 0.999, 0.5000064],+ [0.001, 0.9999999, 1.0],+ [0.001, 1.0, 1.0],+ [0.25, 0.0, 0.0],+ [0.25, 1e-07, 0.0],+ [0.25, 0.001, 0.0],+ [0.25, 0.25, 0.0],+ [0.25, 0.5, 0.25],+ [0.25, 0.75, 0.5],+ [0.25, 0.999, 1.0],+ [0.25, 0.9999999, 1.0],+ [0.25, 1.0, 1.0],+ [0.5, 0.0, 0.0],+ [0.5, 1e-07, 0.0],+ [0.5, 0.001, 0.0],+ [0.5, 0.25, 0.0],+ [0.5, 0.5, 0.5],+ [0.5, 0.75, 1.0],+ [0.5, 0.999, 1.0],+ [0.5, 0.9999999, 1.0],+ [0.5, 1.0, 1.0],+ [0.75, 0.0, 0.0],+ [0.75, 1e-07, 0.0],+ [0.75, 0.001, 0.0],+ [0.75, 0.25, 0.5],+ [0.75, 0.5, 0.75],+ [0.75, 0.75, 1.0],+ [0.75, 0.999, 1.0],+ [0.75, 0.9999999, 1.0],+ [0.75, 1.0, 1.0],+ [0.999, 0.0, 0.0],+ [0.999, 1e-07, 0.0],+ [0.999, 0.001, 0.5000064],+ [0.999, 0.25, 0.998],+ [0.999, 0.5, 0.999],+ [0.999, 0.75, 1.0],+ [0.999, 0.999, 1.0],+ [0.999, 0.9999999, 1.0],+ [0.999, 1.0, 1.0],+ [0.9999999, 0.0, 0.0],+ [0.9999999, 1e-07, 0.0],+ [0.9999999, 0.001, 0.9999404],+ [0.9999999, 0.25, 0.9999998],+ [0.9999999, 0.5, 0.9999999],+ [0.9999999, 0.75, 1.0],+ [0.9999999, 0.999, 1.0],+ [0.9999999, 0.9999999, 1.0],+ [0.9999999, 1.0, 1.0],+ [1.0, 0.0, 1.0],+ [1.0, 1e-07, 1.0],+ [1.0, 0.001, 1.0],+ [1.0, 0.25, 1.0],+ [1.0, 0.5, 1.0],+ [1.0, 0.75, 1.0],+ [1.0, 0.999, 1.0],+ [1.0, 0.9999999, 1.0],+ [1.0, 1.0, 1.0]+ ]+ },+ "hsl": {+ "color": [+ [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [1.0, 1.0, 1.0], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [0.5, 0.5, 0.5], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [0.0, 0.0, 1.0], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [0.2, 0.4, 0.6], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [0.9, 0.1, 0.35], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [1e-07, 1e-07, 1e-07], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [1e-07, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [0.05, 0.05, 0.05], [0.0, 0.0, 0.0]],+ [[1.0, 1.0, 1.0], [0.0, 0.0, 0.0], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [0.5, 0.5, 0.5], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [1.0, 0.0, 0.0], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [0.0, 0.0, 1.0], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [0.2, 0.4, 0.6], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [0.9, 0.1, 0.35], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [1e-07, 1e-07, 1e-07], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [1e-07, 0.0, 0.0], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [0.05, 0.05, 0.05], [1.0, 1.0, 1.0]],+ [[0.5, 0.5, 0.5], [0.0, 0.0, 0.0], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [1.0, 1.0, 1.0], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [0.5, 0.5, 0.5], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [1.0, 0.0, 0.0], [1.0, 0.0, 0.0]],+ [[0.5, 0.5, 0.5], [0.0, 0.0, 1.0], [0.0, 0.0, 1.0]],+ [[0.5, 0.5, 0.5], [0.2, 0.4, 0.6], [0.25, 0.5, 0.75]],+ [[0.5, 0.5, 0.5], [0.9, 0.1, 0.35], [0.9, 0.1, 0.35]],+ [[0.5, 0.5, 0.5], [1e-07, 1e-07, 1e-07], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [1e-07, 0.0, 0.0], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [0.05, 0.05, 0.05], [0.5, 0.5, 0.5]],+ [[1.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.5, 0.5, 0.5]],+ [[1.0, 0.0, 0.0], [1.0, 1.0, 1.0], [0.5, 0.5, 0.5]],+ [[1.0, 0.0, 0.0], [0.5, 0.5, 0.5], [0.5, 0.5, 0.5]],+ [[1.0, 0.0, 0.0], [1.0, 0.0, 0.0], [1.0, 0.0, 0.0]],+ [[1.0, 0.0, 0.0], [0.0, 0.0, 1.0], [0.0, 0.0, 1.0]],+ [[1.0, 0.0, 0.0], [0.2, 0.4, 0.6], [0.25, 0.5, 0.75]],+ [[1.0, 0.0, 0.0], [0.9, 0.1, 0.35], [0.9, 0.1, 0.35]],+ [[1.0, 0.0, 0.0], [1e-07, 1e-07, 1e-07], [0.5, 0.5, 0.5]],+ [[1.0, 0.0, 0.0], [1e-07, 0.0, 0.0], [0.5, 0.5, 0.5]],+ [[1.0, 0.0, 0.0], [0.05, 0.05, 0.05], [0.5, 0.5, 0.5]],+ [[0.0, 0.0, 1.0], [0.0, 0.0, 0.0], [0.5, 0.5, 0.5]],+ [[0.0, 0.0, 1.0], [1.0, 1.0, 1.0], [0.5, 0.5, 0.5]],+ [[0.0, 0.0, 1.0], [0.5, 0.5, 0.5], [0.5, 0.5, 0.5]],+ [[0.0, 0.0, 1.0], [1.0, 0.0, 0.0], [1.0, 0.0, 0.0]],+ [[0.0, 0.0, 1.0], [0.0, 0.0, 1.0], [0.0, 0.0, 1.0]],+ [[0.0, 0.0, 1.0], [0.2, 0.4, 0.6], [0.25, 0.5, 0.75]],+ [[0.0, 0.0, 1.0], [0.9, 0.1, 0.35], [0.9, 0.1, 0.35]],+ [[0.0, 0.0, 1.0], [1e-07, 1e-07, 1e-07], [0.5, 0.5, 0.5]],+ [[0.0, 0.0, 1.0], [1e-07, 0.0, 0.0], [0.5, 0.5, 0.5]],+ [[0.0, 0.0, 1.0], [0.05, 0.05, 0.05], [0.5, 0.5, 0.5]],+ [[0.2, 0.4, 0.6], [0.0, 0.0, 0.0], [0.4, 0.4, 0.4]],+ [[0.2, 0.4, 0.6], [1.0, 1.0, 1.0], [0.4, 0.4, 0.4]],+ [[0.2, 0.4, 0.6], [0.5, 0.5, 0.5], [0.4, 0.4, 0.4]],+ [[0.2, 0.4, 0.6], [1.0, 0.0, 0.0], [0.8, 0.0, 0.0]],+ [[0.2, 0.4, 0.6], [0.0, 0.0, 1.0], [0.0, 0.0, 0.8]],+ [[0.2, 0.4, 0.6], [0.2, 0.4, 0.6], [0.2, 0.4, 0.6]],+ [[0.2, 0.4, 0.6], [0.9, 0.1, 0.35], [0.72, 0.08, 0.28]],+ [[0.2, 0.4, 0.6], [1e-07, 1e-07, 1e-07], [0.4, 0.4, 0.4]],+ [[0.2, 0.4, 0.6], [1e-07, 0.0, 0.0], [0.4, 0.4, 0.4]],+ [[0.2, 0.4, 0.6], [0.05, 0.05, 0.05], [0.4, 0.4, 0.4]],+ [[0.9, 0.1, 0.35], [0.0, 0.0, 0.0], [0.5, 0.5, 0.5]],+ [[0.9, 0.1, 0.35], [1.0, 1.0, 1.0], [0.5, 0.5, 0.5]],+ [[0.9, 0.1, 0.35], [0.5, 0.5, 0.5], [0.5, 0.5, 0.5]],+ [[0.9, 0.1, 0.35], [1.0, 0.0, 0.0], [1.0, 0.0, 0.0]],+ [[0.9, 0.1, 0.35], [0.0, 0.0, 1.0], [0.0, 0.0, 1.0]],+ [[0.9, 0.1, 0.35], [0.2, 0.4, 0.6], [0.25, 0.5, 0.75]],+ [[0.9, 0.1, 0.35], [0.9, 0.1, 0.35], [0.9, 0.1, 0.35]],+ [[0.9, 0.1, 0.35], [1e-07, 1e-07, 1e-07], [0.5, 0.5, 0.5]],+ [[0.9, 0.1, 0.35], [1e-07, 0.0, 0.0], [0.5, 0.5, 0.5]],+ [[0.9, 0.1, 0.35], [0.05, 0.05, 0.05], [0.5, 0.5, 0.5]],+ [[1e-07, 1e-07, 1e-07], [0.0, 0.0, 0.0], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [1.0, 1.0, 1.0], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [0.5, 0.5, 0.5], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [1.0, 0.0, 0.0], [2e-07, 0.0, 0.0]],+ [[1e-07, 1e-07, 1e-07], [0.0, 0.0, 1.0], [0.0, 0.0, 2e-07]],+ [[1e-07, 1e-07, 1e-07], [0.2, 0.4, 0.6], [1e-07, 1e-07, 2e-07]],+ [[1e-07, 1e-07, 1e-07], [0.9, 0.1, 0.35], [2e-07, 0.0, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [1e-07, 1e-07, 1e-07], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [1e-07, 0.0, 0.0], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [0.05, 0.05, 0.05], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 0.0, 0.0], [0.0, 0.0, 0.0], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 0.0, 0.0], [1.0, 1.0, 1.0], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 0.0, 0.0], [0.5, 0.5, 0.5], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 0.0, 0.0], [1.0, 0.0, 0.0], [1e-07, 0.0, 0.0]],+ [[1e-07, 0.0, 0.0], [0.0, 0.0, 1.0], [0.0, 0.0, 1e-07]],+ [[1e-07, 0.0, 0.0], [0.2, 0.4, 0.6], [0.0, 1e-07, 1e-07]],+ [[1e-07, 0.0, 0.0], [0.9, 0.1, 0.35], [1e-07, 0.0, 0.0]],+ [[1e-07, 0.0, 0.0], [1e-07, 1e-07, 1e-07], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 0.0, 0.0], [1e-07, 0.0, 0.0], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 0.0, 0.0], [0.05, 0.05, 0.05], [1e-07, 1e-07, 1e-07]],+ [[0.05, 0.05, 0.05], [0.0, 0.0, 0.0], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [1.0, 1.0, 1.0], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [0.5, 0.5, 0.5], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [1.0, 0.0, 0.0], [0.1, 0.0, 0.0]],+ [[0.05, 0.05, 0.05], [0.0, 0.0, 1.0], [0.0, 0.0, 0.1]],+ [[0.05, 0.05, 0.05], [0.2, 0.4, 0.6], [0.025, 0.05, 0.075]],+ [[0.05, 0.05, 0.05], [0.9, 0.1, 0.35], [0.09, 0.01, 0.035]],+ [[0.05, 0.05, 0.05], [1e-07, 1e-07, 1e-07], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [1e-07, 0.0, 0.0], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [0.05, 0.05, 0.05], [0.05, 0.05, 0.05]]+ ],+ "hue": [+ [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [1.0, 1.0, 1.0], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [0.5, 0.5, 0.5], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [0.0, 0.0, 1.0], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [0.2, 0.4, 0.6], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [0.9, 0.1, 0.35], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [1e-07, 1e-07, 1e-07], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [1e-07, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [0.05, 0.05, 0.05], [0.0, 0.0, 0.0]],+ [[1.0, 1.0, 1.0], [0.0, 0.0, 0.0], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [0.5, 0.5, 0.5], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [1.0, 0.0, 0.0], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [0.0, 0.0, 1.0], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [0.2, 0.4, 0.6], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [0.9, 0.1, 0.35], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [1e-07, 1e-07, 1e-07], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [1e-07, 0.0, 0.0], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [0.05, 0.05, 0.05], [1.0, 1.0, 1.0]],+ [[0.5, 0.5, 0.5], [0.0, 0.0, 0.0], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [1.0, 1.0, 1.0], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [0.5, 0.5, 0.5], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [1.0, 0.0, 0.0], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [0.0, 0.0, 1.0], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [0.2, 0.4, 0.6], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [0.9, 0.1, 0.35], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [1e-07, 1e-07, 1e-07], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [1e-07, 0.0, 0.0], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [0.05, 0.05, 0.05], [0.5, 0.5, 0.5]],+ [[1.0, 0.0, 0.0], [0.0, 0.0, 0.0], [1.0, 0.0, 0.0]],+ [[1.0, 0.0, 0.0], [1.0, 1.0, 1.0], [1.0, 0.0, 0.0]],+ [[1.0, 0.0, 0.0], [0.5, 0.5, 0.5], [1.0, 0.0, 0.0]],+ [[1.0, 0.0, 0.0], [1.0, 0.0, 0.0], [1.0, 0.0, 0.0]],+ [[1.0, 0.0, 0.0], [0.0, 0.0, 1.0], [0.0, 0.0, 1.0]],+ [[1.0, 0.0, 0.0], [0.2, 0.4, 0.6], [1e-07, 0.5000001, 1.0]],+ [[1.0, 0.0, 0.0], [0.9, 0.1, 0.35], [1.0, -1e-07, 0.3124999]],+ [[1.0, 0.0, 0.0], [1e-07, 1e-07, 1e-07], [1.0, 0.0, 0.0]],+ [[1.0, 0.0, 0.0], [1e-07, 0.0, 0.0], [1.0, 0.0, 0.0]],+ [[1.0, 0.0, 0.0], [0.05, 0.05, 0.05], [1.0, 0.0, 0.0]],+ [[0.0, 0.0, 1.0], [0.0, 0.0, 0.0], [0.0, 0.0, 1.0]],+ [[0.0, 0.0, 1.0], [1.0, 1.0, 1.0], [0.0, 0.0, 1.0]],+ [[0.0, 0.0, 1.0], [0.5, 0.5, 0.5], [0.0, 0.0, 1.0]],+ [[0.0, 0.0, 1.0], [1.0, 0.0, 0.0], [1.0, 0.0, 0.0]],+ [[0.0, 0.0, 1.0], [0.0, 0.0, 1.0], [0.0, 0.0, 1.0]],+ [[0.0, 0.0, 1.0], [0.2, 0.4, 0.6], [1e-07, 0.5000001, 1.0]],+ [[0.0, 0.0, 1.0], [0.9, 0.1, 0.35], [1.0, -1e-07, 0.3124999]],+ [[0.0, 0.0, 1.0], [1e-07, 1e-07, 1e-07], [0.0, 0.0, 1.0]],+ [[0.0, 0.0, 1.0], [1e-07, 0.0, 0.0], [0.0, 0.0, 1.0]],+ [[0.0, 0.0, 1.0], [0.05, 0.05, 0.05], [0.0, 0.0, 1.0]],+ [[0.2, 0.4, 0.6], [0.0, 0.0, 0.0], [0.2, 0.4, 0.6]],+ [[0.2, 0.4, 0.6], [1.0, 1.0, 1.0], [0.2, 0.4, 0.6]],+ [[0.2, 0.4, 0.6], [0.5, 0.5, 0.5], [0.2, 0.4, 0.6]],+ [[0.2, 0.4, 0.6], [1.0, 0.0, 0.0], [0.6, 0.2, 0.2]],+ [[0.2, 0.4, 0.6], [0.0, 0.0, 1.0], [0.2, 0.2, 0.6]],+ [[0.2, 0.4, 0.6], [0.2, 0.4, 0.6], [0.2, 0.4, 0.6]],+ [[0.2, 0.4, 0.6], [0.9, 0.1, 0.35], [0.6, 0.2, 0.325]],+ [[0.2, 0.4, 0.6], [1e-07, 1e-07, 1e-07], [0.2, 0.4, 0.6]],+ [[0.2, 0.4, 0.6], [1e-07, 0.0, 0.0], [0.2, 0.4, 0.6]],+ [[0.2, 0.4, 0.6], [0.05, 0.05, 0.05], [0.2, 0.4, 0.6]],+ [[0.9, 0.1, 0.35], [0.0, 0.0, 0.0], [0.9, 0.1, 0.35]],+ [[0.9, 0.1, 0.35], [1.0, 1.0, 1.0], [0.9, 0.1, 0.35]],+ [[0.9, 0.1, 0.35], [0.5, 0.5, 0.5], [0.9, 0.1, 0.35]],+ [[0.9, 0.1, 0.35], [1.0, 0.0, 0.0], [0.9, 0.1, 0.1]],+ [[0.9, 0.1, 0.35], [0.0, 0.0, 1.0], [0.1, 0.1, 0.9]],+ [[0.9, 0.1, 0.35], [0.2, 0.4, 0.6], [0.1, 0.4999999, 0.9]],+ [[0.9, 0.1, 0.35], [0.9, 0.1, 0.35], [0.9, 0.1, 0.35]],+ [[0.9, 0.1, 0.35], [1e-07, 1e-07, 1e-07], [0.9, 0.1, 0.35]],+ [[0.9, 0.1, 0.35], [1e-07, 0.0, 0.0], [0.9, 0.1, 0.35]],+ [[0.9, 0.1, 0.35], [0.05, 0.05, 0.05], [0.9, 0.1, 0.35]],+ [[1e-07, 1e-07, 1e-07], [0.0, 0.0, 0.0], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [1.0, 1.0, 1.0], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [0.5, 0.5, 0.5], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [1.0, 0.0, 0.0], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [0.0, 0.0, 1.0], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [0.2, 0.4, 0.6], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [0.9, 0.1, 0.35], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [1e-07, 1e-07, 1e-07], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [1e-07, 0.0, 0.0], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [0.05, 0.05, 0.05], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 0.0, 0.0], [0.0, 0.0, 0.0], [1e-07, 0.0, 0.0]],+ [[1e-07, 0.0, 0.0], [1.0, 1.0, 1.0], [1e-07, 0.0, 0.0]],+ [[1e-07, 0.0, 0.0], [0.5, 0.5, 0.5], [1e-07, 0.0, 0.0]],+ [[1e-07, 0.0, 0.0], [1.0, 0.0, 0.0], [1e-07, 0.0, 0.0]],+ [[1e-07, 0.0, 0.0], [0.0, 0.0, 1.0], [0.0, 0.0, 1e-07]],+ [[1e-07, 0.0, 0.0], [0.2, 0.4, 0.6], [0.0, 0.0, 1e-07]],+ [[1e-07, 0.0, 0.0], [0.9, 0.1, 0.35], [1e-07, -0.0, 0.0]],+ [[1e-07, 0.0, 0.0], [1e-07, 1e-07, 1e-07], [1e-07, 0.0, 0.0]],+ [[1e-07, 0.0, 0.0], [1e-07, 0.0, 0.0], [1e-07, 0.0, 0.0]],+ [[1e-07, 0.0, 0.0], [0.05, 0.05, 0.05], [1e-07, 0.0, 0.0]],+ [[0.05, 0.05, 0.05], [0.0, 0.0, 0.0], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [1.0, 1.0, 1.0], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [0.5, 0.5, 0.5], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [1.0, 0.0, 0.0], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [0.0, 0.0, 1.0], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [0.2, 0.4, 0.6], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [0.9, 0.1, 0.35], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [1e-07, 1e-07, 1e-07], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [1e-07, 0.0, 0.0], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [0.05, 0.05, 0.05], [0.05, 0.05, 0.05]]+ ],+ "luminosity": [+ [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],+ [[0.0, 0.0, 0.0], [0.5, 0.5, 0.5], [0.5, 0.5, 0.5]],+ [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.2224884, 0.2224884, 0.2224884]],+ [[0.0, 0.0, 0.0], [0.0, 0.0, 1.0], [0.0606079, 0.0606079, 0.0606079]],+ [[0.0, 0.0, 0.0], [0.2, 0.4, 0.6], [0.3676239, 0.3676239, 0.3676239]],+ [[0.0, 0.0, 0.0], [0.9, 0.1, 0.35], [0.2931427, 0.2931427, 0.2931427]],+ [[0.0, 0.0, 0.0], [1e-07, 1e-07, 1e-07], [1e-07, 1e-07, 1e-07]],+ [[0.0, 0.0, 0.0], [1e-07, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [0.05, 0.05, 0.05], [0.05, 0.05, 0.05]],+ [[1.0, 1.0, 1.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [0.5, 0.5, 0.5], [0.5, 0.5, 0.5]],+ [[1.0, 1.0, 1.0], [1.0, 0.0, 0.0], [0.2224884, 0.2224884, 0.2224884]],+ [[1.0, 1.0, 1.0], [0.0, 0.0, 1.0], [0.0606079, 0.0606079, 0.0606079]],+ [[1.0, 1.0, 1.0], [0.2, 0.4, 0.6], [0.3676239, 0.3676239, 0.3676239]],+ [[1.0, 1.0, 1.0], [0.9, 0.1, 0.35], [0.2931427, 0.2931427, 0.2931427]],+ [[1.0, 1.0, 1.0], [1e-07, 1e-07, 1e-07], [1e-07, 1e-07, 1e-07]],+ [[1.0, 1.0, 1.0], [1e-07, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[1.0, 1.0, 1.0], [0.05, 0.05, 0.05], [0.05, 0.05, 0.05]],+ [[0.5, 0.5, 0.5], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[0.5, 0.5, 0.5], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],+ [[0.5, 0.5, 0.5], [0.5, 0.5, 0.5], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [1.0, 0.0, 0.0], [0.2224884, 0.2224884, 0.2224884]],+ [[0.5, 0.5, 0.5], [0.0, 0.0, 1.0], [0.0606079, 0.0606079, 0.0606079]],+ [[0.5, 0.5, 0.5], [0.2, 0.4, 0.6], [0.3676239, 0.3676239, 0.3676239]],+ [[0.5, 0.5, 0.5], [0.9, 0.1, 0.35], [0.2931427, 0.2931427, 0.2931427]],+ [[0.5, 0.5, 0.5], [1e-07, 1e-07, 1e-07], [1e-07, 1e-07, 1e-07]],+ [[0.5, 0.5, 0.5], [1e-07, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[0.5, 0.5, 0.5], [0.05, 0.05, 0.05], [0.05, 0.05, 0.05]],+ [[1.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[1.0, 0.0, 0.0], [1.0, 1.0, 1.0], [4.4946165, 0.0, 0.0]],+ [[1.0, 0.0, 0.0], [0.5, 0.5, 0.5], [2.2473083, 0.0, 0.0]],+ [[1.0, 0.0, 0.0], [1.0, 0.0, 0.0], [1.0, 0.0, 0.0]],+ [[1.0, 0.0, 0.0], [0.0, 0.0, 1.0], [0.2724093, 0.0, 0.0]],+ [[1.0, 0.0, 0.0], [0.2, 0.4, 0.6], [1.6523285, 0.0, 0.0]],+ [[1.0, 0.0, 0.0], [0.9, 0.1, 0.35], [1.3175639, 0.0, 0.0]],+ [[1.0, 0.0, 0.0], [1e-07, 1e-07, 1e-07], [4e-07, 0.0, 0.0]],+ [[1.0, 0.0, 0.0], [1e-07, 0.0, 0.0], [1e-07, 0.0, 0.0]],+ [[1.0, 0.0, 0.0], [0.05, 0.05, 0.05], [0.2247308, 0.0, 0.0]],+ [[0.0, 0.0, 1.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 1.0], [1.0, 1.0, 1.0], [0.0, 0.0, 16.4994965]],+ [[0.0, 0.0, 1.0], [0.5, 0.5, 0.5], [0.0, 0.0, 8.2497482]],+ [[0.0, 0.0, 1.0], [1.0, 0.0, 0.0], [0.0, 0.0, 3.6709466]],+ [[0.0, 0.0, 1.0], [0.0, 0.0, 1.0], [0.0, 0.0, 1.0]],+ [[0.0, 0.0, 1.0], [0.2, 0.4, 0.6], [0.0, 0.0, 6.0656095]],+ [[0.0, 0.0, 1.0], [0.9, 0.1, 0.35], [0.0, 0.0, 4.8367066]],+ [[0.0, 0.0, 1.0], [1e-07, 1e-07, 1e-07], [0.0, 0.0, 1.6e-06]],+ [[0.0, 0.0, 1.0], [1e-07, 0.0, 0.0], [0.0, 0.0, 4e-07]],+ [[0.0, 0.0, 1.0], [0.05, 0.05, 0.05], [0.0, 0.0, 0.8249749]],+ [[0.2, 0.4, 0.6], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[0.2, 0.4, 0.6], [1.0, 1.0, 1.0], [0.5440342, 1.0880685, 1.6321028]],+ [[0.2, 0.4, 0.6], [0.5, 0.5, 0.5], [0.2720171, 0.5440342, 0.8160514]],+ [[0.2, 0.4, 0.6], [1.0, 0.0, 0.0], [0.1210413, 0.2420826, 0.363124]],+ [[0.2, 0.4, 0.6], [0.0, 0.0, 1.0], [0.0329728, 0.0659456, 0.0989183]],+ [[0.2, 0.4, 0.6], [0.2, 0.4, 0.6], [0.2, 0.4, 0.6]],+ [[0.2, 0.4, 0.6], [0.9, 0.1, 0.35], [0.1594797, 0.3189593, 0.478439]],+ [[0.2, 0.4, 0.6], [1e-07, 1e-07, 1e-07], [1e-07, 1e-07, 2e-07]],+ [[0.2, 0.4, 0.6], [1e-07, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[0.2, 0.4, 0.6], [0.05, 0.05, 0.05], [0.0272017, 0.0544034, 0.0816052]],+ [[0.9, 0.1, 0.35], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[0.9, 0.1, 0.35], [1.0, 1.0, 1.0], [3.0701771, 0.3411308, 1.1939578]],+ [[0.9, 0.1, 0.35], [0.5, 0.5, 0.5], [1.5350885, 0.1705654, 0.5969789]],+ [[0.9, 0.1, 0.35], [1.0, 0.0, 0.0], [0.6830788, 0.0758977, 0.2656418]],+ [[0.9, 0.1, 0.35], [0.0, 0.0, 1.0], [0.186077, 0.0206752, 0.0723633]],+ [[0.9, 0.1, 0.35], [0.2, 0.4, 0.6], [1.1286706, 0.1254079, 0.4389275]],+ [[0.9, 0.1, 0.35], [0.9, 0.1, 0.35], [0.9, 0.1, 0.35]],+ [[0.9, 0.1, 0.35], [1e-07, 1e-07, 1e-07], [3e-07, 0.0, 1e-07]],+ [[0.9, 0.1, 0.35], [1e-07, 0.0, 0.0], [1e-07, 0.0, 0.0]],+ [[0.9, 0.1, 0.35], [0.05, 0.05, 0.05], [0.1535089, 0.0170565, 0.0596979]],+ [[1e-07, 1e-07, 1e-07], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[1e-07, 1e-07, 1e-07], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],+ [[1e-07, 1e-07, 1e-07], [0.5, 0.5, 0.5], [0.5, 0.5, 0.5]],+ [[1e-07, 1e-07, 1e-07], [1.0, 0.0, 0.0], [0.2224884, 0.2224884, 0.2224884]],+ [[1e-07, 1e-07, 1e-07], [0.0, 0.0, 1.0], [0.0606079, 0.0606079, 0.0606079]],+ [[1e-07, 1e-07, 1e-07], [0.2, 0.4, 0.6], [0.3676239, 0.3676239, 0.3676239]],+ [[1e-07, 1e-07, 1e-07], [0.9, 0.1, 0.35], [0.2931427, 0.2931427, 0.2931427]],+ [[1e-07, 1e-07, 1e-07], [1e-07, 1e-07, 1e-07], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [1e-07, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[1e-07, 1e-07, 1e-07], [0.05, 0.05, 0.05], [0.05, 0.05, 0.05]],+ [[1e-07, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[1e-07, 0.0, 0.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],+ [[1e-07, 0.0, 0.0], [0.5, 0.5, 0.5], [0.5, 0.5, 0.5]],+ [[1e-07, 0.0, 0.0], [1.0, 0.0, 0.0], [0.2224884, 0.2224884, 0.2224884]],+ [[1e-07, 0.0, 0.0], [0.0, 0.0, 1.0], [0.0606079, 0.0606079, 0.0606079]],+ [[1e-07, 0.0, 0.0], [0.2, 0.4, 0.6], [0.3676239, 0.3676239, 0.3676239]],+ [[1e-07, 0.0, 0.0], [0.9, 0.1, 0.35], [0.2931427, 0.2931427, 0.2931427]],+ [[1e-07, 0.0, 0.0], [1e-07, 1e-07, 1e-07], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 0.0, 0.0], [1e-07, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[1e-07, 0.0, 0.0], [0.05, 0.05, 0.05], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[0.05, 0.05, 0.05], [1.0, 1.0, 1.0], [0.9999999, 0.9999999, 0.9999999]],+ [[0.05, 0.05, 0.05], [0.5, 0.5, 0.5], [0.5, 0.5, 0.5]],+ [[0.05, 0.05, 0.05], [1.0, 0.0, 0.0], [0.2224884, 0.2224884, 0.2224884]],+ [[0.05, 0.05, 0.05], [0.0, 0.0, 1.0], [0.0606079, 0.0606079, 0.0606079]],+ [[0.05, 0.05, 0.05], [0.2, 0.4, 0.6], [0.3676239, 0.3676239, 0.3676239]],+ [[0.05, 0.05, 0.05], [0.9, 0.1, 0.35], [0.2931426, 0.2931426, 0.2931426]],+ [[0.05, 0.05, 0.05], [1e-07, 1e-07, 1e-07], [1e-07, 1e-07, 1e-07]],+ [[0.05, 0.05, 0.05], [1e-07, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[0.05, 0.05, 0.05], [0.05, 0.05, 0.05], [0.05, 0.05, 0.05]]+ ],+ "saturation": [+ [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [1.0, 1.0, 1.0], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [0.5, 0.5, 0.5], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [0.0, 0.0, 1.0], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [0.2, 0.4, 0.6], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [0.9, 0.1, 0.35], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [1e-07, 1e-07, 1e-07], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [1e-07, 0.0, 0.0], [0.0, 0.0, 0.0]],+ [[0.0, 0.0, 0.0], [0.05, 0.05, 0.05], [0.0, 0.0, 0.0]],+ [[1.0, 1.0, 1.0], [0.0, 0.0, 0.0], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [0.5, 0.5, 0.5], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [1.0, 0.0, 0.0], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [0.0, 0.0, 1.0], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [0.2, 0.4, 0.6], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [0.9, 0.1, 0.35], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [1e-07, 1e-07, 1e-07], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [1e-07, 0.0, 0.0], [1.0, 1.0, 1.0]],+ [[1.0, 1.0, 1.0], [0.05, 0.05, 0.05], [1.0, 1.0, 1.0]],+ [[0.5, 0.5, 0.5], [0.0, 0.0, 0.0], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [1.0, 1.0, 1.0], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [0.5, 0.5, 0.5], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [1.0, 0.0, 0.0], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [0.0, 0.0, 1.0], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [0.2, 0.4, 0.6], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [0.9, 0.1, 0.35], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [1e-07, 1e-07, 1e-07], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [1e-07, 0.0, 0.0], [0.5, 0.5, 0.5]],+ [[0.5, 0.5, 0.5], [0.05, 0.05, 0.05], [0.5, 0.5, 0.5]],+ [[1.0, 0.0, 0.0], [0.0, 0.0, 0.0], [1.0, 1.0, 1.0]],+ [[1.0, 0.0, 0.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],+ [[1.0, 0.0, 0.0], [0.5, 0.5, 0.5], [1.0, 1.0, 1.0]],+ [[1.0, 0.0, 0.0], [1.0, 0.0, 0.0], [1.0, 0.0, 0.0]],+ [[1.0, 0.0, 0.0], [0.0, 0.0, 1.0], [1.0, 0.0, 0.0]],+ [[1.0, 0.0, 0.0], [0.2, 0.4, 0.6], [1.0, 0.3333333, 0.3333333]],+ [[1.0, 0.0, 0.0], [0.9, 0.1, 0.35], [1.0, 0.1111112, 0.1111112]],+ [[1.0, 0.0, 0.0], [1e-07, 1e-07, 1e-07], [1.0, 1.0, 1.0]],+ [[1.0, 0.0, 0.0], [1e-07, 0.0, 0.0], [1.0, 0.0, 0.0]],+ [[1.0, 0.0, 0.0], [0.05, 0.05, 0.05], [1.0, 1.0, 1.0]],+ [[0.0, 0.0, 1.0], [0.0, 0.0, 0.0], [1.0, 1.0, 1.0]],+ [[0.0, 0.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],+ [[0.0, 0.0, 1.0], [0.5, 0.5, 0.5], [1.0, 1.0, 1.0]],+ [[0.0, 0.0, 1.0], [1.0, 0.0, 0.0], [0.0, 0.0, 1.0]],+ [[0.0, 0.0, 1.0], [0.0, 0.0, 1.0], [0.0, 0.0, 1.0]],+ [[0.0, 0.0, 1.0], [0.2, 0.4, 0.6], [0.3333333, 0.3333333, 1.0]],+ [[0.0, 0.0, 1.0], [0.9, 0.1, 0.35], [0.1111112, 0.1111112, 1.0]],+ [[0.0, 0.0, 1.0], [1e-07, 1e-07, 1e-07], [1.0, 1.0, 1.0]],+ [[0.0, 0.0, 1.0], [1e-07, 0.0, 0.0], [0.0, 0.0, 1.0]],+ [[0.0, 0.0, 1.0], [0.05, 0.05, 0.05], [1.0, 1.0, 1.0]],+ [[0.2, 0.4, 0.6], [0.0, 0.0, 0.0], [0.6, 0.6, 0.6]],+ [[0.2, 0.4, 0.6], [1.0, 1.0, 1.0], [0.6, 0.6, 0.6]],+ [[0.2, 0.4, 0.6], [0.5, 0.5, 0.5], [0.6, 0.6, 0.6]],+ [[0.2, 0.4, 0.6], [1.0, 0.0, 0.0], [0.0, 0.3, 0.6]],+ [[0.2, 0.4, 0.6], [0.0, 0.0, 1.0], [0.0, 0.3, 0.6]],+ [[0.2, 0.4, 0.6], [0.2, 0.4, 0.6], [0.2, 0.4, 0.6]],+ [[0.2, 0.4, 0.6], [0.9, 0.1, 0.35], [0.0666667, 0.3333334, 0.6]],+ [[0.2, 0.4, 0.6], [1e-07, 1e-07, 1e-07], [0.6, 0.6, 0.6]],+ [[0.2, 0.4, 0.6], [1e-07, 0.0, 0.0], [0.0, 0.3, 0.6]],+ [[0.2, 0.4, 0.6], [0.05, 0.05, 0.05], [0.6, 0.6, 0.6]],+ [[0.9, 0.1, 0.35], [0.0, 0.0, 0.0], [0.9, 0.9, 0.9]],+ [[0.9, 0.1, 0.35], [1.0, 1.0, 1.0], [0.9, 0.9, 0.9]],+ [[0.9, 0.1, 0.35], [0.5, 0.5, 0.5], [0.9, 0.9, 0.9]],+ [[0.9, 0.1, 0.35], [1.0, 0.0, 0.0], [0.8999999, 0.0, 0.28125]],+ [[0.9, 0.1, 0.35], [0.0, 0.0, 1.0], [0.8999999, 0.0, 0.28125]],+ [[0.9, 0.1, 0.35], [0.2, 0.4, 0.6], [0.9, 0.3, 0.4875]],+ [[0.9, 0.1, 0.35], [0.9, 0.1, 0.35], [0.9, 0.1, 0.35]],+ [[0.9, 0.1, 0.35], [1e-07, 1e-07, 1e-07], [0.9, 0.9, 0.9]],+ [[0.9, 0.1, 0.35], [1e-07, 0.0, 0.0], [0.8999999, 0.0, 0.28125]],+ [[0.9, 0.1, 0.35], [0.05, 0.05, 0.05], [0.9, 0.9, 0.9]],+ [[1e-07, 1e-07, 1e-07], [0.0, 0.0, 0.0], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [1.0, 1.0, 1.0], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [0.5, 0.5, 0.5], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [1.0, 0.0, 0.0], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [0.0, 0.0, 1.0], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [0.2, 0.4, 0.6], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [0.9, 0.1, 0.35], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [1e-07, 1e-07, 1e-07], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [1e-07, 0.0, 0.0], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 1e-07, 1e-07], [0.05, 0.05, 0.05], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 0.0, 0.0], [0.0, 0.0, 0.0], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 0.0, 0.0], [1.0, 1.0, 1.0], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 0.0, 0.0], [0.5, 0.5, 0.5], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 0.0, 0.0], [1.0, 0.0, 0.0], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 0.0, 0.0], [0.0, 0.0, 1.0], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 0.0, 0.0], [0.2, 0.4, 0.6], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 0.0, 0.0], [0.9, 0.1, 0.35], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 0.0, 0.0], [1e-07, 1e-07, 1e-07], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 0.0, 0.0], [1e-07, 0.0, 0.0], [1e-07, 1e-07, 1e-07]],+ [[1e-07, 0.0, 0.0], [0.05, 0.05, 0.05], [1e-07, 1e-07, 1e-07]],+ [[0.05, 0.05, 0.05], [0.0, 0.0, 0.0], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [1.0, 1.0, 1.0], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [0.5, 0.5, 0.5], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [1.0, 0.0, 0.0], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [0.0, 0.0, 1.0], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [0.2, 0.4, 0.6], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [0.9, 0.1, 0.35], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [1e-07, 1e-07, 1e-07], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [1e-07, 0.0, 0.0], [0.05, 0.05, 0.05]],+ [[0.05, 0.05, 0.05], [0.05, 0.05, 0.05], [0.05, 0.05, 0.05]]+ ]+ }+}diff --git a/tests-unit/comfy_extras_test/compositor_blend_test.py b/tests-unit/comfy_extras_test/compositor_blend_test.pynew file mode 100644index 000000000..6734ab637--- /dev/null+++ b/tests-unit/comfy_extras_test/compositor_blend_test.py@@ -0,0 +1,157 @@+"""Blend-mode parity tests for the compositor.++The compositor blends in three places: this numpy module (server-side), the+``layerBlend.frag`` GLSL shader (the live preview the user actually sees), and+anything the frontend adds later. They have diverged before, silently, and the+divergences only show up as "the render does not look like the preview".++``compositor_blend_golden.json`` is the shared contract. This file pins the+numpy implementation to it and additionally spells out, by hand, the boundary+rules that the epsilon guards exist to enforce - so a future refactor of+``safe_div`` cannot quietly re-introduce the old behaviour by regenerating the+fixture.+"""++import json+import os++import numpy as np+import pytest++from comfy_extras.compositor_blend import (+ CHANNEL_BLEND,+ HSL_BLEND,+ EffectiveMode,+ blend_composite,+ blend_pixel,+ resolve_mode,+)++GOLDEN_PATH = os.path.join(os.path.dirname(__file__), "compositor_blend_golden.json")++with open(GOLDEN_PATH) as _handle:+ GOLDEN = json.load(_handle)++TOLERANCE = GOLDEN["tolerance"]+++def _blend(mode: str, i, l) -> np.ndarray:+ return np.asarray(+ blend_pixel(mode, np.float32(i), np.float32(l)), dtype=np.float64+ ).reshape(3)+++def test_golden_covers_every_mode():+ """A new blend mode must arrive with golden values, not silently."""+ assert set(GOLDEN["channel"]) == set(CHANNEL_BLEND)+ assert set(GOLDEN["hsl"]) == set(HSL_BLEND)++[email protected]("mode", sorted(CHANNEL_BLEND))+def test_channel_modes_match_golden(mode):+ for i, l, expected in GOLDEN["channel"][mode]:+ actual = _blend(mode, [i] * 3, [l] * 3)+ assert actual == pytest.approx([expected] * 3, abs=TOLERANCE), (+ f"{mode}(i={i}, l={l}) -> {actual.tolist()}, golden {expected}"+ )++[email protected]("mode", sorted(HSL_BLEND))+def test_hsl_modes_match_golden(mode):+ for i, l, expected in GOLDEN["hsl"][mode]:+ actual = _blend(mode, i, l)+ assert actual == pytest.approx(expected, abs=TOLERANCE), (+ f"{mode}(i={i}, l={l}) -> {actual.tolist()}, golden {expected}"+ )++[email protected]("mode", sorted(set(CHANNEL_BLEND) | set(HSL_BLEND)))+def test_no_mode_produces_nan_or_inf(mode):+ edges = [0.0, 1e-7, 1e-6, 0.5, 1.0 - 1e-7, 1.0]+ for i in edges:+ for l in edges:+ out = _blend(mode, [i, 0.0, 1.0], [l, 1.0, 0.0])+ assert np.all(np.isfinite(out)), f"{mode}(i={i}, l={l}) -> {out.tolist()}"+++class TestBoundaryRules:+ """The rules the epsilon guards encode, written out independently of the fixture."""++ def test_color_dodge_full_layer_is_white_not_black(self):+ # Guarding the denominator returns 0 here, which reads as "the dodge+ # layer turned the image black" - the exact inversion CodeRabbit flagged.+ assert _blend("color-dodge", [0.5] * 3, [1.0] * 3) == pytest.approx([1.0] * 3)++ def test_color_dodge_black_backdrop_stays_black(self):+ assert _blend("color-dodge", [0.0] * 3, [1.0] * 3) == pytest.approx([0.0] * 3)++ def test_color_dodge_is_clamped(self):+ assert _blend("color-dodge", [0.6] * 3, [0.9] * 3) == pytest.approx([1.0] * 3)++ def test_color_burn_empty_layer_is_black_not_white(self):+ assert _blend("color-burn", [0.5] * 3, [0.0] * 3) == pytest.approx([0.0] * 3)++ def test_color_burn_white_backdrop_stays_white(self):+ assert _blend("color-burn", [1.0] * 3, [0.0] * 3) == pytest.approx([1.0] * 3)++ def test_vivid_light_boundaries(self):+ assert _blend("vivid-light", [0.5] * 3, [0.0] * 3) == pytest.approx([0.0] * 3)+ assert _blend("vivid-light", [0.5] * 3, [1.0] * 3) == pytest.approx([1.0] * 3)+ assert _blend("vivid-light", [1.0] * 3, [0.0] * 3) == pytest.approx([1.0] * 3)+ assert _blend("vivid-light", [0.0] * 3, [1.0] * 3) == pytest.approx([0.0] * 3)++ def test_divide_by_zero_is_clamped_to_one(self):+ assert _blend("divide", [0.5] * 3, [0.0] * 3) == pytest.approx([1.0] * 3)++ def test_luminosity_over_black_takes_the_layer_luminance(self):+ # A luminosity layer over a black backdrop must not vanish. There is no+ # hue or saturation in the backdrop to preserve, so the result is a+ # neutral grey at the layer's luminance.+ assert _blend("luminosity", [0.0] * 3, [1.0] * 3) == pytest.approx([1.0] * 3)+ assert _blend("luminosity", [0.0] * 3, [0.5] * 3) == pytest.approx([0.5] * 3)++ def test_luminosity_is_continuous_approaching_black(self):+ near = _blend("luminosity", [1e-7] * 3, [1.0] * 3)+ at = _blend("luminosity", [0.0] * 3, [1.0] * 3)+ assert near == pytest.approx(at, abs=TOLERANCE)++ def test_luminosity_preserves_backdrop_chroma(self):+ out = _blend("luminosity", [0.4, 0.2, 0.1], [0.5] * 3)+ assert out[0] > out[1] > out[2]+++class TestCompositeAndModeTable:+ def test_unknown_blend_mode_falls_back_to_normal(self):+ unknown = resolve_mode("not-a-mode")+ assert (unknown.blend_space, unknown.composite) == (+ resolve_mode("normal").blend_space,+ resolve_mode("normal").composite,+ )+ assert _blend("not-a-mode", [0.1, 0.2, 0.3], [0.4, 0.5, 0.6]) == pytest.approx(+ _blend("normal", [0.1, 0.2, 0.3], [0.4, 0.5, 0.6])+ )++ def test_every_blend_mode_has_a_composite_entry(self):+ for mode in set(CHANNEL_BLEND) | set(HSL_BLEND):+ resolved = resolve_mode(mode)+ assert isinstance(resolved, EffectiveMode)+ assert resolved.blend == mode+ assert resolved.blend_space in ("linear", "perceptual")+ assert resolved.composite in (+ "union",+ "clip-to-backdrop",+ "clip-to-layer",+ "intersection",+ )++ def test_normal_over_transparent_backdrop_keeps_the_layer(self):+ backdrop = np.zeros((1, 1, 4), dtype=np.float32)+ layer = np.float32([[[0.25, 0.5, 0.75, 1.0]]])+ out = blend_composite(resolve_mode("normal"), backdrop, layer, 1.0)+ assert out[0, 0].tolist() == pytest.approx([0.25, 0.5, 0.75, 1.0])++ def test_zero_opacity_is_a_no_op(self):+ backdrop = np.float32([[[0.1, 0.2, 0.3, 1.0]]])+ layer = np.float32([[[1.0, 1.0, 1.0, 1.0]]])+ out = blend_composite(resolve_mode("multiply"), backdrop, layer, 0.0)+ assert out[0, 0].tolist() == pytest.approx([0.1, 0.2, 0.3, 1.0])diff --git a/tests-unit/comfy_extras_test/compositor_node_test.py b/tests-unit/comfy_extras_test/compositor_node_test.pynew file mode 100644index 000000000..3a24c4dff--- /dev/null+++ b/tests-unit/comfy_extras_test/compositor_node_test.py@@ -0,0 +1,72 @@+"""Regression tests for ImageCompositor's handling of untrusted layer state.++The compositor's `compositor` widget value is persisted into the saved workflow+and is accepted verbatim on `POST /prompt`, so every field in it is untrusted+input, not an internal invariant.+"""++import numpy as np+import pytest+import torch++from comfy_extras.nodes_compositor import (+ _layer_params,+ composite_from_state,+ expand_item_frames,+ state_from_items,+)+++def _solid(color, w=4, h=4) -> torch.Tensor:+ frame = np.zeros((h, w, len(color)), dtype=np.float32)+ frame[:] = color+ return torch.from_numpy(frame).unsqueeze(0)+++class TestLayerOpacity:+ @pytest.mark.parametrize(+ ("raw", "expected"),+ [(-0.5, 0.0), (0.0, 0.0), (0.25, 0.25), (1.0, 1.0), (3.0, 1.0)],+ )+ def test_opacity_is_clamped(self, raw, expected):+ assert _layer_params({"opacity": raw}, 4, 4)["opacity"] == expected++ def test_opacity_defaults_to_opaque(self):+ assert _layer_params({}, 4, 4)["opacity"] == 1.0++ def test_out_of_range_opacity_does_not_leak_into_the_next_layer(self):+ # The canvas is only clamped once, after every layer has been composited,+ # so an out-of-range coverage multiplier on one layer changes the *blend*+ # of the layer above it. White at opacity 3.0 over black leaves the canvas+ # at 3.0; the multiply above it then reads 3.0 as its backdrop and the+ # result is visibly lighter than the same stack at opacity 1.0.+ def run(opacity):+ state = {+ "canvas": (2, 2),+ "layers": [{"opacity": opacity}, {"opacity": 1.0, "blend": "multiply"}],+ "inputs": None,+ "background": {"color": "#000000", "opacity": 1.0, "visible": True},+ "order": None,+ }+ tensors = [_solid([1.0, 1.0, 1.0], 2, 2), _solid([0.5, 0.5, 0.5], 2, 2)]+ return composite_from_state(tensors, state, [None, None])[0, 0, 0, :3]++ assert run(3.0).tolist() == pytest.approx(run(1.0).tolist(), abs=1e-6)+++class TestGraphOnlyBackground:+ def test_default_layout_background_is_hidden(self):+ # A visible white background here would make every graph-only run emit a+ # white matte instead of transparency.+ frames = expand_item_frames([{"image": _solid([1.0, 0.0, 0.0])}])+ state = state_from_items(frames, (4, 4))+ assert state["background"]["visible"] is False++ def test_uncovered_canvas_stays_transparent(self):+ tensors = [_solid([1.0, 0.0, 0.0], w=2, h=2)]+ frames = expand_item_frames([{"image": tensors[0]}])+ state = state_from_items(frames, (4, 4))+ out = composite_from_state(tensors, state, [None])[0]+ assert out.shape[-1] == 4+ assert float(out[0, 0, 3]) == pytest.approx(1.0)+ assert float(out[3, 3, 3]) == pytest.approx(0.0)