Upload 1633 files

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+comfyui_controlnet_aux/examples/example_mesh_graphormer.png filter=lfs diff=lfs merge=lfs -text
+comfyui_controlnet_aux/examples/ExecuteAll.png filter=lfs diff=lfs merge=lfs -text
+comfyui_controlnet_aux/examples/ExecuteAll1.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_controlnet_aux/examples/ExecuteAll2.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_controlnet_aux/src/custom_controlnet_aux/mesh_graphormer/hand_landmarker.task filter=lfs diff=lfs merge=lfs -text

ComfyUI_InstantID/.github/FUNDING.yml

@@ -0,0 +1 @@
+github: cubiq

ComfyUI_InstantID/.github/workflows/publish.yml

@@ -0,0 +1,22 @@
+name: Publish to Comfy registry
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+      - master
+    paths:
+      - "pyproject.toml"
+
+jobs:
+  publish-node:
+    name: Publish Custom Node to registry
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+      - name: Publish Custom Node
+        uses: Comfy-Org/publish-node-action@main
+        with:
+          ## Add your own personal access token to your Github Repository secrets and reference it here.
+          personal_access_token: ${{ secrets.REGISTRY_ACCESS_TOKEN }}

ComfyUI_InstantID/.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

ComfyUI_InstantID/CrossAttentionPatch.py

@@ -0,0 +1,190 @@
+import torch
+import math
+import torch.nn.functional as F
+from comfy.ldm.modules.attention import optimized_attention
+from .utils import tensor_to_size
+
+class Attn2Replace:
+    def __init__(self, callback=None, **kwargs):
+        self.callback = [callback]
+        self.kwargs = [kwargs]
+    
+    def add(self, callback, **kwargs):          
+        self.callback.append(callback)
+        self.kwargs.append(kwargs)
+
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+    def __call__(self, q, k, v, extra_options):
+        dtype = q.dtype
+        out = optimized_attention(q, k, v, extra_options["n_heads"])
+        sigma = extra_options["sigmas"].detach().cpu()[0].item() if 'sigmas' in extra_options else 999999999.9
+
+        for i, callback in enumerate(self.callback):
+            if sigma <= self.kwargs[i]["sigma_start"] and sigma >= self.kwargs[i]["sigma_end"]:
+                out = out + callback(out, q, k, v, extra_options, **self.kwargs[i])
+        
+        return out.to(dtype=dtype)
+
+def instantid_attention(out, q, k, v, extra_options, module_key='', ipadapter=None, weight=1.0, cond=None, cond_alt=None, uncond=None, weight_type="linear", mask=None, sigma_start=0.0, sigma_end=1.0, unfold_batch=False, embeds_scaling='V only', **kwargs):
+    dtype = q.dtype
+    cond_or_uncond = extra_options["cond_or_uncond"]
+    block_type = extra_options["block"][0]
+    #block_id = extra_options["block"][1]
+    t_idx = extra_options["transformer_index"]
+    layers = 11 if '101_to_k_ip' in ipadapter.ip_layers.to_kvs else 16
+    k_key = module_key + "_to_k_ip"
+    v_key = module_key + "_to_v_ip"
+
+    # extra options for AnimateDiff
+    ad_params = extra_options['ad_params'] if "ad_params" in extra_options else None
+
+    b = q.shape[0]
+    seq_len = q.shape[1]
+    batch_prompt = b // len(cond_or_uncond)
+    _, _, oh, ow = extra_options["original_shape"]
+
+    if weight_type == 'ease in':
+        weight = weight * (0.05 + 0.95 * (1 - t_idx / layers))
+    elif weight_type == 'ease out':
+        weight = weight * (0.05 + 0.95 * (t_idx / layers))
+    elif weight_type == 'ease in-out':
+        weight = weight * (0.05 + 0.95 * (1 - abs(t_idx - (layers/2)) / (layers/2)))
+    elif weight_type == 'reverse in-out':
+        weight = weight * (0.05 + 0.95 * (abs(t_idx - (layers/2)) / (layers/2)))
+    elif weight_type == 'weak input' and block_type == 'input':
+        weight = weight * 0.2
+    elif weight_type == 'weak middle' and block_type == 'middle':
+        weight = weight * 0.2
+    elif weight_type == 'weak output' and block_type == 'output':
+        weight = weight * 0.2
+    elif weight_type == 'strong middle' and (block_type == 'input' or block_type == 'output'):
+        weight = weight * 0.2
+    elif isinstance(weight, dict):
+        if t_idx not in weight:
+            return 0
+
+        weight = weight[t_idx]
+
+        if cond_alt is not None and t_idx in cond_alt:
+            cond = cond_alt[t_idx]
+            del cond_alt
+
+    if unfold_batch:
+        # Check AnimateDiff context window
+        if ad_params is not None and ad_params["sub_idxs"] is not None:
+            if isinstance(weight, torch.Tensor):
+                weight = tensor_to_size(weight, ad_params["full_length"])
+                weight = torch.Tensor(weight[ad_params["sub_idxs"]])
+                if torch.all(weight == 0):
+                    return 0
+                weight = weight.repeat(len(cond_or_uncond), 1, 1) # repeat for cond and uncond
+            elif weight == 0:
+                return 0
+
+            # if image length matches or exceeds full_length get sub_idx images
+            if cond.shape[0] >= ad_params["full_length"]:
+                cond = torch.Tensor(cond[ad_params["sub_idxs"]])
+                uncond = torch.Tensor(uncond[ad_params["sub_idxs"]])
+            # otherwise get sub_idxs images
+            else:
+                cond = tensor_to_size(cond, ad_params["full_length"])
+                uncond = tensor_to_size(uncond, ad_params["full_length"])
+                cond = cond[ad_params["sub_idxs"]]
+                uncond = uncond[ad_params["sub_idxs"]]
+        else:
+            if isinstance(weight, torch.Tensor):
+                weight = tensor_to_size(weight, batch_prompt)
+                if torch.all(weight == 0):
+                    return 0
+                weight = weight.repeat(len(cond_or_uncond), 1, 1) # repeat for cond and uncond
+            elif weight == 0:
+                return 0
+
+            cond = tensor_to_size(cond, batch_prompt)
+            uncond = tensor_to_size(uncond, batch_prompt)
+
+        k_cond = ipadapter.ip_layers.to_kvs[k_key](cond)
+        k_uncond = ipadapter.ip_layers.to_kvs[k_key](uncond)
+        v_cond = ipadapter.ip_layers.to_kvs[v_key](cond)
+        v_uncond = ipadapter.ip_layers.to_kvs[v_key](uncond)
+    else:
+        # TODO: should we always convert the weights to a tensor?
+        if isinstance(weight, torch.Tensor):
+            weight = tensor_to_size(weight, batch_prompt)
+            if torch.all(weight == 0):
+                return 0
+            weight = weight.repeat(len(cond_or_uncond), 1, 1) # repeat for cond and uncond
+        elif weight == 0:
+            return 0
+
+        k_cond = ipadapter.ip_layers.to_kvs[k_key](cond).repeat(batch_prompt, 1, 1)
+        k_uncond = ipadapter.ip_layers.to_kvs[k_key](uncond).repeat(batch_prompt, 1, 1)
+        v_cond = ipadapter.ip_layers.to_kvs[v_key](cond).repeat(batch_prompt, 1, 1)
+        v_uncond = ipadapter.ip_layers.to_kvs[v_key](uncond).repeat(batch_prompt, 1, 1)
+
+    ip_k = torch.cat([(k_cond, k_uncond)[i] for i in cond_or_uncond], dim=0)
+    ip_v = torch.cat([(v_cond, v_uncond)[i] for i in cond_or_uncond], dim=0)
+    
+    if embeds_scaling == 'K+mean(V) w/ C penalty':
+        scaling = float(ip_k.shape[2]) / 1280.0
+        weight = weight * scaling
+        ip_k = ip_k * weight
+        ip_v_mean = torch.mean(ip_v, dim=1, keepdim=True)
+        ip_v = (ip_v - ip_v_mean) + ip_v_mean * weight
+        out_ip = optimized_attention(q, ip_k, ip_v, extra_options["n_heads"])
+        del ip_v_mean
+    elif embeds_scaling == 'K+V w/ C penalty':
+        scaling = float(ip_k.shape[2]) / 1280.0
+        weight = weight * scaling
+        ip_k = ip_k * weight
+        ip_v = ip_v * weight
+        out_ip = optimized_attention(q, ip_k, ip_v, extra_options["n_heads"])
+    elif embeds_scaling == 'K+V':
+        ip_k = ip_k * weight
+        ip_v = ip_v * weight
+        out_ip = optimized_attention(q, ip_k, ip_v, extra_options["n_heads"])
+    else:
+        #ip_v = ip_v * weight
+        out_ip = optimized_attention(q, ip_k, ip_v, extra_options["n_heads"])
+        out_ip = out_ip * weight # I'm doing this to get the same results as before
+
+    if mask is not None:
+        mask_h = oh / math.sqrt(oh * ow / seq_len)
+        mask_h = int(mask_h) + int((seq_len % int(mask_h)) != 0)
+        mask_w = seq_len // mask_h
+
+        # check if using AnimateDiff and sliding context window
+        if (mask.shape[0] > 1 and ad_params is not None and ad_params["sub_idxs"] is not None):
+            # if mask length matches or exceeds full_length, get sub_idx masks
+            if mask.shape[0] >= ad_params["full_length"]:
+                mask = torch.Tensor(mask[ad_params["sub_idxs"]])
+                mask = F.interpolate(mask.unsqueeze(1), size=(mask_h, mask_w), mode="bilinear").squeeze(1)
+            else:
+                mask = F.interpolate(mask.unsqueeze(1), size=(mask_h, mask_w), mode="bilinear").squeeze(1)
+                mask = tensor_to_size(mask, ad_params["full_length"])
+                mask = mask[ad_params["sub_idxs"]]
+        else:
+            mask = F.interpolate(mask.unsqueeze(1), size=(mask_h, mask_w), mode="bilinear").squeeze(1)
+            mask = tensor_to_size(mask, batch_prompt)
+
+        mask = mask.repeat(len(cond_or_uncond), 1, 1)
+        mask = mask.view(mask.shape[0], -1, 1).repeat(1, 1, out.shape[2])
+
+        # covers cases where extreme aspect ratios can cause the mask to have a wrong size
+        mask_len = mask_h * mask_w
+        if mask_len < seq_len:
+            pad_len = seq_len - mask_len
+            pad1 = pad_len // 2
+            pad2 = pad_len - pad1
+            mask = F.pad(mask, (0, 0, pad1, pad2), value=0.0)
+        elif mask_len > seq_len:
+            crop_start = (mask_len - seq_len) // 2
+            mask = mask[:, crop_start:crop_start+seq_len, :]
+
+        out_ip = out_ip * mask
+
+    #out = out + out_ip
+
+    return out_ip.to(dtype=dtype)

ComfyUI_InstantID/InstantID.py

@@ -0,0 +1,611 @@
+import torch
+import os
+import comfy.utils
+import folder_paths
+import numpy as np
+import math
+import cv2
+import PIL.Image
+from .resampler import Resampler
+from .CrossAttentionPatch import Attn2Replace, instantid_attention
+from .utils import tensor_to_image
+
+from insightface.app import FaceAnalysis
+
+try:
+    import torchvision.transforms.v2 as T
+except ImportError:
+    import torchvision.transforms as T
+
+import torch.nn.functional as F
+
+MODELS_DIR = os.path.join(folder_paths.models_dir, "instantid")
+if "instantid" not in folder_paths.folder_names_and_paths:
+    current_paths = [MODELS_DIR]
+else:
+    current_paths, _ = folder_paths.folder_names_and_paths["instantid"]
+folder_paths.folder_names_and_paths["instantid"] = (current_paths, folder_paths.supported_pt_extensions)
+
+INSIGHTFACE_DIR = os.path.join(folder_paths.models_dir, "insightface")
+
+def draw_kps(image_pil, kps, color_list=[(255,0,0), (0,255,0), (0,0,255), (255,255,0), (255,0,255)]):
+    stickwidth = 4
+    limbSeq = np.array([[0, 2], [1, 2], [3, 2], [4, 2]])
+    kps = np.array(kps)
+
+    h, w, _ = image_pil.shape
+    out_img = np.zeros([h, w, 3])
+
+    for i in range(len(limbSeq)):
+        index = limbSeq[i]
+        color = color_list[index[0]]
+
+        x = kps[index][:, 0]
+        y = kps[index][:, 1]
+        length = ((x[0] - x[1]) ** 2 + (y[0] - y[1]) ** 2) ** 0.5
+        angle = math.degrees(math.atan2(y[0] - y[1], x[0] - x[1]))
+        polygon = cv2.ellipse2Poly((int(np.mean(x)), int(np.mean(y))), (int(length / 2), stickwidth), int(angle), 0, 360, 1)
+        out_img = cv2.fillConvexPoly(out_img.copy(), polygon, color)
+    out_img = (out_img * 0.6).astype(np.uint8)
+
+    for idx_kp, kp in enumerate(kps):
+        color = color_list[idx_kp]
+        x, y = kp
+        out_img = cv2.circle(out_img.copy(), (int(x), int(y)), 10, color, -1)
+
+    out_img_pil = PIL.Image.fromarray(out_img.astype(np.uint8))
+    return out_img_pil
+
+class InstantID(torch.nn.Module):
+    def __init__(self, instantid_model, cross_attention_dim=1280, output_cross_attention_dim=1024, clip_embeddings_dim=512, clip_extra_context_tokens=16):
+        super().__init__()
+
+        self.clip_embeddings_dim = clip_embeddings_dim
+        self.cross_attention_dim = cross_attention_dim
+        self.output_cross_attention_dim = output_cross_attention_dim
+        self.clip_extra_context_tokens = clip_extra_context_tokens
+
+        self.image_proj_model = self.init_proj()
+
+        self.image_proj_model.load_state_dict(instantid_model["image_proj"])
+        self.ip_layers = To_KV(instantid_model["ip_adapter"])
+
+    def init_proj(self):
+        image_proj_model = Resampler(
+            dim=self.cross_attention_dim,
+            depth=4,
+            dim_head=64,
+            heads=20,
+            num_queries=self.clip_extra_context_tokens,
+            embedding_dim=self.clip_embeddings_dim,
+            output_dim=self.output_cross_attention_dim,
+            ff_mult=4
+        )
+        return image_proj_model
+
+    @torch.inference_mode()
+    def get_image_embeds(self, clip_embed, clip_embed_zeroed):
+        #image_prompt_embeds = clip_embed.clone().detach()
+        image_prompt_embeds = self.image_proj_model(clip_embed)
+        #uncond_image_prompt_embeds = clip_embed_zeroed.clone().detach()
+        uncond_image_prompt_embeds = self.image_proj_model(clip_embed_zeroed)
+
+        return image_prompt_embeds, uncond_image_prompt_embeds
+
+class ImageProjModel(torch.nn.Module):
+    def __init__(self, cross_attention_dim=1024, clip_embeddings_dim=1024, clip_extra_context_tokens=4):
+        super().__init__()
+
+        self.cross_attention_dim = cross_attention_dim
+        self.clip_extra_context_tokens = clip_extra_context_tokens
+        self.proj = torch.nn.Linear(clip_embeddings_dim, self.clip_extra_context_tokens * cross_attention_dim)
+        self.norm = torch.nn.LayerNorm(cross_attention_dim)
+
+    def forward(self, image_embeds):
+        embeds = image_embeds
+        clip_extra_context_tokens = self.proj(embeds).reshape(-1, self.clip_extra_context_tokens, self.cross_attention_dim)
+        clip_extra_context_tokens = self.norm(clip_extra_context_tokens)
+        return clip_extra_context_tokens
+
+class To_KV(torch.nn.Module):
+    def __init__(self, state_dict):
+        super().__init__()
+
+        self.to_kvs = torch.nn.ModuleDict()
+        for key, value in state_dict.items():
+            k = key.replace(".weight", "").replace(".", "_")
+            self.to_kvs[k] = torch.nn.Linear(value.shape[1], value.shape[0], bias=False)
+            self.to_kvs[k].weight.data = value
+
+def _set_model_patch_replace(model, patch_kwargs, key):
+    to = model.model_options["transformer_options"].copy()
+    if "patches_replace" not in to:
+        to["patches_replace"] = {}
+    else:
+        to["patches_replace"] = to["patches_replace"].copy()
+
+    if "attn2" not in to["patches_replace"]:
+        to["patches_replace"]["attn2"] = {}
+    else:
+        to["patches_replace"]["attn2"] = to["patches_replace"]["attn2"].copy()
+    
+    if key not in to["patches_replace"]["attn2"]:
+        to["patches_replace"]["attn2"][key] = Attn2Replace(instantid_attention, **patch_kwargs)
+        model.model_options["transformer_options"] = to
+    else:
+        to["patches_replace"]["attn2"][key].add(instantid_attention, **patch_kwargs)
+
+class InstantIDModelLoader:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { "instantid_file": (folder_paths.get_filename_list("instantid"), )}}
+
+    RETURN_TYPES = ("INSTANTID",)
+    FUNCTION = "load_model"
+    CATEGORY = "InstantID"
+
+    def load_model(self, instantid_file):
+        ckpt_path = folder_paths.get_full_path("instantid", instantid_file)
+
+        model = comfy.utils.load_torch_file(ckpt_path, safe_load=True)
+
+        if ckpt_path.lower().endswith(".safetensors"):
+            st_model = {"image_proj": {}, "ip_adapter": {}}
+            for key in model.keys():
+                if key.startswith("image_proj."):
+                    st_model["image_proj"][key.replace("image_proj.", "")] = model[key]
+                elif key.startswith("ip_adapter."):
+                    st_model["ip_adapter"][key.replace("ip_adapter.", "")] = model[key]
+            model = st_model
+
+        model = InstantID(
+            model,
+            cross_attention_dim=1280,
+            output_cross_attention_dim=model["ip_adapter"]["1.to_k_ip.weight"].shape[1],
+            clip_embeddings_dim=512,
+            clip_extra_context_tokens=16,
+        )
+
+        return (model,)
+
+def extractFeatures(insightface, image, extract_kps=False):
+    face_img = tensor_to_image(image)
+    out = []
+
+    insightface.det_model.input_size = (640,640) # reset the detection size
+
+    for i in range(face_img.shape[0]):
+        for size in [(size, size) for size in range(640, 128, -64)]:
+            insightface.det_model.input_size = size # TODO: hacky but seems to be working
+            face = insightface.get(face_img[i])
+            if face:
+                face = sorted(face, key=lambda x:(x['bbox'][2]-x['bbox'][0])*(x['bbox'][3]-x['bbox'][1]))[-1]
+
+                if extract_kps:
+                    out.append(draw_kps(face_img[i], face['kps']))
+                else:
+                    out.append(torch.from_numpy(face['embedding']).unsqueeze(0))
+
+                if 640 not in size:
+                    print(f"\033[33mINFO: InsightFace detection resolution lowered to {size}.\033[0m")
+                break
+
+    if out:
+        if extract_kps:
+            out = torch.stack(T.ToTensor()(out), dim=0).permute([0,2,3,1])
+        else:
+            out = torch.stack(out, dim=0)
+    else:
+        out = None
+
+    return out
+
+class InstantIDFaceAnalysis:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "provider": (["CPU", "CUDA", "ROCM", "CoreML"], ),
+            },
+        }
+
+    RETURN_TYPES = ("FACEANALYSIS",)
+    FUNCTION = "load_insight_face"
+    CATEGORY = "InstantID"
+
+    def load_insight_face(self, provider):
+        model = FaceAnalysis(name="antelopev2", root=INSIGHTFACE_DIR, providers=[provider + 'ExecutionProvider',]) # alternative to buffalo_l
+        model.prepare(ctx_id=0, det_size=(640, 640))
+
+        return (model,)
+
+class FaceKeypointsPreprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "faceanalysis": ("FACEANALYSIS", ),
+                "image": ("IMAGE", ),
+            },
+        }
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "preprocess_image"
+    CATEGORY = "InstantID"
+
+    def preprocess_image(self, faceanalysis, image):
+        face_kps = extractFeatures(faceanalysis, image, extract_kps=True)
+
+        if face_kps is None:
+            face_kps = torch.zeros_like(image)
+            print(f"\033[33mWARNING: no face detected, unable to extract the keypoints!\033[0m")
+            #raise Exception('Face Keypoints Image: No face detected.')
+
+        return (face_kps,)
+
+def add_noise(image, factor):
+    seed = int(torch.sum(image).item()) % 1000000007
+    torch.manual_seed(seed)
+    mask = (torch.rand_like(image) < factor).float()
+    noise = torch.rand_like(image)
+    noise = torch.zeros_like(image) * (1-mask) + noise * mask
+
+    return factor*noise
+
+class ApplyInstantID:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "instantid": ("INSTANTID", ),
+                "insightface": ("FACEANALYSIS", ),
+                "control_net": ("CONTROL_NET", ),
+                "image": ("IMAGE", ),
+                "model": ("MODEL", ),
+                "positive": ("CONDITIONING", ),
+                "negative": ("CONDITIONING", ),
+                "weight": ("FLOAT", {"default": .8, "min": 0.0, "max": 5.0, "step": 0.01, }),
+                "start_at": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.001, }),
+                "end_at": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.001, }),
+            },
+            "optional": {
+                "image_kps": ("IMAGE",),
+                "mask": ("MASK",),
+            }
+        }
+
+    RETURN_TYPES = ("MODEL", "CONDITIONING", "CONDITIONING",)
+    RETURN_NAMES = ("MODEL", "positive", "negative", )
+    FUNCTION = "apply_instantid"
+    CATEGORY = "InstantID"
+
+    def apply_instantid(self, instantid, insightface, control_net, image, model, positive, negative, start_at, end_at, weight=.8, ip_weight=None, cn_strength=None, noise=0.35, image_kps=None, mask=None, combine_embeds='average'):
+        dtype = comfy.model_management.unet_dtype()
+        if dtype not in [torch.float32, torch.float16, torch.bfloat16]:
+            dtype = torch.float16 if comfy.model_management.should_use_fp16() else torch.float32
+        
+        self.dtype = dtype
+        self.device = comfy.model_management.get_torch_device()
+
+        ip_weight = weight if ip_weight is None else ip_weight
+        cn_strength = weight if cn_strength is None else cn_strength
+
+        face_embed = extractFeatures(insightface, image)
+        if face_embed is None:
+            raise Exception('Reference Image: No face detected.')
+
+        # if no keypoints image is provided, use the image itself (only the first one in the batch)
+        face_kps = extractFeatures(insightface, image_kps if image_kps is not None else image[0].unsqueeze(0), extract_kps=True)
+
+        if face_kps is None:
+            face_kps = torch.zeros_like(image) if image_kps is None else image_kps
+            print(f"\033[33mWARNING: No face detected in the keypoints image!\033[0m")
+
+        clip_embed = face_embed
+        # InstantID works better with averaged embeds (TODO: needs testing)
+        if clip_embed.shape[0] > 1:
+            if combine_embeds == 'average':
+                clip_embed = torch.mean(clip_embed, dim=0).unsqueeze(0)
+            elif combine_embeds == 'norm average':
+                clip_embed = torch.mean(clip_embed / torch.norm(clip_embed, dim=0, keepdim=True), dim=0).unsqueeze(0)
+
+        if noise > 0:
+            seed = int(torch.sum(clip_embed).item()) % 1000000007
+            torch.manual_seed(seed)
+            clip_embed_zeroed = noise * torch.rand_like(clip_embed)
+            #clip_embed_zeroed = add_noise(clip_embed, noise)
+        else:
+            clip_embed_zeroed = torch.zeros_like(clip_embed)
+
+        # 1: patch the attention
+        self.instantid = instantid
+        self.instantid.to(self.device, dtype=self.dtype)
+
+        image_prompt_embeds, uncond_image_prompt_embeds = self.instantid.get_image_embeds(clip_embed.to(self.device, dtype=self.dtype), clip_embed_zeroed.to(self.device, dtype=self.dtype))
+
+        image_prompt_embeds = image_prompt_embeds.to(self.device, dtype=self.dtype)
+        uncond_image_prompt_embeds = uncond_image_prompt_embeds.to(self.device, dtype=self.dtype)
+
+        work_model = model.clone()
+
+        sigma_start = model.get_model_object("model_sampling").percent_to_sigma(start_at)
+        sigma_end = model.get_model_object("model_sampling").percent_to_sigma(end_at)
+
+        if mask is not None:
+            mask = mask.to(self.device)
+
+        patch_kwargs = {
+            "ipadapter": self.instantid,
+            "weight": ip_weight,
+            "cond": image_prompt_embeds,
+            "uncond": uncond_image_prompt_embeds,
+            "mask": mask,
+            "sigma_start": sigma_start,
+            "sigma_end": sigma_end,
+        }
+
+        number = 0
+        for id in [4,5,7,8]: # id of input_blocks that have cross attention
+            block_indices = range(2) if id in [4, 5] else range(10) # transformer_depth
+            for index in block_indices:
+                patch_kwargs["module_key"] = str(number*2+1)
+                _set_model_patch_replace(work_model, patch_kwargs, ("input", id, index))
+                number += 1
+        for id in range(6): # id of output_blocks that have cross attention
+            block_indices = range(2) if id in [3, 4, 5] else range(10) # transformer_depth
+            for index in block_indices:
+                patch_kwargs["module_key"] = str(number*2+1)
+                _set_model_patch_replace(work_model, patch_kwargs, ("output", id, index))
+                number += 1
+        for index in range(10):
+            patch_kwargs["module_key"] = str(number*2+1)
+            _set_model_patch_replace(work_model, patch_kwargs, ("middle", 1, index))
+            number += 1
+
+        # 2: do the ControlNet
+        if mask is not None and len(mask.shape) < 3:
+            mask = mask.unsqueeze(0)
+
+        cnets = {}
+        cond_uncond = []
+
+        is_cond = True
+        for conditioning in [positive, negative]:
+            c = []
+            for t in conditioning:
+                d = t[1].copy()
+
+                prev_cnet = d.get('control', None)
+                if prev_cnet in cnets:
+                    c_net = cnets[prev_cnet]
+                else:
+                    c_net = control_net.copy().set_cond_hint(face_kps.movedim(-1,1), cn_strength, (start_at, end_at))
+                    c_net.set_previous_controlnet(prev_cnet)
+                    cnets[prev_cnet] = c_net
+
+                d['control'] = c_net
+                d['control_apply_to_uncond'] = False
+                d['cross_attn_controlnet'] = image_prompt_embeds.to(comfy.model_management.intermediate_device(), dtype=c_net.cond_hint_original.dtype) if is_cond else uncond_image_prompt_embeds.to(comfy.model_management.intermediate_device(), dtype=c_net.cond_hint_original.dtype)
+
+                if mask is not None and is_cond:
+                    d['mask'] = mask
+                    d['set_area_to_bounds'] = False
+
+                n = [t[0], d]
+                c.append(n)
+            cond_uncond.append(c)
+            is_cond = False
+
+        return(work_model, cond_uncond[0], cond_uncond[1], )
+
+class ApplyInstantIDAdvanced(ApplyInstantID):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "instantid": ("INSTANTID", ),
+                "insightface": ("FACEANALYSIS", ),
+                "control_net": ("CONTROL_NET", ),
+                "image": ("IMAGE", ),
+                "model": ("MODEL", ),
+                "positive": ("CONDITIONING", ),
+                "negative": ("CONDITIONING", ),
+                "ip_weight": ("FLOAT", {"default": .8, "min": 0.0, "max": 3.0, "step": 0.01, }),
+                "cn_strength": ("FLOAT", {"default": .8, "min": 0.0, "max": 10.0, "step": 0.01, }),
+                "start_at": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.001, }),
+                "end_at": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.001, }),
+                "noise": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.1, }),
+                "combine_embeds": (['average', 'norm average', 'concat'], {"default": 'average'}),
+            },
+            "optional": {
+                "image_kps": ("IMAGE",),
+                "mask": ("MASK",),
+            }
+        }
+
+class InstantIDAttentionPatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "instantid": ("INSTANTID", ),
+                "insightface": ("FACEANALYSIS", ),
+                "image": ("IMAGE", ),
+                "model": ("MODEL", ),
+                "weight": ("FLOAT", {"default": 1.0, "min": -1.0, "max": 3.0, "step": 0.01, }),
+                "start_at": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.001, }),
+                "end_at": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.001, }),
+                "noise": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.1, }),
+            },
+            "optional": {
+                "mask": ("MASK",),
+            }
+        }
+
+    RETURN_TYPES = ("MODEL", "FACE_EMBEDS")
+    FUNCTION = "patch_attention"
+    CATEGORY = "InstantID"
+
+    def patch_attention(self, instantid, insightface, image, model, weight, start_at, end_at, noise=0.0, mask=None):
+        self.dtype = torch.float16 if comfy.model_management.should_use_fp16() else torch.float32
+        self.device = comfy.model_management.get_torch_device()
+
+        face_embed = extractFeatures(insightface, image)
+        if face_embed is None:
+            raise Exception('Reference Image: No face detected.')
+
+        clip_embed = face_embed
+        # InstantID works better with averaged embeds (TODO: needs testing)
+        if clip_embed.shape[0] > 1:
+            clip_embed = torch.mean(clip_embed, dim=0).unsqueeze(0)
+
+        if noise > 0:
+            seed = int(torch.sum(clip_embed).item()) % 1000000007
+            torch.manual_seed(seed)
+            clip_embed_zeroed = noise * torch.rand_like(clip_embed)
+        else:
+            clip_embed_zeroed = torch.zeros_like(clip_embed)
+
+        # 1: patch the attention
+        self.instantid = instantid
+        self.instantid.to(self.device, dtype=self.dtype)
+
+        image_prompt_embeds, uncond_image_prompt_embeds = self.instantid.get_image_embeds(clip_embed.to(self.device, dtype=self.dtype), clip_embed_zeroed.to(self.device, dtype=self.dtype))
+
+        image_prompt_embeds = image_prompt_embeds.to(self.device, dtype=self.dtype)
+        uncond_image_prompt_embeds = uncond_image_prompt_embeds.to(self.device, dtype=self.dtype)
+
+        if weight == 0:
+            return (model, { "cond": image_prompt_embeds, "uncond": uncond_image_prompt_embeds } )
+
+        work_model = model.clone()
+
+        sigma_start = model.get_model_object("model_sampling").percent_to_sigma(start_at)
+        sigma_end = model.get_model_object("model_sampling").percent_to_sigma(end_at)
+
+        if mask is not None:
+            mask = mask.to(self.device)
+
+        patch_kwargs = {
+            "weight": weight,
+            "ipadapter": self.instantid,
+            "cond": image_prompt_embeds,
+            "uncond": uncond_image_prompt_embeds,
+            "mask": mask,
+            "sigma_start": sigma_start,
+            "sigma_end": sigma_end,
+        }
+
+        number = 0
+        for id in [4,5,7,8]: # id of input_blocks that have cross attention
+            block_indices = range(2) if id in [4, 5] else range(10) # transformer_depth
+            for index in block_indices:
+                patch_kwargs["module_key"] = str(number*2+1)
+                _set_model_patch_replace(work_model, patch_kwargs, ("input", id, index))
+                number += 1
+        for id in range(6): # id of output_blocks that have cross attention
+            block_indices = range(2) if id in [3, 4, 5] else range(10) # transformer_depth
+            for index in block_indices:
+                patch_kwargs["module_key"] = str(number*2+1)
+                _set_model_patch_replace(work_model, patch_kwargs, ("output", id, index))
+                number += 1
+        for index in range(10):
+            patch_kwargs["module_key"] = str(number*2+1)
+            _set_model_patch_replace(work_model, patch_kwargs, ("middle", 0, index))
+            number += 1
+
+        return(work_model, { "cond": image_prompt_embeds, "uncond": uncond_image_prompt_embeds }, )
+
+class ApplyInstantIDControlNet:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "face_embeds": ("FACE_EMBEDS", ),
+                "control_net": ("CONTROL_NET", ),
+                "image_kps": ("IMAGE", ),
+                "positive": ("CONDITIONING", ),
+                "negative": ("CONDITIONING", ),
+                "strength": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01, }),
+                "start_at": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.001, }),
+                "end_at": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.001, }),
+            },
+            "optional": {
+                "mask": ("MASK",),
+            }
+        }
+
+    RETURN_TYPES = ("CONDITIONING", "CONDITIONING",)
+    RETURN_NAMES = ("positive", "negative", )
+    FUNCTION = "apply_controlnet"
+    CATEGORY = "InstantID"
+
+    def apply_controlnet(self, face_embeds, control_net, image_kps, positive, negative, strength, start_at, end_at, mask=None):
+        self.device = comfy.model_management.get_torch_device()
+
+        if strength == 0:
+            return (positive, negative)
+
+        if mask is not None:
+            mask = mask.to(self.device)
+
+        if mask is not None and len(mask.shape) < 3:
+            mask = mask.unsqueeze(0)
+
+        image_prompt_embeds = face_embeds['cond']
+        uncond_image_prompt_embeds = face_embeds['uncond']
+
+        cnets = {}
+        cond_uncond = []
+        control_hint = image_kps.movedim(-1,1)
+
+        is_cond = True
+        for conditioning in [positive, negative]:
+            c = []
+            for t in conditioning:
+                d = t[1].copy()
+
+                prev_cnet = d.get('control', None)
+                if prev_cnet in cnets:
+                    c_net = cnets[prev_cnet]
+                else:
+                    c_net = control_net.copy().set_cond_hint(control_hint, strength, (start_at, end_at))
+                    c_net.set_previous_controlnet(prev_cnet)
+                    cnets[prev_cnet] = c_net
+
+                d['control'] = c_net
+                d['control_apply_to_uncond'] = False
+                d['cross_attn_controlnet'] = image_prompt_embeds.to(comfy.model_management.intermediate_device()) if is_cond else uncond_image_prompt_embeds.to(comfy.model_management.intermediate_device())
+
+                if mask is not None and is_cond:
+                    d['mask'] = mask
+                    d['set_area_to_bounds'] = False
+
+                n = [t[0], d]
+                c.append(n)
+            cond_uncond.append(c)
+            is_cond = False
+
+        return(cond_uncond[0], cond_uncond[1])
+
+
+NODE_CLASS_MAPPINGS = {
+    "InstantIDModelLoader": InstantIDModelLoader,
+    "InstantIDFaceAnalysis": InstantIDFaceAnalysis,
+    "ApplyInstantID": ApplyInstantID,
+    "ApplyInstantIDAdvanced": ApplyInstantIDAdvanced,
+    "FaceKeypointsPreprocessor": FaceKeypointsPreprocessor,
+
+    "InstantIDAttentionPatch": InstantIDAttentionPatch,
+    "ApplyInstantIDControlNet": ApplyInstantIDControlNet,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "InstantIDModelLoader": "Load InstantID Model",
+    "InstantIDFaceAnalysis": "InstantID Face Analysis",
+    "ApplyInstantID": "Apply InstantID",
+    "ApplyInstantIDAdvanced": "Apply InstantID Advanced",
+    "FaceKeypointsPreprocessor": "Face Keypoints Preprocessor",
+
+    "InstantIDAttentionPatch": "InstantID Patch Attention",
+    "ApplyInstantIDControlNet": "InstantID Apply ControlNet",
+}

ComfyUI_InstantID/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

ComfyUI_InstantID/README.md

@@ -0,0 +1,141 @@
+# ComfyUI InstantID (Native Support)
+
+## Translations
+- [简体中文 (Simplified Chinese)](./README.zh-CN.md)
+
+Native [InstantID](https://github.com/InstantID/InstantID) support for [ComfyUI](https://github.com/comfyanonymous/ComfyUI).
+
+This extension differs from the many already available as it doesn't use *diffusers* but instead implements InstantID natively and it fully integrates with ComfyUI.
+
+# Sponsorship
+
+<div align="center">
+
+**[:heart: Github Sponsor](https://github.com/sponsors/cubiq) | [:coin: Paypal](https://paypal.me/matt3o)**
+
+</div>
+
+If you like my work and wish to see updates and new features please consider sponsoring my projects.
+
+- [ComfyUI IPAdapter Plus](https://github.com/cubiq/ComfyUI_IPAdapter_plus)
+- [ComfyUI InstantID (Native)](https://github.com/cubiq/ComfyUI_InstantID)
+- [ComfyUI Essentials](https://github.com/cubiq/ComfyUI_essentials)
+- [ComfyUI FaceAnalysis](https://github.com/cubiq/ComfyUI_FaceAnalysis)
+
+Not to mention the documentation and videos tutorials. Check my **ComfyUI Advanced Understanding** videos on YouTube for example, [part 1](https://www.youtube.com/watch?v=_C7kR2TFIX0) and [part 2](https://www.youtube.com/watch?v=ijqXnW_9gzc)
+
+The only way to keep the code open and free is by sponsoring its development. The more sponsorships the more time I can dedicate to my open source projects.
+
+Please consider a [Github Sponsorship](https://github.com/sponsors/cubiq) or [PayPal donation](https://paypal.me/matt3o) (Matteo "matt3o" Spinelli). For sponsorships of $50+, let me know if you'd like to be mentioned in this readme file, you can find me on [Discord](https://latent.vision/discord) or _matt3o :snail: gmail.com_.
+
+## Important updates
+
+- **2024/02/27:** Added [noise injection](#noise-injection) in the negative embeds.
+
+- **2024/02/26:** Fixed a small but nasty bug. Results will be different and you may need to lower the CFG.
+
+- **2024/02/20:** I refactored the nodes so they are hopefully easier to use. **This is a breaking update**, the previous workflows won't work anymore.
+
+## Basic Workflow
+
+In the `examples` directory you'll find some basic workflows.
+
+![workflow](examples/instantid_basic_workflow.jpg)
+
+## Video Tutorial
+
+<a href="https://youtu.be/wMLiGhogOPE" target="_blank">
+ <img src="https://img.youtube.com/vi/wMLiGhogOPE/hqdefault.jpg" alt="Watch the video" />
+</a>
+
+** :movie_camera: [Introduction to InstantID features](https://youtu.be/wMLiGhogOPE)**
+
+## Installation
+
+**Upgrade ComfyUI to the latest version!**
+
+Download or `git clone` this repository into the `ComfyUI/custom_nodes/` directory or use the Manager.
+
+InstantID requires `insightface`, you need to add it to your libraries together with `onnxruntime` and `onnxruntime-gpu`.
+
+The InsightFace model is **antelopev2** (not the classic buffalo_l). Download the models (for example from [here](https://drive.google.com/file/d/18wEUfMNohBJ4K3Ly5wpTejPfDzp-8fI8/view?usp=sharing) or [here](https://huggingface.co/MonsterMMORPG/tools/tree/main)), unzip and place them in the `ComfyUI/models/insightface/models/antelopev2` directory.
+
+The **main model** can be downloaded from [HuggingFace](https://huggingface.co/InstantX/InstantID/resolve/main/ip-adapter.bin?download=true) and should be placed into the `ComfyUI/models/instantid` directory. (Note that the model is called *ip_adapter* as it is based on the [IPAdapter](https://github.com/tencent-ailab/IP-Adapter)).
+
+You also needs a [controlnet](https://huggingface.co/InstantX/InstantID/resolve/main/ControlNetModel/diffusion_pytorch_model.safetensors?download=true), place it in the ComfyUI controlnet directory.
+
+**Remember at the moment this is only for SDXL.**
+
+## Watermarks!
+
+The training data is full of watermarks, to avoid them to show up in your generations use a resolution slightly different from 1024×1024 (or the standard ones) for example **1016×1016** works pretty well.
+
+## Lower the CFG!
+
+It's important to lower the CFG to at least 4/5 or you can use the `RescaleCFG` node.
+
+## Face keypoints
+
+The person is posed based on the keypoints generated from the reference image. You can use a different pose by sending an image to the `image_kps` input.
+
+<img src="examples/daydreaming.jpg" width="386" height="386" alt="Day Dreaming" />
+
+## Noise Injection
+
+The default InstantID implementation seems to really burn the image, I find that by injecting noise to the negative embeds we can mitigate the effect and also increase the likeliness to the reference. The default Apply InstantID node automatically injects 35% noise, if you want to fine tune the effect you can use the Advanced InstantID node.
+
+This is still experimental and may change in the future.
+
+## Additional Controlnets
+
+You can add more controlnets to the generation. An example workflow for depth controlnet is provided.
+
+## Styling with IPAdapter
+
+It's possible to style the composition with IPAdapter. An example is provided.
+
+<img src="examples/instant_id_ipadapter.jpg" width="512" alt="IPAdapter" />
+
+## Multi-ID
+
+Multi-ID is supported but the workflow is a bit complicated and the generation slower. I'll check if I can find a better way of doing it. The "hackish" workflow is provided in the example directory.
+
+<img src="examples/instantid_multi_id.jpg" width="768" alt="IPAdapter" />
+
+## Advanced Node
+
+There's an InstantID advanced node available, at the moment the only difference with the standard one is that you can set the weights for the instantID models and the controlnet separately. It now also includes a noise injection option. It might be helpful for finetuning.
+
+The instantID model influences the composition of about 25%, the rest is the controlnet.
+
+The noise helps reducing the "burn" effect.
+
+## Other notes
+
+It works very well with SDXL Turbo/Lighting. Best results with community's checkpoints.
+
+
+## Current sponsors
+
+It's only thanks to generous sponsors that **the whole community** can enjoy open and free software. Please join me in thanking the following companies and individuals!
+
+### :trophy: Gold sponsors
+
+[![Kaiber.ai](https://f.latent.vision/imgs/kaiber.png)](https://kaiber.ai/)&nbsp; &nbsp;[![InstaSD](https://f.latent.vision/imgs/instasd.png)](https://www.instasd.com/)
+
+### :tada: Silver sponsors
+
+[![OperArt.ai](https://f.latent.vision/imgs/openart.png?r=1)](https://openart.ai/workflows)&nbsp; &nbsp;[![Finetuners](https://f.latent.vision/imgs/finetuners.png)](https://www.finetuners.ai/)&nbsp; &nbsp;[![Comfy.ICU](https://f.latent.vision/imgs/comfyicu.png?r=1)](https://comfy.icu/)
+
+### Other companies supporting my projects
+
+- [RunComfy](https://www.runcomfy.com/) (ComfyUI Cloud)
+
+### Esteemed individuals
+
+- [Øystein Ø. Olsen](https://github.com/FireNeslo)
+- [Jack Gane](https://github.com/ganeJackS)
+- [Nathan Shipley](https://www.nathanshipley.com/)
+- [Dkdnzia](https://github.com/Dkdnzia)
+
+[And all my public and private sponsors!](https://github.com/sponsors/cubiq)

ComfyUI_InstantID/README.zh-CN.md

@@ -0,0 +1,137 @@
+# ComfyUI InstantID (原生支持)
+
+[InstantID](https://github.com/InstantID/InstantID) 的原生 [ComfyUI](https://github.com/comfyanonymous/ComfyUI) 支持。
+
+此扩展不同于许多已可用的扩展，因为它不使用 *diffusers*，而是原生实现了 InstantID，并且与 ComfyUI 完全集成。
+
+# 赞助
+
+<div align="center">
+
+**[:heart: Github 赞助](https://github.com/sponsors/cubiq) | [:coin: Paypal](https://paypal.me/matt3o)**
+
+</div>
+
+如果您喜欢我的工作并希望看到更新和新功能，请考虑赞助我的项目。
+
+- [ComfyUI IPAdapter Plus](https://github.com/cubiq/ComfyUI_IPAdapter_plus)
+- [ComfyUI InstantID (原生)](https://github.com/cubiq/ComfyUI_InstantID)
+- [ComfyUI Essentials](https://github.com/cubiq/ComfyUI_essentials)
+- [ComfyUI FaceAnalysis](https://github.com/cubiq/ComfyUI_FaceAnalysis)
+
+更不用说文档和视频教程。可以查看我在 YouTube 上的 **ComfyUI 高级理解** 视频，例如 [第 1 部分](https://www.youtube.com/watch?v=_C7kR2TFIX0) 和 [第 2 部分](https://www.youtube.com/watch?v=ijqXnW_9gzc)。
+
+保持代码开源和免费的唯一方法是通过赞助其开发。赞助越多，我就能投入更多时间在我的开源项目上。
+
+请考虑 [Github 赞助](https://github.com/sponsors/cubiq) 或 [PayPal 捐赠](https://paypal.me/matt3o)（Matteo "matt3o" Spinelli）。对于赞助 $50+ 的人，请告诉我是否希望在此 README 文件中被提及，您可以在 [Discord](https://latent.vision/discord) 或通过 _matt3o :snail: gmail.com_ 联系我。
+
+## 重要更新
+
+- **2024/02/27:** 在负嵌入中添加了[噪声注入](#noise-injection)。
+
+- **2024/02/26:** 修复了一个小但讨厌的错误。结果将有所不同，您可能需要降低 CFG。
+
+- **2024/02/20:** 我重构了节点，希望它们更易于使用。**这是一次重大更新**，以前的工作流将不再可用。
+
+## 基本工作流
+
+在 `examples` 目录中，您会找到一些基本工作流。
+
+![workflow](examples/instantid_basic_workflow.jpg)
+
+## 视频教程
+
+<a href="https://youtu.be/wMLiGhogOPE" target="_blank">
+ <img src="https://img.youtube.com/vi/wMLiGhogOPE/hqdefault.jpg" alt="观看视频" />
+</a>
+
+** :movie_camera: [InstantID 功能介绍](https://youtu.be/wMLiGhogOPE)**
+
+## 安装
+
+**将 ComfyUI 升级到最新版本！**
+
+下载或 `git clone` 此仓库到 `ComfyUI/custom_nodes/` 目录或使用 Manager。
+
+InstantID 需要 `insightface`，您需要将其添加到您的库中，连同 `onnxruntime` 和 `onnxruntime-gpu`。
+
+InsightFace 模型是 **antelopev2**（不是经典的 buffalo_l）。下载模型（例如从 [这里](https://drive.google.com/file/d/18wEUfMNohBJ4K3Ly5wpTejPfDzp-8fI8/view?usp=sharing) 或 [这里](https://huggingface.co/MonsterMMORPG/tools/tree/main)），解压并将其放置在 `ComfyUI/models/insightface/models/antelopev2` 目录中。
+
+**主模型**可以从 [HuggingFace](https://huggingface.co/InstantX/InstantID/resolve/main/ip-adapter.bin?download=true) 下载，应将其放置在 `ComfyUI/models/instantid` 目录中。（请注意，该模型称为 *ip_adapter*，因为它基于 [IPAdapter](https://github.com/tencent-ailab/IP-Adapter)）。
+
+您还需要一个 [controlnet](https://huggingface.co/InstantX/InstantID/resolve/main/ControlNetModel/diffusion_pytorch_model.safetensors?download=true)，将其放置在 ComfyUI controlnet 目录中。
+
+**请记住，目前这仅适用于 SDXL。**
+
+## 水印！
+
+训练数据中充满了水印，为避免水印出现在您的生成中，请使用与 1024×1024（或标准尺寸）略有不同的分辨率，例如 **1016×1016** 效果很好。
+
+## 降低 CFG！
+
+重要的是将 CFG 降低到至少 4/5，或者您可以使用 `RescaleCFG` 节点。
+
+## 面部关键点
+
+人物的姿势是基于从参考图像生成的关键点。您可以通过向 `image_kps` 输入发送图像来使用不同的姿势。
+
+<img src="examples/daydreaming.jpg" width="386" height="386" alt="白日梦" />
+
+## 噪声注入
+
+默认的 InstantID 实现似乎真的“烧坏”了图像，我发现通过向负嵌入中注入噪声，我们可以缓解这一效果，并增加与参考的相似性。默认的 Apply InstantID 节点自动注入 35% 的噪声，如果您想微调效果，可以使用 Advanced InstantID 节点。
+
+这仍然是实验性的，可能会在未来发生变化。
+
+## 额外的 Controlnets
+
+您可以向生成中添加更多 controlnets。提供了一个用于深度 controlnet 的示例工作流。
+
+## 使用 IPAdapter 进行样式化
+
+可以使用 IPAdapter 对构图进行样式化。提供了一个示例。
+
+<img src="examples/instant_id_ipadapter.jpg" width="512" alt="IPAdapter" />
+
+## 多-ID 支持
+
+支持多 ID，但工作流有点复杂，生成速度较慢。我会检查是否可以找到更好的方法。示例工作流在 examples 目录中提供。
+
+<img src="examples/instantid_multi_id.jpg" width="768" alt="IPAdapter" />
+
+## 高级节点
+
+目前有一个高级的 InstantID 节点，当前与标准节点的唯一区别是您可以分别设置 instantID 模型和 controlnet 的权重。它现在还包括一个噪声注入选项。对于微调可能很有帮助。
+
+instantID 模型对构图的影响约为 25%，其余的是 controlnet。
+
+噪声有助于减少“燃烧”效果。
+
+## 其他注意事项
+
+它与 SDXL Turbo/Lighting 非常兼容。使用社区的检查点效果最好。
+
+## 当前赞助商
+
+正是由于慷慨的赞助商，**整个社区**才能享受开源和免费软件。请与我一起感谢以下公司和个人！
+
+### :trophy: 金牌赞助商
+
+[![Kaiber.ai](https://f.latent.vision/imgs/kaiber.png)](https://kaiber.ai/)&nbsp; &nbsp;[![InstaSD](https://f.latent.vision/imgs/instasd.png)](https://www.instasd.com/)
+
+### :tada: 银牌赞助商
+
+[![OperArt.ai](https://f.latent.vision/imgs/openart.png?r=1)](https://openart.ai/workflows)&nbsp; &nbsp;[![Finetuners](https://f.latent.vision/imgs/finetuners.png)](https://www.finetuners.ai/)&nbsp; &nbsp;[![Comfy.ICU](https://f.latent.vision/imgs/comfyicu.png?r=1)](https://comfy.icu/)
+
+### 其他支持我项目的公司
+
+- [RunComfy](https://www.runcomfy.com/) (ComfyUI 云) 
+
+### 尊敬的个人
+
+- [Øystein Ø. Olsen](https://github.com/FireNeslo)
+- [Jack Gane](https://github.com/ganeJackS)
+- [Nathan Shipley](https://www.nathanshipley.com/)
+- [Dkdnzia](https://github.com/Dkdnzia)
+
+[以及所有我的公开和私密赞助商！](https://github.com/sponsors/cubiq)

ComfyUI_InstantID/__init__.py

@@ -0,0 +1,3 @@
+from .InstantID import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS
+
+__all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS']

ComfyUI_InstantID/examples/InstantID_IPAdapter.json

@@ -0,0 +1,861 @@
+{
+  "last_node_id": 72,
+  "last_link_id": 231,
+  "nodes": [
+    {
+      "id": 11,
+      "type": "InstantIDModelLoader",
+      "pos": [
+        560,
+        70
+      ],
+      "size": {
+        "0": 238.72393798828125,
+        "1": 58
+      },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "INSTANTID",
+          "type": "INSTANTID",
+          "links": [
+            197
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "InstantIDModelLoader"
+      },
+      "widgets_values": [
+        "ip-adapter.bin"
+      ]
+    },
+    {
+      "id": 38,
+      "type": "InstantIDFaceAnalysis",
+      "pos": [
+        570,
+        180
+      ],
+      "size": {
+        "0": 227.09793090820312,
+        "1": 58
+      },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "FACEANALYSIS",
+          "type": "FACEANALYSIS",
+          "links": [
+            198
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "InstantIDFaceAnalysis"
+      },
+      "widgets_values": [
+        "CPU"
+      ]
+    },
+    {
+      "id": 16,
+      "type": "ControlNetLoader",
+      "pos": [
+        560,
+        290
+      ],
+      "size": {
+        "0": 250.07241821289062,
+        "1": 58
+      },
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "CONTROL_NET",
+          "type": "CONTROL_NET",
+          "links": [
+            199
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ControlNetLoader"
+      },
+      "widgets_values": [
+        "instantid/diffusion_pytorch_model.safetensors"
+      ]
+    },
+    {
+      "id": 15,
+      "type": "PreviewImage",
+      "pos": [
+        1910,
+        290
+      ],
+      "size": {
+        "0": 584.0855712890625,
+        "1": 610.4592895507812
+      },
+      "flags": {},
+      "order": 15,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 19
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 5,
+      "type": "EmptyLatentImage",
+      "pos": [
+        910,
+        540
+      ],
+      "size": {
+        "0": 315,
+        "1": 106
+      },
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            2
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "EmptyLatentImage"
+      },
+      "widgets_values": [
+        1016,
+        1016,
+        1
+      ]
+    },
+    {
+      "id": 8,
+      "type": "VAEDecode",
+      "pos": [
+        1910,
+        200
+      ],
+      "size": {
+        "0": 210,
+        "1": 46
+      },
+      "flags": {},
+      "order": 14,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 7
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 8
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            19
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VAEDecode"
+      }
+    },
+    {
+      "id": 39,
+      "type": "CLIPTextEncode",
+      "pos": [
+        520,
+        430
+      ],
+      "size": {
+        "0": 291.9967346191406,
+        "1": 128.62518310546875
+      },
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 122
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            203
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "comic character. graphic illustration, comic art, graphic novel art, vibrant, highly detailed"
+      ]
+    },
+    {
+      "id": 40,
+      "type": "CLIPTextEncode",
+      "pos": [
+        520,
+        620
+      ],
+      "size": {
+        "0": 286.3603515625,
+        "1": 112.35245513916016
+      },
+      "flags": {},
+      "order": 10,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 123
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            204
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "photograph, deformed, glitch, noisy, realistic, stock photo"
+      ]
+    },
+    {
+      "id": 4,
+      "type": "CheckpointLoaderSimple",
+      "pos": [
+        70,
+        520
+      ],
+      "size": {
+        "0": 315,
+        "1": 98
+      },
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            206
+          ],
+          "slot_index": 0
+        },
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            122,
+            123
+          ],
+          "slot_index": 1
+        },
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            8
+          ],
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CheckpointLoaderSimple"
+      },
+      "widgets_values": [
+        "sdxl/AlbedoBaseXL.safetensors"
+      ]
+    },
+    {
+      "id": 13,
+      "type": "LoadImage",
+      "pos": [
+        290,
+        70
+      ],
+      "size": {
+        "0": 210,
+        "1": 314
+      },
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            214
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "joseph-gonzalez-iFgRcqHznqg-unsplash.jpg",
+        "image"
+      ]
+    },
+    {
+      "id": 3,
+      "type": "KSampler",
+      "pos": [
+        1540,
+        200
+      ],
+      "size": {
+        "0": 315,
+        "1": 262
+      },
+      "flags": {},
+      "order": 13,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 231
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 200
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 201
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 2
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            7
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "KSampler"
+      },
+      "widgets_values": [
+        1631591432,
+        "fixed",
+        30,
+        4.5,
+        "ddpm",
+        "karras",
+        1
+      ]
+    },
+    {
+      "id": 68,
+      "type": "IPAdapterModelLoader",
+      "pos": [
+        830,
+        -500
+      ],
+      "size": {
+        "0": 315,
+        "1": 58
+      },
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "IPADAPTER",
+          "type": "IPADAPTER",
+          "links": [
+            227
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "IPAdapterModelLoader"
+      },
+      "widgets_values": [
+        "ip-adapter-plus_sdxl_vit-h.safetensors"
+      ]
+    },
+    {
+      "id": 60,
+      "type": "ApplyInstantID",
+      "pos": [
+        910,
+        210
+      ],
+      "size": {
+        "0": 315,
+        "1": 266
+      },
+      "flags": {},
+      "order": 11,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "instantid",
+          "type": "INSTANTID",
+          "link": 197
+        },
+        {
+          "name": "insightface",
+          "type": "FACEANALYSIS",
+          "link": 198
+        },
+        {
+          "name": "control_net",
+          "type": "CONTROL_NET",
+          "link": 199
+        },
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 214
+        },
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 206
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 203
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 204
+        },
+        {
+          "name": "image_kps",
+          "type": "IMAGE",
+          "link": null
+        },
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            230
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "POSITIVE",
+          "type": "CONDITIONING",
+          "links": [
+            200
+          ],
+          "shape": 3,
+          "slot_index": 1
+        },
+        {
+          "name": "NEGATIVE",
+          "type": "CONDITIONING",
+          "links": [
+            201
+          ],
+          "shape": 3,
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ApplyInstantID"
+      },
+      "widgets_values": [
+        0.8,
+        0,
+        1
+      ]
+    },
+    {
+      "id": 70,
+      "type": "CLIPVisionLoader",
+      "pos": [
+        830,
+        -390
+      ],
+      "size": {
+        "0": 315,
+        "1": 58
+      },
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "CLIP_VISION",
+          "type": "CLIP_VISION",
+          "links": [
+            228
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPVisionLoader"
+      },
+      "widgets_values": [
+        "CLIP-ViT-H-14-laion2B-s32B-b79K.safetensors"
+      ]
+    },
+    {
+      "id": 71,
+      "type": "LoadImage",
+      "pos": [
+        830,
+        -280
+      ],
+      "size": {
+        "0": 315,
+        "1": 314
+      },
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            229
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "anime_colorful.png",
+        "image"
+      ]
+    },
+    {
+      "id": 72,
+      "type": "IPAdapterAdvanced",
+      "pos": [
+        1226,
+        -337
+      ],
+      "size": {
+        "0": 315,
+        "1": 278
+      },
+      "flags": {},
+      "order": 12,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 230
+        },
+        {
+          "name": "ipadapter",
+          "type": "IPADAPTER",
+          "link": 227
+        },
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 229
+        },
+        {
+          "name": "image_negative",
+          "type": "IMAGE",
+          "link": null
+        },
+        {
+          "name": "attn_mask",
+          "type": "MASK",
+          "link": null
+        },
+        {
+          "name": "clip_vision",
+          "type": "CLIP_VISION",
+          "link": 228
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            231
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "IPAdapterAdvanced"
+      },
+      "widgets_values": [
+        0.5,
+        "linear",
+        "concat",
+        0,
+        1,
+        "V only"
+      ]
+    }
+  ],
+  "links": [
+    [
+      2,
+      5,
+      0,
+      3,
+      3,
+      "LATENT"
+    ],
+    [
+      7,
+      3,
+      0,
+      8,
+      0,
+      "LATENT"
+    ],
+    [
+      8,
+      4,
+      2,
+      8,
+      1,
+      "VAE"
+    ],
+    [
+      19,
+      8,
+      0,
+      15,
+      0,
+      "IMAGE"
+    ],
+    [
+      122,
+      4,
+      1,
+      39,
+      0,
+      "CLIP"
+    ],
+    [
+      123,
+      4,
+      1,
+      40,
+      0,
+      "CLIP"
+    ],
+    [
+      197,
+      11,
+      0,
+      60,
+      0,
+      "INSTANTID"
+    ],
+    [
+      198,
+      38,
+      0,
+      60,
+      1,
+      "FACEANALYSIS"
+    ],
+    [
+      199,
+      16,
+      0,
+      60,
+      2,
+      "CONTROL_NET"
+    ],
+    [
+      200,
+      60,
+      1,
+      3,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      201,
+      60,
+      2,
+      3,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      203,
+      39,
+      0,
+      60,
+      5,
+      "CONDITIONING"
+    ],
+    [
+      204,
+      40,
+      0,
+      60,
+      6,
+      "CONDITIONING"
+    ],
+    [
+      206,
+      4,
+      0,
+      60,
+      4,
+      "MODEL"
+    ],
+    [
+      214,
+      13,
+      0,
+      60,
+      3,
+      "IMAGE"
+    ],
+    [
+      227,
+      68,
+      0,
+      72,
+      1,
+      "IPADAPTER"
+    ],
+    [
+      228,
+      70,
+      0,
+      72,
+      5,
+      "CLIP_VISION"
+    ],
+    [
+      229,
+      71,
+      0,
+      72,
+      2,
+      "IMAGE"
+    ],
+    [
+      230,
+      60,
+      0,
+      72,
+      0,
+      "MODEL"
+    ],
+    [
+      231,
+      72,
+      0,
+      3,
+      0,
+      "MODEL"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

ComfyUI_InstantID/examples/InstantID_basic.json

@@ -0,0 +1,657 @@
+{
+  "last_node_id": 66,
+  "last_link_id": 220,
+  "nodes": [
+    {
+      "id": 11,
+      "type": "InstantIDModelLoader",
+      "pos": [
+        560,
+        70
+      ],
+      "size": {
+        "0": 238.72393798828125,
+        "1": 58
+      },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "INSTANTID",
+          "type": "INSTANTID",
+          "links": [
+            197
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "InstantIDModelLoader"
+      },
+      "widgets_values": [
+        "ip-adapter.bin"
+      ]
+    },
+    {
+      "id": 38,
+      "type": "InstantIDFaceAnalysis",
+      "pos": [
+        570,
+        180
+      ],
+      "size": {
+        "0": 227.09793090820312,
+        "1": 58
+      },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "FACEANALYSIS",
+          "type": "FACEANALYSIS",
+          "links": [
+            198
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "InstantIDFaceAnalysis"
+      },
+      "widgets_values": [
+        "CPU"
+      ]
+    },
+    {
+      "id": 16,
+      "type": "ControlNetLoader",
+      "pos": [
+        560,
+        290
+      ],
+      "size": {
+        "0": 250.07241821289062,
+        "1": 58
+      },
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "CONTROL_NET",
+          "type": "CONTROL_NET",
+          "links": [
+            199
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ControlNetLoader"
+      },
+      "widgets_values": [
+        "instantid/diffusion_pytorch_model.safetensors"
+      ]
+    },
+    {
+      "id": 15,
+      "type": "PreviewImage",
+      "pos": [
+        1670,
+        300
+      ],
+      "size": {
+        "0": 584.0855712890625,
+        "1": 610.4592895507812
+      },
+      "flags": {},
+      "order": 11,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 19
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 5,
+      "type": "EmptyLatentImage",
+      "pos": [
+        910,
+        540
+      ],
+      "size": {
+        "0": 315,
+        "1": 106
+      },
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            2
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "EmptyLatentImage"
+      },
+      "widgets_values": [
+        1016,
+        1016,
+        1
+      ]
+    },
+    {
+      "id": 8,
+      "type": "VAEDecode",
+      "pos": [
+        1670,
+        210
+      ],
+      "size": {
+        "0": 210,
+        "1": 46
+      },
+      "flags": {},
+      "order": 10,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 7
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 8
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            19
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VAEDecode"
+      }
+    },
+    {
+      "id": 60,
+      "type": "ApplyInstantID",
+      "pos": [
+        910,
+        210
+      ],
+      "size": {
+        "0": 315,
+        "1": 266
+      },
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "instantid",
+          "type": "INSTANTID",
+          "link": 197
+        },
+        {
+          "name": "insightface",
+          "type": "FACEANALYSIS",
+          "link": 198
+        },
+        {
+          "name": "control_net",
+          "type": "CONTROL_NET",
+          "link": 199
+        },
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 214
+        },
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 206
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 203
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 204
+        },
+        {
+          "name": "image_kps",
+          "type": "IMAGE",
+          "link": null
+        },
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            220
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "POSITIVE",
+          "type": "CONDITIONING",
+          "links": [
+            200
+          ],
+          "shape": 3,
+          "slot_index": 1
+        },
+        {
+          "name": "NEGATIVE",
+          "type": "CONDITIONING",
+          "links": [
+            201
+          ],
+          "shape": 3,
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ApplyInstantID"
+      },
+      "widgets_values": [
+        0.8,
+        0,
+        1
+      ]
+    },
+    {
+      "id": 39,
+      "type": "CLIPTextEncode",
+      "pos": [
+        520,
+        430
+      ],
+      "size": {
+        "0": 291.9967346191406,
+        "1": 128.62518310546875
+      },
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 122
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            203
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "comic character. graphic illustration, comic art, graphic novel art, vibrant, highly detailed"
+      ]
+    },
+    {
+      "id": 40,
+      "type": "CLIPTextEncode",
+      "pos": [
+        520,
+        620
+      ],
+      "size": {
+        "0": 286.3603515625,
+        "1": 112.35245513916016
+      },
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 123
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            204
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "photograph, deformed, glitch, noisy, realistic, stock photo"
+      ]
+    },
+    {
+      "id": 4,
+      "type": "CheckpointLoaderSimple",
+      "pos": [
+        70,
+        520
+      ],
+      "size": {
+        "0": 315,
+        "1": 98
+      },
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            206
+          ],
+          "slot_index": 0
+        },
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            122,
+            123
+          ],
+          "slot_index": 1
+        },
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            8
+          ],
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CheckpointLoaderSimple"
+      },
+      "widgets_values": [
+        "sdxl/AlbedoBaseXL.safetensors"
+      ]
+    },
+    {
+      "id": 3,
+      "type": "KSampler",
+      "pos": [
+        1300,
+        210
+      ],
+      "size": {
+        "0": 315,
+        "1": 262
+      },
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 220
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 200
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 201
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 2
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            7
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "KSampler"
+      },
+      "widgets_values": [
+        1631591050,
+        "fixed",
+        30,
+        4.5,
+        "ddpm",
+        "karras",
+        1
+      ]
+    },
+    {
+      "id": 13,
+      "type": "LoadImage",
+      "pos": [
+        290,
+        70
+      ],
+      "size": {
+        "0": 210,
+        "1": 314
+      },
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            214
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "joseph-gonzalez-iFgRcqHznqg-unsplash.jpg",
+        "image"
+      ]
+    }
+  ],
+  "links": [
+    [
+      2,
+      5,
+      0,
+      3,
+      3,
+      "LATENT"
+    ],
+    [
+      7,
+      3,
+      0,
+      8,
+      0,
+      "LATENT"
+    ],
+    [
+      8,
+      4,
+      2,
+      8,
+      1,
+      "VAE"
+    ],
+    [
+      19,
+      8,
+      0,
+      15,
+      0,
+      "IMAGE"
+    ],
+    [
+      122,
+      4,
+      1,
+      39,
+      0,
+      "CLIP"
+    ],
+    [
+      123,
+      4,
+      1,
+      40,
+      0,
+      "CLIP"
+    ],
+    [
+      197,
+      11,
+      0,
+      60,
+      0,
+      "INSTANTID"
+    ],
+    [
+      198,
+      38,
+      0,
+      60,
+      1,
+      "FACEANALYSIS"
+    ],
+    [
+      199,
+      16,
+      0,
+      60,
+      2,
+      "CONTROL_NET"
+    ],
+    [
+      200,
+      60,
+      1,
+      3,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      201,
+      60,
+      2,
+      3,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      203,
+      39,
+      0,
+      60,
+      5,
+      "CONDITIONING"
+    ],
+    [
+      204,
+      40,
+      0,
+      60,
+      6,
+      "CONDITIONING"
+    ],
+    [
+      206,
+      4,
+      0,
+      60,
+      4,
+      "MODEL"
+    ],
+    [
+      214,
+      13,
+      0,
+      60,
+      3,
+      "IMAGE"
+    ],
+    [
+      220,
+      60,
+      0,
+      3,
+      0,
+      "MODEL"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

ComfyUI_InstantID/examples/InstantID_depth.json

@@ -0,0 +1,881 @@
+{
+  "last_node_id": 78,
+  "last_link_id": 239,
+  "nodes": [
+    {
+      "id": 11,
+      "type": "InstantIDModelLoader",
+      "pos": [
+        560,
+        70
+      ],
+      "size": {
+        "0": 238.72393798828125,
+        "1": 58
+      },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "INSTANTID",
+          "type": "INSTANTID",
+          "links": [
+            197
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "InstantIDModelLoader"
+      },
+      "widgets_values": [
+        "ip-adapter.bin"
+      ]
+    },
+    {
+      "id": 38,
+      "type": "InstantIDFaceAnalysis",
+      "pos": [
+        570,
+        180
+      ],
+      "size": {
+        "0": 227.09793090820312,
+        "1": 58
+      },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "FACEANALYSIS",
+          "type": "FACEANALYSIS",
+          "links": [
+            198
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "InstantIDFaceAnalysis"
+      },
+      "widgets_values": [
+        "CPU"
+      ]
+    },
+    {
+      "id": 16,
+      "type": "ControlNetLoader",
+      "pos": [
+        560,
+        290
+      ],
+      "size": {
+        "0": 250.07241821289062,
+        "1": 58
+      },
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "CONTROL_NET",
+          "type": "CONTROL_NET",
+          "links": [
+            199
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ControlNetLoader"
+      },
+      "widgets_values": [
+        "instantid/diffusion_pytorch_model.safetensors"
+      ]
+    },
+    {
+      "id": 39,
+      "type": "CLIPTextEncode",
+      "pos": [
+        520,
+        430
+      ],
+      "size": {
+        "0": 291.9967346191406,
+        "1": 128.62518310546875
+      },
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 122
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            203
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "comic character. graphic illustration, comic art, graphic novel art, vibrant, highly detailed"
+      ]
+    },
+    {
+      "id": 40,
+      "type": "CLIPTextEncode",
+      "pos": [
+        520,
+        620
+      ],
+      "size": {
+        "0": 286.3603515625,
+        "1": 112.35245513916016
+      },
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 123
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            204
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "photograph, deformed, glitch, noisy, realistic, stock photo"
+      ]
+    },
+    {
+      "id": 4,
+      "type": "CheckpointLoaderSimple",
+      "pos": [
+        70,
+        520
+      ],
+      "size": {
+        "0": 315,
+        "1": 98
+      },
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            206
+          ],
+          "slot_index": 0
+        },
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            122,
+            123
+          ],
+          "slot_index": 1
+        },
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            8
+          ],
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CheckpointLoaderSimple"
+      },
+      "widgets_values": [
+        "sdxl/AlbedoBaseXL.safetensors"
+      ]
+    },
+    {
+      "id": 60,
+      "type": "ApplyInstantID",
+      "pos": [
+        910,
+        210
+      ],
+      "size": {
+        "0": 315,
+        "1": 266
+      },
+      "flags": {},
+      "order": 11,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "instantid",
+          "type": "INSTANTID",
+          "link": 197
+        },
+        {
+          "name": "insightface",
+          "type": "FACEANALYSIS",
+          "link": 198
+        },
+        {
+          "name": "control_net",
+          "type": "CONTROL_NET",
+          "link": 199
+        },
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 214
+        },
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 206
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 203
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 204
+        },
+        {
+          "name": "image_kps",
+          "type": "IMAGE",
+          "link": 236
+        },
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            227
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "POSITIVE",
+          "type": "CONDITIONING",
+          "links": [
+            229
+          ],
+          "shape": 3,
+          "slot_index": 1
+        },
+        {
+          "name": "NEGATIVE",
+          "type": "CONDITIONING",
+          "links": [
+            228
+          ],
+          "shape": 3,
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ApplyInstantID"
+      },
+      "widgets_values": [
+        0.8,
+        0,
+        1
+      ]
+    },
+    {
+      "id": 15,
+      "type": "PreviewImage",
+      "pos": [
+        1937,
+        321
+      ],
+      "size": {
+        "0": 584.0855712890625,
+        "1": 610.4592895507812
+      },
+      "flags": {},
+      "order": 15,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 19
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 8,
+      "type": "VAEDecode",
+      "pos": [
+        1940,
+        207
+      ],
+      "size": {
+        "0": 210,
+        "1": 46
+      },
+      "flags": {},
+      "order": 14,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 7
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 8
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            19
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VAEDecode"
+      }
+    },
+    {
+      "id": 5,
+      "type": "EmptyLatentImage",
+      "pos": [
+        910,
+        540
+      ],
+      "size": {
+        "0": 315,
+        "1": 106
+      },
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            2
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "EmptyLatentImage"
+      },
+      "widgets_values": [
+        1016,
+        1016,
+        1
+      ]
+    },
+    {
+      "id": 13,
+      "type": "LoadImage",
+      "pos": [
+        290,
+        70
+      ],
+      "size": {
+        "0": 210,
+        "1": 314
+      },
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            214
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "face4.jpg",
+        "image"
+      ]
+    },
+    {
+      "id": 73,
+      "type": "ControlNetLoader",
+      "pos": [
+        909,
+        706
+      ],
+      "size": {
+        "0": 315,
+        "1": 58
+      },
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "CONTROL_NET",
+          "type": "CONTROL_NET",
+          "links": [
+            232
+          ],
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ControlNetLoader"
+      },
+      "widgets_values": [
+        "control-lora/control-lora-depth-rank256.safetensors"
+      ]
+    },
+    {
+      "id": 74,
+      "type": "LoadImage",
+      "pos": [
+        508,
+        816
+      ],
+      "size": {
+        "0": 315,
+        "1": 314.0000305175781
+      },
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            236,
+            238
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "666561.jpg",
+        "image"
+      ]
+    },
+    {
+      "id": 72,
+      "type": "ControlNetApplyAdvanced",
+      "pos": [
+        1284,
+        416
+      ],
+      "size": {
+        "0": 226.8000030517578,
+        "1": 166
+      },
+      "flags": {},
+      "order": 12,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 229
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 228
+        },
+        {
+          "name": "control_net",
+          "type": "CONTROL_NET",
+          "link": 232,
+          "slot_index": 2
+        },
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 239
+        }
+      ],
+      "outputs": [
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "links": [
+            230
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "links": [
+            231
+          ],
+          "shape": 3,
+          "slot_index": 1
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ControlNetApplyAdvanced"
+      },
+      "widgets_values": [
+        0.65,
+        0,
+        0.35000000000000003
+      ]
+    },
+    {
+      "id": 77,
+      "type": "Zoe-DepthMapPreprocessor",
+      "pos": [
+        1009,
+        839
+      ],
+      "size": [
+        210,
+        58
+      ],
+      "flags": {},
+      "order": 10,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 238
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            239
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Zoe-DepthMapPreprocessor"
+      },
+      "widgets_values": [
+        1024
+      ]
+    },
+    {
+      "id": 3,
+      "type": "KSampler",
+      "pos": [
+        1570,
+        210
+      ],
+      "size": {
+        "0": 315,
+        "1": 262
+      },
+      "flags": {},
+      "order": 13,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 227
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 230
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 231
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 2
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            7
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "KSampler"
+      },
+      "widgets_values": [
+        1631592172,
+        "fixed",
+        30,
+        4.5,
+        "ddpm",
+        "karras",
+        1
+      ]
+    }
+  ],
+  "links": [
+    [
+      2,
+      5,
+      0,
+      3,
+      3,
+      "LATENT"
+    ],
+    [
+      7,
+      3,
+      0,
+      8,
+      0,
+      "LATENT"
+    ],
+    [
+      8,
+      4,
+      2,
+      8,
+      1,
+      "VAE"
+    ],
+    [
+      19,
+      8,
+      0,
+      15,
+      0,
+      "IMAGE"
+    ],
+    [
+      122,
+      4,
+      1,
+      39,
+      0,
+      "CLIP"
+    ],
+    [
+      123,
+      4,
+      1,
+      40,
+      0,
+      "CLIP"
+    ],
+    [
+      197,
+      11,
+      0,
+      60,
+      0,
+      "INSTANTID"
+    ],
+    [
+      198,
+      38,
+      0,
+      60,
+      1,
+      "FACEANALYSIS"
+    ],
+    [
+      199,
+      16,
+      0,
+      60,
+      2,
+      "CONTROL_NET"
+    ],
+    [
+      203,
+      39,
+      0,
+      60,
+      5,
+      "CONDITIONING"
+    ],
+    [
+      204,
+      40,
+      0,
+      60,
+      6,
+      "CONDITIONING"
+    ],
+    [
+      206,
+      4,
+      0,
+      60,
+      4,
+      "MODEL"
+    ],
+    [
+      214,
+      13,
+      0,
+      60,
+      3,
+      "IMAGE"
+    ],
+    [
+      227,
+      60,
+      0,
+      3,
+      0,
+      "MODEL"
+    ],
+    [
+      228,
+      60,
+      2,
+      72,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      229,
+      60,
+      1,
+      72,
+      0,
+      "CONDITIONING"
+    ],
+    [
+      230,
+      72,
+      0,
+      3,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      231,
+      72,
+      1,
+      3,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      232,
+      73,
+      0,
+      72,
+      2,
+      "CONTROL_NET"
+    ],
+    [
+      236,
+      74,
+      0,
+      60,
+      7,
+      "IMAGE"
+    ],
+    [
+      238,
+      74,
+      0,
+      77,
+      0,
+      "IMAGE"
+    ],
+    [
+      239,
+      77,
+      0,
+      72,
+      3,
+      "IMAGE"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

ComfyUI_InstantID/examples/InstantID_multi_id.json

@@ -0,0 +1,1364 @@
+{
+  "last_node_id": 92,
+  "last_link_id": 290,
+  "nodes": [
+    {
+      "id": 15,
+      "type": "PreviewImage",
+      "pos": [
+        2160,
+        -150
+      ],
+      "size": {
+        "0": 584.0855712890625,
+        "1": 610.4592895507812
+      },
+      "flags": {},
+      "order": 23,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 19
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 8,
+      "type": "VAEDecode",
+      "pos": [
+        2170,
+        -270
+      ],
+      "size": {
+        "0": 210,
+        "1": 46
+      },
+      "flags": {},
+      "order": 22,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 7
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 254
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            19
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VAEDecode"
+      }
+    },
+    {
+      "id": 81,
+      "type": "Reroute",
+      "pos": [
+        1980,
+        120
+      ],
+      "size": [
+        75,
+        26
+      ],
+      "flags": {},
+      "order": 13,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "",
+          "type": "*",
+          "link": 253
+        }
+      ],
+      "outputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            254
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "showOutputText": true,
+        "horizontal": false
+      }
+    },
+    {
+      "id": 38,
+      "type": "InstantIDFaceAnalysis",
+      "pos": [
+        -210,
+        -40
+      ],
+      "size": [
+        210,
+        60
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "FACEANALYSIS",
+          "type": "FACEANALYSIS",
+          "links": [
+            198,
+            239
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "InstantIDFaceAnalysis"
+      },
+      "widgets_values": [
+        "CPU"
+      ]
+    },
+    {
+      "id": 16,
+      "type": "ControlNetLoader",
+      "pos": [
+        -210,
+        70
+      ],
+      "size": [
+        210,
+        60
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "CONTROL_NET",
+          "type": "CONTROL_NET",
+          "links": [
+            199,
+            240
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ControlNetLoader"
+      },
+      "widgets_values": [
+        "instantid/diffusion_pytorch_model.safetensors"
+      ]
+    },
+    {
+      "id": 79,
+      "type": "ConditioningCombine",
+      "pos": [
+        1410,
+        -190
+      ],
+      "size": [
+        228.39999389648438,
+        46
+      ],
+      "flags": {},
+      "order": 19,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "conditioning_1",
+          "type": "CONDITIONING",
+          "link": 247
+        },
+        {
+          "name": "conditioning_2",
+          "type": "CONDITIONING",
+          "link": 248
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            249
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ConditioningCombine"
+      }
+    },
+    {
+      "id": 84,
+      "type": "ImageFlip+",
+      "pos": [
+        990,
+        -210
+      ],
+      "size": {
+        "0": 315,
+        "1": 58
+      },
+      "flags": {},
+      "order": 15,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 258
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            259
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ImageFlip+"
+      },
+      "widgets_values": [
+        "x"
+      ]
+    },
+    {
+      "id": 13,
+      "type": "LoadImage",
+      "pos": [
+        715,
+        35
+      ],
+      "size": [
+        213.36950471073226,
+        296.38119750842566
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            214
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "face4.jpg",
+        "image"
+      ]
+    },
+    {
+      "id": 88,
+      "type": "MaskFlip+",
+      "pos": [
+        990,
+        -110
+      ],
+      "size": {
+        "0": 315,
+        "1": 58
+      },
+      "flags": {},
+      "order": 17,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": 263
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": [
+            264
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "MaskFlip+"
+      },
+      "widgets_values": [
+        "x"
+      ]
+    },
+    {
+      "id": 78,
+      "type": "LoadImage",
+      "pos": [
+        714,
+        -512
+      ],
+      "size": [
+        210,
+        314
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            246
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "joseph-gonzalez-iFgRcqHznqg-unsplash.jpg",
+        "image"
+      ]
+    },
+    {
+      "id": 85,
+      "type": "SolidMask",
+      "pos": [
+        970,
+        510
+      ],
+      "size": [
+        210,
+        106
+      ],
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": [
+            260
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "SolidMask"
+      },
+      "widgets_values": [
+        0,
+        1280,
+        960
+      ]
+    },
+    {
+      "id": 11,
+      "type": "InstantIDModelLoader",
+      "pos": [
+        -210,
+        -150
+      ],
+      "size": [
+        210,
+        60
+      ],
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "INSTANTID",
+          "type": "INSTANTID",
+          "links": [
+            197,
+            238
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "InstantIDModelLoader"
+      },
+      "widgets_values": [
+        "ip-adapter.bin"
+      ]
+    },
+    {
+      "id": 4,
+      "type": "CheckpointLoaderSimple",
+      "pos": [
+        -312,
+        198
+      ],
+      "size": {
+        "0": 315,
+        "1": 98
+      },
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            206
+          ],
+          "slot_index": 0
+        },
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            122,
+            123,
+            266
+          ],
+          "slot_index": 1
+        },
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            253
+          ],
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CheckpointLoaderSimple"
+      },
+      "widgets_values": [
+        "sdxl/AlbedoBaseXL.safetensors"
+      ]
+    },
+    {
+      "id": 87,
+      "type": "MaskComposite",
+      "pos": [
+        1232,
+        583
+      ],
+      "size": [
+        210,
+        126
+      ],
+      "flags": {},
+      "order": 14,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "destination",
+          "type": "MASK",
+          "link": 260
+        },
+        {
+          "name": "source",
+          "type": "MASK",
+          "link": 261
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": [
+            262,
+            263
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "MaskComposite"
+      },
+      "widgets_values": [
+        0,
+        0,
+        "add"
+      ]
+    },
+    {
+      "id": 86,
+      "type": "SolidMask",
+      "pos": [
+        970,
+        660
+      ],
+      "size": {
+        "0": 210,
+        "1": 106
+      },
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": [
+            261
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "SolidMask"
+      },
+      "widgets_values": [
+        1,
+        640,
+        960
+      ]
+    },
+    {
+      "id": 82,
+      "type": "LoadImage",
+      "pos": [
+        591,
+        511
+      ],
+      "size": [
+        315,
+        314.0000190734863
+      ],
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            257,
+            258
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "pose (1).jpg",
+        "image"
+      ]
+    },
+    {
+      "id": 40,
+      "type": "CLIPTextEncode",
+      "pos": [
+        146,
+        487
+      ],
+      "size": {
+        "0": 286.3603515625,
+        "1": 112.35245513916016
+      },
+      "flags": {},
+      "order": 11,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 123
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            204,
+            278
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "photograph, deformed, glitch, noisy, realistic, stock photo, naked"
+      ],
+      "color": "#322",
+      "bgcolor": "#533"
+    },
+    {
+      "id": 5,
+      "type": "EmptyLatentImage",
+      "pos": [
+        1431,
+        20
+      ],
+      "size": [
+        210,
+        106
+      ],
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            2
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "EmptyLatentImage"
+      },
+      "widgets_values": [
+        1280,
+        960,
+        1
+      ]
+    },
+    {
+      "id": 3,
+      "type": "KSampler",
+      "pos": [
+        1730,
+        -180
+      ],
+      "size": {
+        "0": 315,
+        "1": 262
+      },
+      "flags": {},
+      "order": 21,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 256
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 249
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 288
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 2
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            7
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "KSampler"
+      },
+      "widgets_values": [
+        1631594039,
+        "fixed",
+        30,
+        4.5,
+        "ddpm",
+        "normal",
+        1
+      ]
+    },
+    {
+      "id": 80,
+      "type": "ConditioningCombine",
+      "pos": [
+        1410,
+        -90
+      ],
+      "size": {
+        "0": 228.39999389648438,
+        "1": 46
+      },
+      "flags": {},
+      "order": 20,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "conditioning_1",
+          "type": "CONDITIONING",
+          "link": 290
+        },
+        {
+          "name": "conditioning_2",
+          "type": "CONDITIONING",
+          "link": 287
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            288
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ConditioningCombine"
+      }
+    },
+    {
+      "id": 77,
+      "type": "ApplyInstantID",
+      "pos": [
+        990,
+        -528
+      ],
+      "size": {
+        "0": 315,
+        "1": 266
+      },
+      "flags": {},
+      "order": 18,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "instantid",
+          "type": "INSTANTID",
+          "link": 238
+        },
+        {
+          "name": "insightface",
+          "type": "FACEANALYSIS",
+          "link": 239
+        },
+        {
+          "name": "control_net",
+          "type": "CONTROL_NET",
+          "link": 240
+        },
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 246
+        },
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 255
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 272
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 278
+        },
+        {
+          "name": "image_kps",
+          "type": "IMAGE",
+          "link": 259
+        },
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": 264
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            256
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "POSITIVE",
+          "type": "CONDITIONING",
+          "links": [
+            247
+          ],
+          "shape": 3,
+          "slot_index": 1
+        },
+        {
+          "name": "NEGATIVE",
+          "type": "CONDITIONING",
+          "links": [
+            290
+          ],
+          "shape": 3,
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ApplyInstantID"
+      },
+      "widgets_values": [
+        0.8,
+        0,
+        1
+      ]
+    },
+    {
+      "id": 60,
+      "type": "ApplyInstantID",
+      "pos": [
+        991,
+        73
+      ],
+      "size": {
+        "0": 315,
+        "1": 266
+      },
+      "flags": {},
+      "order": 16,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "instantid",
+          "type": "INSTANTID",
+          "link": 197
+        },
+        {
+          "name": "insightface",
+          "type": "FACEANALYSIS",
+          "link": 198
+        },
+        {
+          "name": "control_net",
+          "type": "CONTROL_NET",
+          "link": 199
+        },
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 214
+        },
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 206
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 203
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 204
+        },
+        {
+          "name": "image_kps",
+          "type": "IMAGE",
+          "link": 257
+        },
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": 262
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            255
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "POSITIVE",
+          "type": "CONDITIONING",
+          "links": [
+            248
+          ],
+          "shape": 3,
+          "slot_index": 1
+        },
+        {
+          "name": "NEGATIVE",
+          "type": "CONDITIONING",
+          "links": [
+            287
+          ],
+          "shape": 3,
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ApplyInstantID"
+      },
+      "widgets_values": [
+        0.9,
+        0,
+        1
+      ]
+    },
+    {
+      "id": 89,
+      "type": "CLIPTextEncode",
+      "pos": [
+        314,
+        -421
+      ],
+      "size": {
+        "0": 291.9967346191406,
+        "1": 128.62518310546875
+      },
+      "flags": {},
+      "order": 12,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 266
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            272
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "comic male character. graphic illustration, comic art, graphic novel art, vibrant, highly detailed. New York background"
+      ],
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 39,
+      "type": "CLIPTextEncode",
+      "pos": [
+        309,
+        171
+      ],
+      "size": {
+        "0": 291.9967346191406,
+        "1": 128.62518310546875
+      },
+      "flags": {},
+      "order": 10,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 122
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            203
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "comic female character. graphic illustration, comic art, graphic novel art, vibrant, highly detailed. New York background"
+      ],
+      "color": "#232",
+      "bgcolor": "#353"
+    }
+  ],
+  "links": [
+    [
+      2,
+      5,
+      0,
+      3,
+      3,
+      "LATENT"
+    ],
+    [
+      7,
+      3,
+      0,
+      8,
+      0,
+      "LATENT"
+    ],
+    [
+      19,
+      8,
+      0,
+      15,
+      0,
+      "IMAGE"
+    ],
+    [
+      122,
+      4,
+      1,
+      39,
+      0,
+      "CLIP"
+    ],
+    [
+      123,
+      4,
+      1,
+      40,
+      0,
+      "CLIP"
+    ],
+    [
+      197,
+      11,
+      0,
+      60,
+      0,
+      "INSTANTID"
+    ],
+    [
+      198,
+      38,
+      0,
+      60,
+      1,
+      "FACEANALYSIS"
+    ],
+    [
+      199,
+      16,
+      0,
+      60,
+      2,
+      "CONTROL_NET"
+    ],
+    [
+      203,
+      39,
+      0,
+      60,
+      5,
+      "CONDITIONING"
+    ],
+    [
+      204,
+      40,
+      0,
+      60,
+      6,
+      "CONDITIONING"
+    ],
+    [
+      206,
+      4,
+      0,
+      60,
+      4,
+      "MODEL"
+    ],
+    [
+      214,
+      13,
+      0,
+      60,
+      3,
+      "IMAGE"
+    ],
+    [
+      238,
+      11,
+      0,
+      77,
+      0,
+      "INSTANTID"
+    ],
+    [
+      239,
+      38,
+      0,
+      77,
+      1,
+      "FACEANALYSIS"
+    ],
+    [
+      240,
+      16,
+      0,
+      77,
+      2,
+      "CONTROL_NET"
+    ],
+    [
+      246,
+      78,
+      0,
+      77,
+      3,
+      "IMAGE"
+    ],
+    [
+      247,
+      77,
+      1,
+      79,
+      0,
+      "CONDITIONING"
+    ],
+    [
+      248,
+      60,
+      1,
+      79,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      249,
+      79,
+      0,
+      3,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      253,
+      4,
+      2,
+      81,
+      0,
+      "*"
+    ],
+    [
+      254,
+      81,
+      0,
+      8,
+      1,
+      "VAE"
+    ],
+    [
+      255,
+      60,
+      0,
+      77,
+      4,
+      "MODEL"
+    ],
+    [
+      256,
+      77,
+      0,
+      3,
+      0,
+      "MODEL"
+    ],
+    [
+      257,
+      82,
+      0,
+      60,
+      7,
+      "IMAGE"
+    ],
+    [
+      258,
+      82,
+      0,
+      84,
+      0,
+      "IMAGE"
+    ],
+    [
+      259,
+      84,
+      0,
+      77,
+      7,
+      "IMAGE"
+    ],
+    [
+      260,
+      85,
+      0,
+      87,
+      0,
+      "MASK"
+    ],
+    [
+      261,
+      86,
+      0,
+      87,
+      1,
+      "MASK"
+    ],
+    [
+      262,
+      87,
+      0,
+      60,
+      8,
+      "MASK"
+    ],
+    [
+      263,
+      87,
+      0,
+      88,
+      0,
+      "MASK"
+    ],
+    [
+      264,
+      88,
+      0,
+      77,
+      8,
+      "MASK"
+    ],
+    [
+      266,
+      4,
+      1,
+      89,
+      0,
+      "CLIP"
+    ],
+    [
+      272,
+      89,
+      0,
+      77,
+      5,
+      "CONDITIONING"
+    ],
+    [
+      278,
+      40,
+      0,
+      77,
+      6,
+      "CONDITIONING"
+    ],
+    [
+      287,
+      60,
+      2,
+      80,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      288,
+      80,
+      0,
+      3,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      290,
+      77,
+      2,
+      80,
+      0,
+      "CONDITIONING"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

ComfyUI_InstantID/examples/InstantID_posed.json

@@ -0,0 +1,704 @@
+{
+  "last_node_id": 67,
+  "last_link_id": 221,
+  "nodes": [
+    {
+      "id": 11,
+      "type": "InstantIDModelLoader",
+      "pos": [
+        560,
+        70
+      ],
+      "size": {
+        "0": 238.72393798828125,
+        "1": 58
+      },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "INSTANTID",
+          "type": "INSTANTID",
+          "links": [
+            197
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "InstantIDModelLoader"
+      },
+      "widgets_values": [
+        "ip-adapter.bin"
+      ]
+    },
+    {
+      "id": 38,
+      "type": "InstantIDFaceAnalysis",
+      "pos": [
+        570,
+        180
+      ],
+      "size": {
+        "0": 227.09793090820312,
+        "1": 58
+      },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "FACEANALYSIS",
+          "type": "FACEANALYSIS",
+          "links": [
+            198
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "InstantIDFaceAnalysis"
+      },
+      "widgets_values": [
+        "CPU"
+      ]
+    },
+    {
+      "id": 16,
+      "type": "ControlNetLoader",
+      "pos": [
+        560,
+        290
+      ],
+      "size": {
+        "0": 250.07241821289062,
+        "1": 58
+      },
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "CONTROL_NET",
+          "type": "CONTROL_NET",
+          "links": [
+            199
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ControlNetLoader"
+      },
+      "widgets_values": [
+        "instantid/diffusion_pytorch_model.safetensors"
+      ]
+    },
+    {
+      "id": 15,
+      "type": "PreviewImage",
+      "pos": [
+        1670,
+        300
+      ],
+      "size": {
+        "0": 584.0855712890625,
+        "1": 610.4592895507812
+      },
+      "flags": {},
+      "order": 12,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 19
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 5,
+      "type": "EmptyLatentImage",
+      "pos": [
+        910,
+        540
+      ],
+      "size": {
+        "0": 315,
+        "1": 106
+      },
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            2
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "EmptyLatentImage"
+      },
+      "widgets_values": [
+        1016,
+        1016,
+        1
+      ]
+    },
+    {
+      "id": 8,
+      "type": "VAEDecode",
+      "pos": [
+        1670,
+        210
+      ],
+      "size": {
+        "0": 210,
+        "1": 46
+      },
+      "flags": {},
+      "order": 11,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 7
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 8
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            19
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VAEDecode"
+      }
+    },
+    {
+      "id": 60,
+      "type": "ApplyInstantID",
+      "pos": [
+        910,
+        210
+      ],
+      "size": {
+        "0": 315,
+        "1": 266
+      },
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "instantid",
+          "type": "INSTANTID",
+          "link": 197
+        },
+        {
+          "name": "insightface",
+          "type": "FACEANALYSIS",
+          "link": 198
+        },
+        {
+          "name": "control_net",
+          "type": "CONTROL_NET",
+          "link": 199
+        },
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 214
+        },
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 206
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 203
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 204
+        },
+        {
+          "name": "image_kps",
+          "type": "IMAGE",
+          "link": 221
+        },
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            220
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "POSITIVE",
+          "type": "CONDITIONING",
+          "links": [
+            200
+          ],
+          "shape": 3,
+          "slot_index": 1
+        },
+        {
+          "name": "NEGATIVE",
+          "type": "CONDITIONING",
+          "links": [
+            201
+          ],
+          "shape": 3,
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ApplyInstantID"
+      },
+      "widgets_values": [
+        0.8,
+        0,
+        1
+      ]
+    },
+    {
+      "id": 39,
+      "type": "CLIPTextEncode",
+      "pos": [
+        520,
+        430
+      ],
+      "size": {
+        "0": 291.9967346191406,
+        "1": 128.62518310546875
+      },
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 122
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            203
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "comic character. graphic illustration, comic art, graphic novel art, vibrant, highly detailed"
+      ]
+    },
+    {
+      "id": 40,
+      "type": "CLIPTextEncode",
+      "pos": [
+        520,
+        620
+      ],
+      "size": {
+        "0": 286.3603515625,
+        "1": 112.35245513916016
+      },
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 123
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            204
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "photograph, deformed, glitch, noisy, realistic, stock photo"
+      ]
+    },
+    {
+      "id": 4,
+      "type": "CheckpointLoaderSimple",
+      "pos": [
+        70,
+        520
+      ],
+      "size": {
+        "0": 315,
+        "1": 98
+      },
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            206
+          ],
+          "slot_index": 0
+        },
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            122,
+            123
+          ],
+          "slot_index": 1
+        },
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            8
+          ],
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CheckpointLoaderSimple"
+      },
+      "widgets_values": [
+        "sdxl/AlbedoBaseXL.safetensors"
+      ]
+    },
+    {
+      "id": 13,
+      "type": "LoadImage",
+      "pos": [
+        290,
+        70
+      ],
+      "size": {
+        "0": 210,
+        "1": 314
+      },
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            214
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "joseph-gonzalez-iFgRcqHznqg-unsplash.jpg",
+        "image"
+      ]
+    },
+    {
+      "id": 67,
+      "type": "LoadImage",
+      "pos": [
+        592,
+        781
+      ],
+      "size": {
+        "0": 210,
+        "1": 314
+      },
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            221
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "miranda.jpg",
+        "image"
+      ]
+    },
+    {
+      "id": 3,
+      "type": "KSampler",
+      "pos": [
+        1300,
+        210
+      ],
+      "size": {
+        "0": 315,
+        "1": 262
+      },
+      "flags": {},
+      "order": 10,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 220
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 200
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 201
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 2
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            7
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "KSampler"
+      },
+      "widgets_values": [
+        1631591431,
+        "fixed",
+        30,
+        4.5,
+        "ddpm",
+        "karras",
+        1
+      ]
+    }
+  ],
+  "links": [
+    [
+      2,
+      5,
+      0,
+      3,
+      3,
+      "LATENT"
+    ],
+    [
+      7,
+      3,
+      0,
+      8,
+      0,
+      "LATENT"
+    ],
+    [
+      8,
+      4,
+      2,
+      8,
+      1,
+      "VAE"
+    ],
+    [
+      19,
+      8,
+      0,
+      15,
+      0,
+      "IMAGE"
+    ],
+    [
+      122,
+      4,
+      1,
+      39,
+      0,
+      "CLIP"
+    ],
+    [
+      123,
+      4,
+      1,
+      40,
+      0,
+      "CLIP"
+    ],
+    [
+      197,
+      11,
+      0,
+      60,
+      0,
+      "INSTANTID"
+    ],
+    [
+      198,
+      38,
+      0,
+      60,
+      1,
+      "FACEANALYSIS"
+    ],
+    [
+      199,
+      16,
+      0,
+      60,
+      2,
+      "CONTROL_NET"
+    ],
+    [
+      200,
+      60,
+      1,
+      3,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      201,
+      60,
+      2,
+      3,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      203,
+      39,
+      0,
+      60,
+      5,
+      "CONDITIONING"
+    ],
+    [
+      204,
+      40,
+      0,
+      60,
+      6,
+      "CONDITIONING"
+    ],
+    [
+      206,
+      4,
+      0,
+      60,
+      4,
+      "MODEL"
+    ],
+    [
+      214,
+      13,
+      0,
+      60,
+      3,
+      "IMAGE"
+    ],
+    [
+      220,
+      60,
+      0,
+      3,
+      0,
+      "MODEL"
+    ],
+    [
+      221,
+      67,
+      0,
+      60,
+      7,
+      "IMAGE"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

ComfyUI_InstantID/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "comfyui_instantid"
+description = "Native InstantID support for ComfyUI. This extension differs from the many already available as it doesn't use diffusers but instead implements InstantID natively and it fully integrates with ComfyUI."
+version = "1.0.0"
+license = "LICENSE"
+dependencies = ["insightface", "onnxruntime", "onnxruntime-gpu"]
+
+[project.urls]
+Repository = "https://github.com/cubiq/ComfyUI_InstantID"
+#  Used by Comfy Registry https://comfyregistry.org
+
+[tool.comfy]
+PublisherId = "matteo"
+DisplayName = "ComfyUI_InstantID"
+Icon = ""

ComfyUI_InstantID/requirements.txt

@@ -0,0 +1,3 @@
+insightface
+onnxruntime
+onnxruntime-gpu; sys_platform != 'darwin' and platform_machine == 'x86_64'

ComfyUI_InstantID/resampler.py

@@ -0,0 +1,121 @@
+# modified from https://github.com/mlfoundations/open_flamingo/blob/main/open_flamingo/src/helpers.py
+import math
+
+import torch
+import torch.nn as nn
+
+
+# FFN
+def FeedForward(dim, mult=4):
+    inner_dim = int(dim * mult)
+    return nn.Sequential(
+        nn.LayerNorm(dim),
+        nn.Linear(dim, inner_dim, bias=False),
+        nn.GELU(),
+        nn.Linear(inner_dim, dim, bias=False),
+    )
+    
+    
+def reshape_tensor(x, heads):
+    bs, length, width = x.shape
+    #(bs, length, width) --> (bs, length, n_heads, dim_per_head)
+    x = x.view(bs, length, heads, -1)
+    # (bs, length, n_heads, dim_per_head) --> (bs, n_heads, length, dim_per_head)
+    x = x.transpose(1, 2)
+    # (bs, n_heads, length, dim_per_head) --> (bs*n_heads, length, dim_per_head)
+    x = x.reshape(bs, heads, length, -1)
+    return x
+
+
+class PerceiverAttention(nn.Module):
+    def __init__(self, *, dim, dim_head=64, heads=8):
+        super().__init__()
+        self.scale = dim_head**-0.5
+        self.dim_head = dim_head
+        self.heads = heads
+        inner_dim = dim_head * heads
+
+        self.norm1 = nn.LayerNorm(dim)
+        self.norm2 = nn.LayerNorm(dim)
+
+        self.to_q = nn.Linear(dim, inner_dim, bias=False)
+        self.to_kv = nn.Linear(dim, inner_dim * 2, bias=False)
+        self.to_out = nn.Linear(inner_dim, dim, bias=False)
+
+
+    def forward(self, x, latents):
+        """
+        Args:
+            x (torch.Tensor): image features
+                shape (b, n1, D)
+            latent (torch.Tensor): latent features
+                shape (b, n2, D)
+        """
+        x = self.norm1(x)
+        latents = self.norm2(latents)
+        
+        b, l, _ = latents.shape
+
+        q = self.to_q(latents)
+        kv_input = torch.cat((x, latents), dim=-2)
+        k, v = self.to_kv(kv_input).chunk(2, dim=-1)
+        
+        q = reshape_tensor(q, self.heads)
+        k = reshape_tensor(k, self.heads)
+        v = reshape_tensor(v, self.heads)
+
+        # attention
+        scale = 1 / math.sqrt(math.sqrt(self.dim_head))
+        weight = (q * scale) @ (k * scale).transpose(-2, -1) # More stable with f16 than dividing afterwards
+        weight = torch.softmax(weight.float(), dim=-1).type(weight.dtype)
+        out = weight @ v
+        
+        out = out.permute(0, 2, 1, 3).reshape(b, l, -1)
+
+        return self.to_out(out)
+
+
+class Resampler(nn.Module):
+    def __init__(
+        self,
+        dim=1024,
+        depth=8,
+        dim_head=64,
+        heads=16,
+        num_queries=8,
+        embedding_dim=768,
+        output_dim=1024,
+        ff_mult=4,
+    ):
+        super().__init__()
+        
+        self.latents = nn.Parameter(torch.randn(1, num_queries, dim) / dim**0.5)
+        
+        self.proj_in = nn.Linear(embedding_dim, dim)
+
+        self.proj_out = nn.Linear(dim, output_dim)
+        self.norm_out = nn.LayerNorm(output_dim)
+        
+        self.layers = nn.ModuleList([])
+        for _ in range(depth):
+            self.layers.append(
+                nn.ModuleList(
+                    [
+                        PerceiverAttention(dim=dim, dim_head=dim_head, heads=heads),
+                        FeedForward(dim=dim, mult=ff_mult),
+                    ]
+                )
+            )
+
+    def forward(self, x):
+        
+        latents = self.latents.repeat(x.size(0), 1, 1)
+        
+        x = self.proj_in(x)
+        
+        for attn, ff in self.layers:
+            latents = attn(x, latents) + latents
+            latents = ff(latents) + latents
+            
+        latents = self.proj_out(latents)
+        return self.norm_out(latents)

ComfyUI_InstantID/utils.py

@@ -0,0 +1,24 @@
+import torch
+
+def tensor_to_size(source, dest_size):
+    if isinstance(dest_size, torch.Tensor):
+        dest_size = dest_size.shape[0]
+    source_size = source.shape[0]
+
+    if source_size < dest_size:
+        shape = [dest_size - source_size] + [1]*(source.dim()-1)
+        source = torch.cat((source, source[-1:].repeat(shape)), dim=0)
+    elif source_size > dest_size:
+        source = source[:dest_size]
+
+    return source
+
+def tensor_to_image(tensor):
+    image = tensor.mul(255).clamp(0, 255).byte().cpu()
+    image = image[..., [2, 1, 0]].numpy()
+    return image
+
+def image_to_tensor(image):
+    tensor = torch.clamp(torch.from_numpy(image).float() / 255., 0, 1)
+    tensor = tensor[..., [2, 1, 0]]
+    return tensor

ComfyUI_essentials/.github/workflows/publish.yml

@@ -0,0 +1,22 @@
+name: Publish to Comfy registry
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+      - master
+    paths:
+      - "pyproject.toml"
+
+jobs:
+  publish-node:
+    name: Publish Custom Node to registry
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+      - name: Publish Custom Node
+        uses: Comfy-Org/publish-node-action@main
+        with:
+          ## Add your own personal access token to your Github Repository secrets and reference it here.
+          personal_access_token: ${{ secrets.REGISTRY_ACCESS_TOKEN }}

ComfyUI_essentials/.gitignore

@@ -0,0 +1,6 @@
+/__pycache__/
+/luts/*.cube
+/luts/*.CUBE
+/fonts/*.ttf
+/fonts/*.otf
+!/fonts/ShareTechMono-Regular.ttf

ComfyUI_essentials/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Matteo Spinelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ComfyUI_essentials/README.md

@@ -0,0 +1,49 @@
+# :wrench: ComfyUI Essentials
+
+Essential nodes that are weirdly missing from ComfyUI core. With few exceptions they are new features and not commodities. I hope this will be just a temporary repository until the nodes get included into ComfyUI.
+
+# Sponsorship
+
+<div align="center">
+
+**[:heart: Github Sponsor](https://github.com/sponsors/cubiq) | [:coin: Paypal](https://paypal.me/matt3o)**
+
+</div>
+
+If you like my work and wish to see updates and new features please consider sponsoring my projects.
+
+- [ComfyUI IPAdapter Plus](https://github.com/cubiq/ComfyUI_IPAdapter_plus)
+- [ComfyUI InstantID (Native)](https://github.com/cubiq/ComfyUI_InstantID)
+- [ComfyUI Essentials](https://github.com/cubiq/ComfyUI_essentials)
+- [ComfyUI FaceAnalysis](https://github.com/cubiq/ComfyUI_FaceAnalysis)
+
+Not to mention the documentation and videos tutorials. Check my **ComfyUI Advanced Understanding** videos on YouTube for example, [part 1](https://www.youtube.com/watch?v=_C7kR2TFIX0) and [part 2](https://www.youtube.com/watch?v=ijqXnW_9gzc)
+
+The only way to keep the code open and free is by sponsoring its development. The more sponsorships the more time I can dedicate to my open source projects.
+
+Please consider a [Github Sponsorship](https://github.com/sponsors/cubiq) or [PayPal donation](https://paypal.me/matt3o) (Matteo "matt3o" Spinelli). For sponsorships of $50+, let me know if you'd like to be mentioned in this readme file, you can find me on [Discord](https://latent.vision/discord) or _matt3o :snail: gmail.com_.
+
+## Current sponsors
+
+It's only thanks to generous sponsors that **the whole community** can enjoy open and free software. Please join me in thanking the following companies and individuals!
+
+### :trophy: Gold sponsors
+
+[![Kaiber.ai](https://f.latent.vision/imgs/kaiber.png)](https://kaiber.ai/)&nbsp; &nbsp;[![InstaSD](https://f.latent.vision/imgs/instasd.png)](https://www.instasd.com/)
+
+### :tada: Silver sponsors
+
+[![OperArt.ai](https://f.latent.vision/imgs/openart.png?r=1)](https://openart.ai/workflows)&nbsp; &nbsp;[![Finetuners](https://f.latent.vision/imgs/finetuners.png)](https://www.finetuners.ai/)&nbsp; &nbsp;[![Comfy.ICU](https://f.latent.vision/imgs/comfyicu.png?r=1)](https://comfy.icu/)
+
+### Other companies supporting my projects
+
+- [RunComfy](https://www.runcomfy.com/) (ComfyUI Cloud)
+
+### Esteemed individuals
+
+- [Øystein Ø. Olsen](https://github.com/FireNeslo)
+- [Jack Gane](https://github.com/ganeJackS)
+- [Nathan Shipley](https://www.nathanshipley.com/)
+- [Dkdnzia](https://github.com/Dkdnzia)
+
+[And all my public and private sponsors!](https://github.com/sponsors/cubiq)

ComfyUI_essentials/__init__.py

@@ -0,0 +1,36 @@
+#from .essentials import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS
+from .image import IMAGE_CLASS_MAPPINGS, IMAGE_NAME_MAPPINGS
+from .mask import MASK_CLASS_MAPPINGS, MASK_NAME_MAPPINGS
+from .sampling import SAMPLING_CLASS_MAPPINGS, SAMPLING_NAME_MAPPINGS
+from .segmentation import SEG_CLASS_MAPPINGS, SEG_NAME_MAPPINGS
+from .misc import MISC_CLASS_MAPPINGS, MISC_NAME_MAPPINGS
+from .conditioning import COND_CLASS_MAPPINGS, COND_NAME_MAPPINGS
+from .text import TEXT_CLASS_MAPPINGS, TEXT_NAME_MAPPINGS
+
+WEB_DIRECTORY = "./js"
+
+NODE_CLASS_MAPPINGS = {}
+NODE_DISPLAY_NAME_MAPPINGS = {}
+
+NODE_CLASS_MAPPINGS.update(COND_CLASS_MAPPINGS)
+NODE_DISPLAY_NAME_MAPPINGS.update(COND_NAME_MAPPINGS)
+
+NODE_CLASS_MAPPINGS.update(IMAGE_CLASS_MAPPINGS)
+NODE_DISPLAY_NAME_MAPPINGS.update(IMAGE_NAME_MAPPINGS)
+
+NODE_CLASS_MAPPINGS.update(MASK_CLASS_MAPPINGS)
+NODE_DISPLAY_NAME_MAPPINGS.update(MASK_NAME_MAPPINGS)
+
+NODE_CLASS_MAPPINGS.update(SAMPLING_CLASS_MAPPINGS)
+NODE_DISPLAY_NAME_MAPPINGS.update(SAMPLING_NAME_MAPPINGS)
+
+NODE_CLASS_MAPPINGS.update(SEG_CLASS_MAPPINGS)
+NODE_DISPLAY_NAME_MAPPINGS.update(SEG_NAME_MAPPINGS)
+
+NODE_CLASS_MAPPINGS.update(TEXT_CLASS_MAPPINGS)
+NODE_DISPLAY_NAME_MAPPINGS.update(TEXT_NAME_MAPPINGS)
+
+NODE_CLASS_MAPPINGS.update(MISC_CLASS_MAPPINGS)
+NODE_DISPLAY_NAME_MAPPINGS.update(MISC_NAME_MAPPINGS)
+
+__all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS', "WEB_DIRECTORY"]

ComfyUI_essentials/carve.py

@@ -0,0 +1,454 @@
+# MIT licensed code from https://github.com/li-plus/seam-carving/
+
+from enum import Enum
+from typing import Optional, Tuple
+
+import numba as nb
+import numpy as np
+from scipy.ndimage import sobel
+
+DROP_MASK_ENERGY = 1e5
+KEEP_MASK_ENERGY = 1e3
+
+
+class OrderMode(str, Enum):
+    WIDTH_FIRST = "width-first"
+    HEIGHT_FIRST = "height-first"
+
+
+class EnergyMode(str, Enum):
+    FORWARD = "forward"
+    BACKWARD = "backward"
+
+
+def _list_enum(enum_class) -> Tuple:
+    return tuple(x.value for x in enum_class)
+
+
+def _rgb2gray(rgb: np.ndarray) -> np.ndarray:
+    """Convert an RGB image to a grayscale image"""
+    coeffs = np.array([0.2125, 0.7154, 0.0721], dtype=np.float32)
+    return (rgb @ coeffs).astype(rgb.dtype)
+
+
+def _get_seam_mask(src: np.ndarray, seam: np.ndarray) -> np.ndarray:
+    """Convert a list of seam column indices to a mask"""
+    return np.eye(src.shape[1], dtype=bool)[seam]
+
+
+def _remove_seam_mask(src: np.ndarray, seam_mask: np.ndarray) -> np.ndarray:
+    """Remove a seam from the source image according to the given seam_mask"""
+    if src.ndim == 3:
+        h, w, c = src.shape
+        seam_mask = np.broadcast_to(seam_mask[:, :, None], src.shape)
+        dst = src[~seam_mask].reshape((h, w - 1, c))
+    else:
+        h, w = src.shape
+        dst = src[~seam_mask].reshape((h, w - 1))
+    return dst
+
+
+def _get_energy(gray: np.ndarray) -> np.ndarray:
+    """Get backward energy map from the source image"""
+    assert gray.ndim == 2
+
+    gray = gray.astype(np.float32)
+    grad_x = sobel(gray, axis=1)
+    grad_y = sobel(gray, axis=0)
+    energy = np.abs(grad_x) + np.abs(grad_y)
+    return energy
+
+
+@nb.njit(nb.int32[:](nb.float32[:, :]), cache=True)
+def _get_backward_seam(energy: np.ndarray) -> np.ndarray:
+    """Compute the minimum vertical seam from the backward energy map"""
+    h, w = energy.shape
+    inf = np.array([np.inf], dtype=np.float32)
+    cost = np.concatenate((inf, energy[0], inf))
+    parent = np.empty((h, w), dtype=np.int32)
+    base_idx = np.arange(-1, w - 1, dtype=np.int32)
+
+    for r in range(1, h):
+        choices = np.vstack((cost[:-2], cost[1:-1], cost[2:]))
+        min_idx = np.argmin(choices, axis=0) + base_idx
+        parent[r] = min_idx
+        cost[1:-1] = cost[1:-1][min_idx] + energy[r]
+
+    c = np.argmin(cost[1:-1])
+    seam = np.empty(h, dtype=np.int32)
+    for r in range(h - 1, -1, -1):
+        seam[r] = c
+        c = parent[r, c]
+
+    return seam
+
+
+def _get_backward_seams(
+    gray: np.ndarray, num_seams: int, aux_energy: Optional[np.ndarray]
+) -> np.ndarray:
+    """Compute the minimum N vertical seams using backward energy"""
+    h, w = gray.shape
+    seams = np.zeros((h, w), dtype=bool)
+    rows = np.arange(h, dtype=np.int32)
+    idx_map = np.broadcast_to(np.arange(w, dtype=np.int32), (h, w))
+    energy = _get_energy(gray)
+    if aux_energy is not None:
+        energy += aux_energy
+    for _ in range(num_seams):
+        seam = _get_backward_seam(energy)
+        seams[rows, idx_map[rows, seam]] = True
+
+        seam_mask = _get_seam_mask(gray, seam)
+        gray = _remove_seam_mask(gray, seam_mask)
+        idx_map = _remove_seam_mask(idx_map, seam_mask)
+        if aux_energy is not None:
+            aux_energy = _remove_seam_mask(aux_energy, seam_mask)
+
+        # Only need to re-compute the energy in the bounding box of the seam
+        _, cur_w = energy.shape
+        lo = max(0, np.min(seam) - 1)
+        hi = min(cur_w, np.max(seam) + 1)
+        pad_lo = 1 if lo > 0 else 0
+        pad_hi = 1 if hi < cur_w - 1 else 0
+        mid_block = gray[:, lo - pad_lo : hi + pad_hi]
+        _, mid_w = mid_block.shape
+        mid_energy = _get_energy(mid_block)[:, pad_lo : mid_w - pad_hi]
+        if aux_energy is not None:
+            mid_energy += aux_energy[:, lo:hi]
+        energy = np.hstack((energy[:, :lo], mid_energy, energy[:, hi + 1 :]))
+
+    return seams
+
+
+@nb.njit(
+    [
+        nb.int32[:](nb.float32[:, :], nb.none),
+        nb.int32[:](nb.float32[:, :], nb.float32[:, :]),
+    ],
+    cache=True,
+)
+def _get_forward_seam(gray: np.ndarray, aux_energy: Optional[np.ndarray]) -> np.ndarray:
+    """Compute the minimum vertical seam using forward energy"""
+    h, w = gray.shape
+
+    gray = np.hstack((gray[:, :1], gray, gray[:, -1:]))
+
+    inf = np.array([np.inf], dtype=np.float32)
+    dp = np.concatenate((inf, np.abs(gray[0, 2:] - gray[0, :-2]), inf))
+
+    parent = np.empty((h, w), dtype=np.int32)
+    base_idx = np.arange(-1, w - 1, dtype=np.int32)
+
+    inf = np.array([np.inf], dtype=np.float32)
+    for r in range(1, h):
+        curr_shl = gray[r, 2:]
+        curr_shr = gray[r, :-2]
+        cost_mid = np.abs(curr_shl - curr_shr)
+        if aux_energy is not None:
+            cost_mid += aux_energy[r]
+
+        prev_mid = gray[r - 1, 1:-1]
+        cost_left = cost_mid + np.abs(prev_mid - curr_shr)
+        cost_right = cost_mid + np.abs(prev_mid - curr_shl)
+
+        dp_mid = dp[1:-1]
+        dp_left = dp[:-2]
+        dp_right = dp[2:]
+
+        choices = np.vstack(
+            (cost_left + dp_left, cost_mid + dp_mid, cost_right + dp_right)
+        )
+        min_idx = np.argmin(choices, axis=0)
+        parent[r] = min_idx + base_idx
+        # numba does not support specifying axis in np.min, below loop is equivalent to:
+        # `dp_mid[:] = np.min(choices, axis=0)` or `dp_mid[:] = choices[min_idx, np.arange(w)]`
+        for j, i in enumerate(min_idx):
+            dp_mid[j] = choices[i, j]
+
+    c = np.argmin(dp[1:-1])
+    seam = np.empty(h, dtype=np.int32)
+    for r in range(h - 1, -1, -1):
+        seam[r] = c
+        c = parent[r, c]
+
+    return seam
+
+
+def _get_forward_seams(
+    gray: np.ndarray, num_seams: int, aux_energy: Optional[np.ndarray]
+) -> np.ndarray:
+    """Compute minimum N vertical seams using forward energy"""
+    h, w = gray.shape
+    seams = np.zeros((h, w), dtype=bool)
+    rows = np.arange(h, dtype=np.int32)
+    idx_map = np.broadcast_to(np.arange(w, dtype=np.int32), (h, w))
+    for _ in range(num_seams):
+        seam = _get_forward_seam(gray, aux_energy)
+        seams[rows, idx_map[rows, seam]] = True
+        seam_mask = _get_seam_mask(gray, seam)
+        gray = _remove_seam_mask(gray, seam_mask)
+        idx_map = _remove_seam_mask(idx_map, seam_mask)
+        if aux_energy is not None:
+            aux_energy = _remove_seam_mask(aux_energy, seam_mask)
+
+    return seams
+
+
+def _get_seams(
+    gray: np.ndarray, num_seams: int, energy_mode: str, aux_energy: Optional[np.ndarray]
+) -> np.ndarray:
+    """Get the minimum N seams from the grayscale image"""
+    gray = np.asarray(gray, dtype=np.float32)
+    if energy_mode == EnergyMode.BACKWARD:
+        return _get_backward_seams(gray, num_seams, aux_energy)
+    elif energy_mode == EnergyMode.FORWARD:
+        return _get_forward_seams(gray, num_seams, aux_energy)
+    else:
+        raise ValueError(
+            f"expect energy_mode to be one of {_list_enum(EnergyMode)}, got {energy_mode}"
+        )
+
+
+def _reduce_width(
+    src: np.ndarray,
+    delta_width: int,
+    energy_mode: str,
+    aux_energy: Optional[np.ndarray],
+) -> Tuple[np.ndarray, Optional[np.ndarray]]:
+    """Reduce the width of image by delta_width pixels"""
+    assert src.ndim in (2, 3) and delta_width >= 0
+    if src.ndim == 2:
+        gray = src
+        src_h, src_w = src.shape
+        dst_shape: Tuple[int, ...] = (src_h, src_w - delta_width)
+    else:
+        gray = _rgb2gray(src)
+        src_h, src_w, src_c = src.shape
+        dst_shape = (src_h, src_w - delta_width, src_c)
+
+    to_keep = ~_get_seams(gray, delta_width, energy_mode, aux_energy)
+    dst = src[to_keep].reshape(dst_shape)
+    if aux_energy is not None:
+        aux_energy = aux_energy[to_keep].reshape(dst_shape[:2])
+    return dst, aux_energy
+
+
+@nb.njit(
+    nb.float32[:, :, :](nb.float32[:, :, :], nb.boolean[:, :], nb.int32), cache=True
+)
+def _insert_seams_kernel(
+    src: np.ndarray, seams: np.ndarray, delta_width: int
+) -> np.ndarray:
+    """The numba kernel for inserting seams"""
+    src_h, src_w, src_c = src.shape
+    dst = np.empty((src_h, src_w + delta_width, src_c), dtype=src.dtype)
+    for row in range(src_h):
+        dst_col = 0
+        for src_col in range(src_w):
+            if seams[row, src_col]:
+                left = src[row, max(src_col - 1, 0)]
+                right = src[row, src_col]
+                dst[row, dst_col] = (left + right) / 2
+                dst_col += 1
+            dst[row, dst_col] = src[row, src_col]
+            dst_col += 1
+    return dst
+
+
+def _insert_seams(src: np.ndarray, seams: np.ndarray, delta_width: int) -> np.ndarray:
+    """Insert multiple seams into the source image"""
+    dst = src.astype(np.float32)
+    if dst.ndim == 2:
+        dst = dst[:, :, None]
+    dst = _insert_seams_kernel(dst, seams, delta_width).astype(src.dtype)
+    if src.ndim == 2:
+        dst = dst.squeeze(-1)
+    return dst
+
+
+def _expand_width(
+    src: np.ndarray,
+    delta_width: int,
+    energy_mode: str,
+    aux_energy: Optional[np.ndarray],
+    step_ratio: float,
+) -> Tuple[np.ndarray, Optional[np.ndarray]]:
+    """Expand the width of image by delta_width pixels"""
+    assert src.ndim in (2, 3) and delta_width >= 0
+    if not 0 < step_ratio <= 1:
+        raise ValueError(f"expect `step_ratio` to be between (0,1], got {step_ratio}")
+
+    dst = src
+    while delta_width > 0:
+        max_step_size = max(1, round(step_ratio * dst.shape[1]))
+        step_size = min(max_step_size, delta_width)
+        gray = dst if dst.ndim == 2 else _rgb2gray(dst)
+        seams = _get_seams(gray, step_size, energy_mode, aux_energy)
+        dst = _insert_seams(dst, seams, step_size)
+        if aux_energy is not None:
+            aux_energy = _insert_seams(aux_energy, seams, step_size)
+        delta_width -= step_size
+
+    return dst, aux_energy
+
+
+def _resize_width(
+    src: np.ndarray,
+    width: int,
+    energy_mode: str,
+    aux_energy: Optional[np.ndarray],
+    step_ratio: float,
+) -> Tuple[np.ndarray, Optional[np.ndarray]]:
+    """Resize the width of image by removing vertical seams"""
+    assert src.size > 0 and src.ndim in (2, 3)
+    assert width > 0
+
+    src_w = src.shape[1]
+    if src_w < width:
+        dst, aux_energy = _expand_width(
+            src, width - src_w, energy_mode, aux_energy, step_ratio
+        )
+    else:
+        dst, aux_energy = _reduce_width(src, src_w - width, energy_mode, aux_energy)
+    return dst, aux_energy
+
+
+def _transpose_image(src: np.ndarray) -> np.ndarray:
+    """Transpose a source image in rgb or grayscale format"""
+    if src.ndim == 3:
+        dst = src.transpose((1, 0, 2))
+    else:
+        dst = src.T
+    return dst
+
+
+def _resize_height(
+    src: np.ndarray,
+    height: int,
+    energy_mode: str,
+    aux_energy: Optional[np.ndarray],
+    step_ratio: float,
+) -> Tuple[np.ndarray, Optional[np.ndarray]]:
+    """Resize the height of image by removing horizontal seams"""
+    assert src.ndim in (2, 3) and height > 0
+    if aux_energy is not None:
+        aux_energy = aux_energy.T
+    src = _transpose_image(src)
+    src, aux_energy = _resize_width(src, height, energy_mode, aux_energy, step_ratio)
+    src = _transpose_image(src)
+    if aux_energy is not None:
+        aux_energy = aux_energy.T
+    return src, aux_energy
+
+
+def _check_mask(mask: np.ndarray, shape: Tuple[int, ...]) -> np.ndarray:
+    """Ensure the mask to be a 2D grayscale map of specific shape"""
+    mask = np.asarray(mask, dtype=bool)
+    if mask.ndim != 2:
+        raise ValueError(f"expect mask to be a 2d binary map, got shape {mask.shape}")
+    if mask.shape != shape:
+        raise ValueError(
+            f"expect the shape of mask to match the image, got {mask.shape} vs {shape}"
+        )
+    return mask
+
+
+def _check_src(src: np.ndarray) -> np.ndarray:
+    """Ensure the source to be RGB or grayscale"""
+    src = np.asarray(src)
+    if src.size == 0 or src.ndim not in (2, 3):
+        raise ValueError(
+            f"expect a 3d rgb image or a 2d grayscale image, got image in shape {src.shape}"
+        )
+    return src
+
+
+def seam_carving(
+    src: np.ndarray,
+    size: Optional[Tuple[int, int]] = None,
+    energy_mode: str = "backward",
+    order: str = "width-first",
+    keep_mask: Optional[np.ndarray] = None,
+    drop_mask: Optional[np.ndarray] = None,
+    step_ratio: float = 0.5,
+) -> np.ndarray:
+    """Resize the image using the content-aware seam-carving algorithm.
+
+    :param src: A source image in RGB or grayscale format.
+    :param size: The target size in pixels, as a 2-tuple (width, height).
+    :param energy_mode: Policy to compute energy for the source image. Could be
+        one of ``backward`` or ``forward``. If ``backward``, compute the energy
+        as the gradient at each pixel. If ``forward``, compute the energy as the
+        distances between adjacent pixels after each pixel is removed.
+    :param order: The order to remove horizontal and vertical seams. Could be
+        one of ``width-first`` or ``height-first``. In ``width-first`` mode, we
+        remove or insert all vertical seams first, then the horizontal ones,
+        while ``height-first`` is the opposite.
+    :param keep_mask: An optional mask where the foreground is protected from
+        seam removal. If not specified, no area will be protected.
+    :param drop_mask: An optional binary object mask to remove. If given, the
+        object will be removed before resizing the image to the target size.
+    :param step_ratio: The maximum size expansion ratio in one seam carving step.
+        The image will be expanded in multiple steps if target size is too large.
+    :return: A resized copy of the source image.
+    """
+    src = _check_src(src)
+
+    if order not in _list_enum(OrderMode):
+        raise ValueError(
+            f"expect order to be one of {_list_enum(OrderMode)}, got {order}"
+        )
+
+    aux_energy = None
+
+    if keep_mask is not None:
+        keep_mask = _check_mask(keep_mask, src.shape[:2])
+
+        aux_energy = np.zeros(src.shape[:2], dtype=np.float32)
+        aux_energy[keep_mask] += KEEP_MASK_ENERGY
+
+    # remove object if `drop_mask` is given
+    if drop_mask is not None:
+        drop_mask = _check_mask(drop_mask, src.shape[:2])
+
+        if aux_energy is None:
+            aux_energy = np.zeros(src.shape[:2], dtype=np.float32)
+        aux_energy[drop_mask] -= DROP_MASK_ENERGY
+
+        if order == OrderMode.HEIGHT_FIRST:
+            src = _transpose_image(src)
+            aux_energy = aux_energy.T
+
+        num_seams = (aux_energy < 0).sum(1).max()
+        while num_seams > 0:
+            src, aux_energy = _reduce_width(src, num_seams, energy_mode, aux_energy)
+            num_seams = (aux_energy < 0).sum(1).max()
+
+        if order == OrderMode.HEIGHT_FIRST:
+            src = _transpose_image(src)
+            aux_energy = aux_energy.T
+
+    # resize image if `size` is given
+    if size is not None:
+        width, height = size
+        width = round(width)
+        height = round(height)
+        if width <= 0 or height <= 0:
+            raise ValueError(f"expect target size to be positive, got {size}")
+
+        if order == OrderMode.WIDTH_FIRST:
+            src, aux_energy = _resize_width(
+                src, width, energy_mode, aux_energy, step_ratio
+            )
+            src, aux_energy = _resize_height(
+                src, height, energy_mode, aux_energy, step_ratio
+            )
+        else:
+            src, aux_energy = _resize_height(
+                src, height, energy_mode, aux_energy, step_ratio
+            )
+            src, aux_energy = _resize_width(
+                src, width, energy_mode, aux_energy, step_ratio
+            )
+
+    return src

ComfyUI_essentials/conditioning.py

@@ -0,0 +1,280 @@
+from nodes import MAX_RESOLUTION, ConditioningZeroOut, ConditioningSetTimestepRange, ConditioningCombine
+import re
+
+class CLIPTextEncodeSDXLSimplified:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+            "width": ("INT", {"default": 1024.0, "min": 0, "max": MAX_RESOLUTION}),
+            "height": ("INT", {"default": 1024.0, "min": 0, "max": MAX_RESOLUTION}),
+            "size_cond_factor": ("INT", {"default": 4, "min": 1, "max": 16 }),
+            "text": ("STRING", {"multiline": True, "dynamicPrompts": True, "default": ""}),
+            "clip": ("CLIP", ),
+            }}
+    RETURN_TYPES = ("CONDITIONING",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/conditioning"
+
+    def execute(self, clip, width, height, size_cond_factor, text):
+        crop_w = 0
+        crop_h = 0
+        width = width*size_cond_factor
+        height = height*size_cond_factor
+        target_width = width
+        target_height = height
+        text_g = text_l = text
+
+        tokens = clip.tokenize(text_g)
+        tokens["l"] = clip.tokenize(text_l)["l"]
+        if len(tokens["l"]) != len(tokens["g"]):
+            empty = clip.tokenize("")
+            while len(tokens["l"]) < len(tokens["g"]):
+                tokens["l"] += empty["l"]
+            while len(tokens["l"]) > len(tokens["g"]):
+                tokens["g"] += empty["g"]
+        cond, pooled = clip.encode_from_tokens(tokens, return_pooled=True)
+        return ([[cond, {"pooled_output": pooled, "width": width, "height": height, "crop_w": crop_w, "crop_h": crop_h, "target_width": target_width, "target_height": target_height}]], )
+
+class ConditioningCombineMultiple:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "conditioning_1": ("CONDITIONING",),
+                "conditioning_2": ("CONDITIONING",),
+            }, "optional": {
+                "conditioning_3": ("CONDITIONING",),
+                "conditioning_4": ("CONDITIONING",),
+                "conditioning_5": ("CONDITIONING",),
+            },
+        }
+    RETURN_TYPES = ("CONDITIONING",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/conditioning"
+
+    def execute(self, conditioning_1, conditioning_2, conditioning_3=None, conditioning_4=None, conditioning_5=None):
+        c = conditioning_1 + conditioning_2
+
+        if conditioning_3 is not None:
+            c += conditioning_3
+        if conditioning_4 is not None:
+            c += conditioning_4
+        if conditioning_5 is not None:
+            c += conditioning_5
+
+        return (c,)
+
+class SD3NegativeConditioning:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+            "conditioning": ("CONDITIONING",),
+            "end": ("FLOAT", {"default": 0.1, "min": 0.0, "max": 1.0, "step": 0.001 }),
+        }}
+    RETURN_TYPES = ("CONDITIONING",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/conditioning"
+
+    def execute(self, conditioning, end):
+        zero_c = ConditioningZeroOut().zero_out(conditioning)[0]
+
+        if end == 0:
+            return (zero_c, )
+
+        c = ConditioningSetTimestepRange().set_range(conditioning, 0, end)[0]
+        zero_c = ConditioningSetTimestepRange().set_range(zero_c, end, 1.0)[0]
+        c = ConditioningCombine().combine(zero_c, c)[0]
+
+        return (c, )
+
+class FluxAttentionSeeker:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+            "clip": ("CLIP",),
+            "apply_to_query": ("BOOLEAN", { "default": True }),
+            "apply_to_key": ("BOOLEAN", { "default": True }),
+            "apply_to_value": ("BOOLEAN", { "default": True }),
+            "apply_to_out": ("BOOLEAN", { "default": True }),
+            **{f"clip_l_{s}": ("FLOAT", { "display": "slider", "default": 1.0, "min": 0, "max": 5, "step": 0.05 }) for s in range(12)},
+            **{f"t5xxl_{s}": ("FLOAT", { "display": "slider", "default": 1.0, "min": 0, "max": 5, "step": 0.05 }) for s in range(24)},
+        }}
+
+    RETURN_TYPES = ("CLIP",)
+    FUNCTION = "execute"
+
+    CATEGORY = "essentials/conditioning"
+
+    def execute(self, clip, apply_to_query, apply_to_key, apply_to_value, apply_to_out, **values):
+        if not apply_to_key and not apply_to_query and not apply_to_value and not apply_to_out:
+            return (clip, )
+
+        m = clip.clone()
+        sd = m.patcher.model_state_dict()
+        
+        for k in sd:
+            if "self_attn" in k:
+                layer = re.search(r"\.layers\.(\d+)\.", k)
+                layer = int(layer.group(1)) if layer else None
+
+                if layer is not None and values[f"clip_l_{layer}"] != 1.0:
+                    if (apply_to_query and "q_proj" in k) or (apply_to_key and "k_proj" in k) or (apply_to_value and "v_proj" in k) or (apply_to_out and "out_proj" in k):
+                        m.add_patches({k: (None,)}, 0.0, values[f"clip_l_{layer}"])
+            elif "SelfAttention" in k:
+                block = re.search(r"\.block\.(\d+)\.", k)
+                block = int(block.group(1)) if block else None
+
+                if block is not None and values[f"t5xxl_{block}"] != 1.0:
+                    if (apply_to_query and ".q." in k) or (apply_to_key and ".k." in k) or (apply_to_value and ".v." in k) or (apply_to_out and ".o." in k):
+                        m.add_patches({k: (None,)}, 0.0, values[f"t5xxl_{block}"])
+
+        return (m, )
+
+class SD3AttentionSeekerLG:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+            "clip": ("CLIP",),
+            "apply_to_query": ("BOOLEAN", { "default": True }),
+            "apply_to_key": ("BOOLEAN", { "default": True }),
+            "apply_to_value": ("BOOLEAN", { "default": True }),
+            "apply_to_out": ("BOOLEAN", { "default": True }),
+            **{f"clip_l_{s}": ("FLOAT", { "display": "slider", "default": 1.0, "min": 0, "max": 5, "step": 0.05 }) for s in range(12)},
+            **{f"clip_g_{s}": ("FLOAT", { "display": "slider", "default": 1.0, "min": 0, "max": 5, "step": 0.05 }) for s in range(32)},
+        }}
+
+    RETURN_TYPES = ("CLIP",)
+    FUNCTION = "execute"
+
+    CATEGORY = "essentials/conditioning"
+
+    def execute(self, clip, apply_to_query, apply_to_key, apply_to_value, apply_to_out, **values):
+        if not apply_to_key and not apply_to_query and not apply_to_value and not apply_to_out:
+            return (clip, )
+
+        m = clip.clone()
+        sd = m.patcher.model_state_dict()
+        
+        for k in sd:
+            if "self_attn" in k:
+                layer = re.search(r"\.layers\.(\d+)\.", k)
+                layer = int(layer.group(1)) if layer else None
+
+                if layer is not None:
+                    if "clip_l" in k and values[f"clip_l_{layer}"] != 1.0:
+                        if (apply_to_query and "q_proj" in k) or (apply_to_key and "k_proj" in k) or (apply_to_value and "v_proj" in k) or (apply_to_out and "out_proj" in k):
+                            m.add_patches({k: (None,)}, 0.0, values[f"clip_l_{layer}"])
+                    elif "clip_g" in k and values[f"clip_g_{layer}"] != 1.0:
+                        if (apply_to_query and "q_proj" in k) or (apply_to_key and "k_proj" in k) or (apply_to_value and "v_proj" in k) or (apply_to_out and "out_proj" in k):
+                            m.add_patches({k: (None,)}, 0.0, values[f"clip_g_{layer}"])
+
+        return (m, )
+
+class SD3AttentionSeekerT5:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+            "clip": ("CLIP",),
+            "apply_to_query": ("BOOLEAN", { "default": True }),
+            "apply_to_key": ("BOOLEAN", { "default": True }),
+            "apply_to_value": ("BOOLEAN", { "default": True }),
+            "apply_to_out": ("BOOLEAN", { "default": True }),
+            **{f"t5xxl_{s}": ("FLOAT", { "display": "slider", "default": 1.0, "min": 0, "max": 5, "step": 0.05 }) for s in range(24)},
+        }}
+
+    RETURN_TYPES = ("CLIP",)
+    FUNCTION = "execute"
+
+    CATEGORY = "essentials/conditioning"
+
+    def execute(self, clip, apply_to_query, apply_to_key, apply_to_value, apply_to_out, **values):
+        if not apply_to_key and not apply_to_query and not apply_to_value and not apply_to_out:
+            return (clip, )
+
+        m = clip.clone()
+        sd = m.patcher.model_state_dict()
+        
+        for k in sd:
+            if "SelfAttention" in k:
+                block = re.search(r"\.block\.(\d+)\.", k)
+                block = int(block.group(1)) if block else None
+
+                if block is not None and values[f"t5xxl_{block}"] != 1.0:
+                    if (apply_to_query and ".q." in k) or (apply_to_key and ".k." in k) or (apply_to_value and ".v." in k) or (apply_to_out and ".o." in k):
+                        m.add_patches({k: (None,)}, 0.0, values[f"t5xxl_{block}"])
+
+        return (m, )
+
+class FluxBlocksBuster:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+            "model": ("MODEL",),
+            "blocks": ("STRING", {"default": "## 0 = 1.0\n## 1 = 1.0\n## 2 = 1.0\n## 3 = 1.0\n## 4 = 1.0\n## 5 = 1.0\n## 6 = 1.0\n## 7 = 1.0\n## 8 = 1.0\n## 9 = 1.0\n## 10 = 1.0\n## 11 = 1.0\n## 12 = 1.0\n## 13 = 1.0\n## 14 = 1.0\n## 15 = 1.0\n## 16 = 1.0\n## 17 = 1.0\n## 18 = 1.0\n# 0 = 1.0\n# 1 = 1.0\n# 2 = 1.0\n# 3 = 1.0\n# 4 = 1.0\n# 5 = 1.0\n# 6 = 1.0\n# 7 = 1.0\n# 8 = 1.0\n# 9 = 1.0\n# 10 = 1.0\n# 11 = 1.0\n# 12 = 1.0\n# 13 = 1.0\n# 14 = 1.0\n# 15 = 1.0\n# 16 = 1.0\n# 17 = 1.0\n# 18 = 1.0\n# 19 = 1.0\n# 20 = 1.0\n# 21 = 1.0\n# 22 = 1.0\n# 23 = 1.0\n# 24 = 1.0\n# 25 = 1.0\n# 26 = 1.0\n# 27 = 1.0\n# 28 = 1.0\n# 29 = 1.0\n# 30 = 1.0\n# 31 = 1.0\n# 32 = 1.0\n# 33 = 1.0\n# 34 = 1.0\n# 35 = 1.0\n# 36 = 1.0\n# 37 = 1.0", "multiline": True, "dynamicPrompts": True}),
+            #**{f"double_block_{s}": ("FLOAT", { "display": "slider", "default": 1.0, "min": 0, "max": 5, "step": 0.05 }) for s in range(19)},
+            #**{f"single_block_{s}": ("FLOAT", { "display": "slider", "default": 1.0, "min": 0, "max": 5, "step": 0.05 }) for s in range(38)},
+        }}
+    RETURN_TYPES = ("MODEL", "STRING")
+    RETURN_NAMES = ("MODEL", "patched_blocks")
+    FUNCTION = "patch"
+
+    CATEGORY = "essentials/conditioning"
+
+    def patch(self, model, blocks):
+        if blocks == "":
+            return (model, )
+
+        m = model.clone()
+        sd = model.model_state_dict()
+        patched_blocks = []
+
+        """
+        Also compatible with the following format:
+
+        double_blocks\.0\.(img|txt)_(mod|attn|mlp)\.(lin|qkv|proj|0|2)\.(weight|bias)=1.1
+        single_blocks\.0\.(linear[12]|modulation\.lin)\.(weight|bias)=1.1
+
+        The regex is used to match the block names
+        """
+
+        blocks = blocks.split("\n")
+        blocks = [b.strip() for b in blocks if b.strip()]
+
+        for k in sd:
+            for block in blocks:
+                block = block.split("=")
+                value = float(block[1].strip()) if len(block) > 1 else 1.0
+                block = block[0].strip()
+                if block.startswith("##"):
+                    block = r"double_blocks\." + block[2:].strip() + r"\.(img|txt)_(mod|attn|mlp)\.(lin|qkv|proj|0|2)\.(weight|bias)"
+                elif block.startswith("#"):
+                    block = r"single_blocks\." + block[1:].strip() + r"\.(linear[12]|modulation\.lin)\.(weight|bias)"
+
+                if value != 1.0 and re.search(block, k):
+                    m.add_patches({k: (None,)}, 0.0, value)
+                    patched_blocks.append(f"{k}: {value}")
+
+        patched_blocks = "\n".join(patched_blocks)
+
+        return (m, patched_blocks,)
+
+
+COND_CLASS_MAPPINGS = {
+    "CLIPTextEncodeSDXL+": CLIPTextEncodeSDXLSimplified,
+    "ConditioningCombineMultiple+": ConditioningCombineMultiple,
+    "SD3NegativeConditioning+": SD3NegativeConditioning,
+    "FluxAttentionSeeker+": FluxAttentionSeeker,
+    "SD3AttentionSeekerLG+": SD3AttentionSeekerLG,
+    "SD3AttentionSeekerT5+": SD3AttentionSeekerT5,
+    "FluxBlocksBuster+": FluxBlocksBuster,
+}
+
+COND_NAME_MAPPINGS = {
+    "CLIPTextEncodeSDXL+": "🔧 SDXL CLIPTextEncode",
+    "ConditioningCombineMultiple+": "🔧 Cond Combine Multiple",
+    "SD3NegativeConditioning+": "🔧 SD3 Negative Conditioning",
+    "FluxAttentionSeeker+": "🔧 Flux Attention Seeker",
+    "SD3AttentionSeekerLG+": "🔧 SD3 Attention Seeker L/G",
+    "SD3AttentionSeekerT5+": "🔧 SD3 Attention Seeker T5",
+    "FluxBlocksBuster+": "🔧 Flux Model Blocks Buster",
+}

ComfyUI_essentials/histogram_matching.py

@@ -0,0 +1,87 @@
+# from MIT licensed https://github.com/nemodleo/pytorch-histogram-matching
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class Histogram_Matching(nn.Module):
+    def __init__(self, differentiable=False):
+        super(Histogram_Matching, self).__init__()
+        self.differentiable = differentiable
+
+    def forward(self, dst, ref):
+        # B C
+        B, C, H, W = dst.size()
+        # assertion
+        assert dst.device == ref.device
+        # [B*C 256]
+        hist_dst = self.cal_hist(dst)
+        hist_ref = self.cal_hist(ref)
+        # [B*C 256]
+        tables = self.cal_trans_batch(hist_dst, hist_ref)
+        # [B C H W]
+        rst = dst.clone()
+        for b in range(B):
+            for c in range(C):
+                rst[b,c] = tables[b*c, (dst[b,c] * 255).long()]
+        # [B C H W]
+        rst /= 255.
+        return rst
+
+    def cal_hist(self, img):
+        B, C, H, W = img.size()
+        # [B*C 256]
+        if self.differentiable: 
+            hists = self.soft_histc_batch(img * 255, bins=256, min=0, max=256, sigma=3*25)
+        else:
+            hists = torch.stack([torch.histc(img[b,c] * 255, bins=256, min=0, max=255) for b in range(B) for c in range(C)])
+        hists = hists.float()
+        hists = F.normalize(hists, p=1)
+        # BC 256
+        bc, n = hists.size()
+        # [B*C 256 256]
+        triu = torch.ones(bc, n, n, device=hists.device).triu()
+        # [B*C 256]
+        hists = torch.bmm(hists[:,None,:], triu)[:,0,:]
+        return hists
+
+    def soft_histc_batch(self, x, bins=256, min=0, max=256, sigma=3*25):
+        # B C H W
+        B, C, H, W = x.size()
+        # [B*C H*W]
+        x = x.view(B*C, -1)
+        # 1
+        delta = float(max - min) / float(bins)
+        # [256]
+        centers = float(min) + delta * (torch.arange(bins, device=x.device, dtype=torch.bfloat16) + 0.5)
+        # [B*C 1 H*W]
+        x = torch.unsqueeze(x, 1)
+        # [1 256 1]
+        centers = centers[None,:,None]
+        # [B*C 256 H*W]
+        x = x - centers
+        # [B*C 256 H*W]
+        x = x.type(torch.bfloat16)
+        # [B*C 256 H*W]
+        x = torch.sigmoid(sigma * (x + delta/2)) - torch.sigmoid(sigma * (x - delta/2))
+        # [B*C 256]
+        x = x.sum(dim=2)
+        # [B*C 256]
+        x = x.type(torch.float32)
+        # prevent oom
+        # torch.cuda.empty_cache()
+        return x
+
+    def cal_trans_batch(self, hist_dst, hist_ref):
+        # [B*C 256 256]
+        hist_dst = hist_dst[:,None,:].repeat(1,256,1)
+        # [B*C 256 256]
+        hist_ref = hist_ref[:,:,None].repeat(1,1,256)
+        # [B*C 256 256]
+        table = hist_dst - hist_ref
+        # [B*C 256 256]
+        table = torch.where(table>=0, 1., 0.)
+        # [B*C 256]
+        table = torch.sum(table, dim=1) - 1
+        # [B*C 256]
+        table = torch.clamp(table, min=0, max=255)
+        return table

ComfyUI_essentials/image.py

@@ -0,0 +1,1770 @@
+from .utils import max_, min_
+from nodes import MAX_RESOLUTION
+import comfy.utils
+from nodes import SaveImage
+from node_helpers import pillow
+from PIL import Image, ImageOps
+
+import kornia
+import torch
+import torch.nn.functional as F
+import torchvision.transforms.v2 as T
+
+#import warnings
+#warnings.filterwarnings('ignore', module="torchvision")
+import math
+import os
+import numpy as np
+import folder_paths
+from pathlib import Path
+import random
+
+"""
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    Image analysis
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+class ImageEnhanceDifference:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image1": ("IMAGE",),
+                "image2": ("IMAGE",),
+                "exponent": ("FLOAT", { "default": 0.75, "min": 0.00, "max": 1.00, "step": 0.05, }),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image analysis"
+
+    def execute(self, image1, image2, exponent):
+        if image1.shape[1:] != image2.shape[1:]:
+            image2 = comfy.utils.common_upscale(image2.permute([0,3,1,2]), image1.shape[2], image1.shape[1], upscale_method='bicubic', crop='center').permute([0,2,3,1])
+
+        diff_image = image1 - image2
+        diff_image = torch.pow(diff_image, exponent)
+        diff_image = torch.clamp(diff_image, 0, 1)
+
+        return(diff_image,)
+
+"""
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    Batch tools
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+class ImageBatchMultiple:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image_1": ("IMAGE",),
+                "method": (["nearest-exact", "bilinear", "area", "bicubic", "lanczos"], { "default": "lanczos" }),
+            }, "optional": {
+                "image_2": ("IMAGE",),
+                "image_3": ("IMAGE",),
+                "image_4": ("IMAGE",),
+                "image_5": ("IMAGE",),
+            },
+        }
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image batch"
+
+    def execute(self, image_1, method, image_2=None, image_3=None, image_4=None, image_5=None):
+        out = image_1
+
+        if image_2 is not None:
+            if image_1.shape[1:] != image_2.shape[1:]:
+                image_2 = comfy.utils.common_upscale(image_2.movedim(-1,1), image_1.shape[2], image_1.shape[1], method, "center").movedim(1,-1)
+            out = torch.cat((image_1, image_2), dim=0)
+        if image_3 is not None:
+            if image_1.shape[1:] != image_3.shape[1:]:
+                image_3 = comfy.utils.common_upscale(image_3.movedim(-1,1), image_1.shape[2], image_1.shape[1], method, "center").movedim(1,-1)
+            out = torch.cat((out, image_3), dim=0)
+        if image_4 is not None:
+            if image_1.shape[1:] != image_4.shape[1:]:
+                image_4 = comfy.utils.common_upscale(image_4.movedim(-1,1), image_1.shape[2], image_1.shape[1], method, "center").movedim(1,-1)
+            out = torch.cat((out, image_4), dim=0)
+        if image_5 is not None:
+            if image_1.shape[1:] != image_5.shape[1:]:
+                image_5 = comfy.utils.common_upscale(image_5.movedim(-1,1), image_1.shape[2], image_1.shape[1], method, "center").movedim(1,-1)
+            out = torch.cat((out, image_5), dim=0)
+
+        return (out,)
+
+
+class ImageExpandBatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "size": ("INT", { "default": 16, "min": 1, "step": 1, }),
+                "method": (["expand", "repeat all", "repeat first", "repeat last"],)
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image batch"
+
+    def execute(self, image, size, method):
+        orig_size = image.shape[0]
+
+        if orig_size == size:
+            return (image,)
+
+        if size <= 1:
+            return (image[:size],)
+
+        if 'expand' in method:
+            out = torch.empty([size] + list(image.shape)[1:], dtype=image.dtype, device=image.device)
+            if size < orig_size:
+                scale = (orig_size - 1) / (size - 1)
+                for i in range(size):
+                    out[i] = image[min(round(i * scale), orig_size - 1)]
+            else:
+                scale = orig_size / size
+                for i in range(size):
+                    out[i] = image[min(math.floor((i + 0.5) * scale), orig_size - 1)]
+        elif 'all' in method:
+            out = image.repeat([math.ceil(size / image.shape[0])] + [1] * (len(image.shape) - 1))[:size]
+        elif 'first' in method:
+            if size < image.shape[0]:
+                out = image[:size]
+            else:
+                out = torch.cat([image[:1].repeat(size-image.shape[0], 1, 1, 1), image], dim=0)
+        elif 'last' in method:
+            if size < image.shape[0]:
+                out = image[:size]
+            else:
+                out = torch.cat((image, image[-1:].repeat((size-image.shape[0], 1, 1, 1))), dim=0)
+
+        return (out,)
+
+class ImageFromBatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE", ),
+                "start": ("INT", { "default": 0, "min": 0, "step": 1, }),
+                "length": ("INT", { "default": -1, "min": -1, "step": 1, }),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image batch"
+
+    def execute(self, image, start, length):
+        if length<0:
+            length = image.shape[0]
+        start = min(start, image.shape[0]-1)
+        length = min(image.shape[0]-start, length)
+        return (image[start:start + length], )
+
+
+class ImageListToBatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    INPUT_IS_LIST = True
+    CATEGORY = "essentials/image batch"
+
+    def execute(self, image):
+        shape = image[0].shape[1:3]
+        out = []
+
+        for i in range(len(image)):
+            img = image[i]
+            if image[i].shape[1:3] != shape:
+                img = comfy.utils.common_upscale(img.permute([0,3,1,2]), shape[1], shape[0], upscale_method='bicubic', crop='center').permute([0,2,3,1])
+            out.append(img)
+
+        out = torch.cat(out, dim=0)
+
+        return (out,)
+
+class ImageBatchToList:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    OUTPUT_IS_LIST = (True,)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image batch"
+
+    def execute(self, image):
+        return ([image[i].unsqueeze(0) for i in range(image.shape[0])], )
+
+
+"""
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    Image manipulation
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+class ImageCompositeFromMaskBatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image_from": ("IMAGE", ),
+                "image_to": ("IMAGE", ),
+                "mask": ("MASK", )
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image manipulation"
+
+    def execute(self, image_from, image_to, mask):
+        frames = mask.shape[0]
+
+        if image_from.shape[1] != image_to.shape[1] or image_from.shape[2] != image_to.shape[2]:
+            image_to = comfy.utils.common_upscale(image_to.permute([0,3,1,2]), image_from.shape[2], image_from.shape[1], upscale_method='bicubic', crop='center').permute([0,2,3,1])
+
+        if frames < image_from.shape[0]:
+            image_from = image_from[:frames]
+        elif frames > image_from.shape[0]:
+            image_from = torch.cat((image_from, image_from[-1].unsqueeze(0).repeat(frames-image_from.shape[0], 1, 1, 1)), dim=0)
+
+        mask = mask.unsqueeze(3).repeat(1, 1, 1, 3)
+
+        if image_from.shape[1] != mask.shape[1] or image_from.shape[2] != mask.shape[2]:
+            mask = comfy.utils.common_upscale(mask.permute([0,3,1,2]), image_from.shape[2], image_from.shape[1], upscale_method='bicubic', crop='center').permute([0,2,3,1])
+
+        out = mask * image_to + (1 - mask) * image_from
+
+        return (out, )
+
+class ImageComposite:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "destination": ("IMAGE",),
+                "source": ("IMAGE",),
+                "x": ("INT", { "default": 0, "min": -MAX_RESOLUTION, "max": MAX_RESOLUTION, "step": 1 }),
+                "y": ("INT", { "default": 0, "min": -MAX_RESOLUTION, "max": MAX_RESOLUTION, "step": 1 }),
+                "offset_x": ("INT", { "default": 0, "min": -MAX_RESOLUTION, "max": MAX_RESOLUTION, "step": 1 }),
+                "offset_y": ("INT", { "default": 0, "min": -MAX_RESOLUTION, "max": MAX_RESOLUTION, "step": 1 }),
+            },
+            "optional": {
+                "mask": ("MASK",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image manipulation"
+
+    def execute(self, destination, source, x, y, offset_x, offset_y, mask=None):
+        if mask is None:
+            mask = torch.ones_like(source)[:,:,:,0]
+        
+        mask = mask.unsqueeze(-1).repeat(1, 1, 1, 3)
+
+        if mask.shape[1:3] != source.shape[1:3]:
+            mask = F.interpolate(mask.permute([0, 3, 1, 2]), size=(source.shape[1], source.shape[2]), mode='bicubic')
+            mask = mask.permute([0, 2, 3, 1])
+        
+        if mask.shape[0] > source.shape[0]:
+            mask = mask[:source.shape[0]]
+        elif mask.shape[0] < source.shape[0]:
+            mask = torch.cat((mask, mask[-1:].repeat((source.shape[0]-mask.shape[0], 1, 1, 1))), dim=0)
+        
+        if destination.shape[0] > source.shape[0]:
+            destination = destination[:source.shape[0]]
+        elif destination.shape[0] < source.shape[0]:
+            destination = torch.cat((destination, destination[-1:].repeat((source.shape[0]-destination.shape[0], 1, 1, 1))), dim=0)
+        
+        if not isinstance(x, list):
+            x = [x]
+        if not isinstance(y, list):
+            y = [y]
+        
+        if len(x) < destination.shape[0]:
+            x = x + [x[-1]] * (destination.shape[0] - len(x))
+        if len(y) < destination.shape[0]:
+            y = y + [y[-1]] * (destination.shape[0] - len(y))
+        
+        x = [i + offset_x for i in x]
+        y = [i + offset_y for i in y]
+
+        output = []
+        for i in range(destination.shape[0]):
+            d = destination[i].clone()
+            s = source[i]
+            m = mask[i]
+
+            if x[i]+source.shape[2] > destination.shape[2]:
+                s = s[:, :, :destination.shape[2]-x[i], :]
+                m = m[:, :, :destination.shape[2]-x[i], :]
+            if y[i]+source.shape[1] > destination.shape[1]:
+                s = s[:, :destination.shape[1]-y[i], :, :]
+                m = m[:destination.shape[1]-y[i], :, :]
+            
+            #output.append(s * m + d[y[i]:y[i]+s.shape[0], x[i]:x[i]+s.shape[1], :] * (1 - m))
+            d[y[i]:y[i]+s.shape[0], x[i]:x[i]+s.shape[1], :] = s * m + d[y[i]:y[i]+s.shape[0], x[i]:x[i]+s.shape[1], :] * (1 - m)
+            output.append(d)
+        
+        output = torch.stack(output)
+
+        # apply the source to the destination at XY position using the mask
+        #for i in range(destination.shape[0]):
+        #    output[i, y[i]:y[i]+source.shape[1], x[i]:x[i]+source.shape[2], :] = source * mask + destination[i, y[i]:y[i]+source.shape[1], x[i]:x[i]+source.shape[2], :] * (1 - mask)
+
+        #for x_, y_ in zip(x, y):
+        #    output[:, y_:y_+source.shape[1], x_:x_+source.shape[2], :] = source * mask + destination[:, y_:y_+source.shape[1], x_:x_+source.shape[2], :] * (1 - mask)
+
+        #output[:, y:y+source.shape[1], x:x+source.shape[2], :] = source * mask + destination[:, y:y+source.shape[1], x:x+source.shape[2], :] * (1 - mask)
+        #output = destination * (1 - mask) + source * mask
+
+        return (output,)
+
+class ImageResize:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "width": ("INT", { "default": 512, "min": 0, "max": MAX_RESOLUTION, "step": 1, }),
+                "height": ("INT", { "default": 512, "min": 0, "max": MAX_RESOLUTION, "step": 1, }),
+                "interpolation": (["nearest", "bilinear", "bicubic", "area", "nearest-exact", "lanczos"],),
+                "method": (["stretch", "keep proportion", "fill / crop", "pad"],),
+                "condition": (["always", "downscale if bigger", "upscale if smaller", "if bigger area", "if smaller area"],),
+                "multiple_of": ("INT", { "default": 0, "min": 0, "max": 512, "step": 1, }),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "INT", "INT",)
+    RETURN_NAMES = ("IMAGE", "width", "height",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image manipulation"
+
+    def execute(self, image, width, height, method="stretch", interpolation="nearest", condition="always", multiple_of=0, keep_proportion=False):
+        _, oh, ow, _ = image.shape
+        x = y = x2 = y2 = 0
+        pad_left = pad_right = pad_top = pad_bottom = 0
+
+        if keep_proportion:
+            method = "keep proportion"
+
+        if multiple_of > 1:
+            width = width - (width % multiple_of)
+            height = height - (height % multiple_of)
+
+        if method == 'keep proportion' or method == 'pad':
+            if width == 0 and oh < height:
+                width = MAX_RESOLUTION
+            elif width == 0 and oh >= height:
+                width = ow
+
+            if height == 0 and ow < width:
+                height = MAX_RESOLUTION
+            elif height == 0 and ow >= width:
+                height = oh
+
+            ratio = min(width / ow, height / oh)
+            new_width = round(ow*ratio)
+            new_height = round(oh*ratio)
+
+            if method == 'pad':
+                pad_left = (width - new_width) // 2
+                pad_right = width - new_width - pad_left
+                pad_top = (height - new_height) // 2
+                pad_bottom = height - new_height - pad_top
+
+            width = new_width
+            height = new_height
+        elif method.startswith('fill'):
+            width = width if width > 0 else ow
+            height = height if height > 0 else oh
+
+            ratio = max(width / ow, height / oh)
+            new_width = round(ow*ratio)
+            new_height = round(oh*ratio)
+            x = (new_width - width) // 2
+            y = (new_height - height) // 2
+            x2 = x + width
+            y2 = y + height
+            if x2 > new_width:
+                x -= (x2 - new_width)
+            if x < 0:
+                x = 0
+            if y2 > new_height:
+                y -= (y2 - new_height)
+            if y < 0:
+                y = 0
+            width = new_width
+            height = new_height
+        else:
+            width = width if width > 0 else ow
+            height = height if height > 0 else oh
+
+        if "always" in condition \
+            or ("downscale if bigger" == condition and (oh > height or ow > width)) or ("upscale if smaller" == condition and (oh < height or ow < width)) \
+            or ("bigger area" in condition and (oh * ow > height * width)) or ("smaller area" in condition and (oh * ow < height * width)):
+
+            outputs = image.permute(0,3,1,2)
+
+            if interpolation == "lanczos":
+                outputs = comfy.utils.lanczos(outputs, width, height)
+            else:
+                outputs = F.interpolate(outputs, size=(height, width), mode=interpolation)
+
+            if method == 'pad':
+                if pad_left > 0 or pad_right > 0 or pad_top > 0 or pad_bottom > 0:
+                    outputs = F.pad(outputs, (pad_left, pad_right, pad_top, pad_bottom), value=0)
+
+            outputs = outputs.permute(0,2,3,1)
+
+            if method.startswith('fill'):
+                if x > 0 or y > 0 or x2 > 0 or y2 > 0:
+                    outputs = outputs[:, y:y2, x:x2, :]
+        else:
+            outputs = image
+
+        if multiple_of > 1 and (outputs.shape[2] % multiple_of != 0 or outputs.shape[1] % multiple_of != 0):
+            width = outputs.shape[2]
+            height = outputs.shape[1]
+            x = (width % multiple_of) // 2
+            y = (height % multiple_of) // 2
+            x2 = width - ((width % multiple_of) - x)
+            y2 = height - ((height % multiple_of) - y)
+            outputs = outputs[:, y:y2, x:x2, :]
+        
+        outputs = torch.clamp(outputs, 0, 1)
+
+        return(outputs, outputs.shape[2], outputs.shape[1],)
+
+class ImageFlip:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "axis": (["x", "y", "xy"],),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image manipulation"
+
+    def execute(self, image, axis):
+        dim = ()
+        if "y" in axis:
+            dim += (1,)
+        if "x" in axis:
+            dim += (2,)
+        image = torch.flip(image, dim)
+
+        return(image,)
+
+class ImageCrop:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "width": ("INT", { "default": 256, "min": 0, "max": MAX_RESOLUTION, "step": 8, }),
+                "height": ("INT", { "default": 256, "min": 0, "max": MAX_RESOLUTION, "step": 8, }),
+                "position": (["top-left", "top-center", "top-right", "right-center", "bottom-right", "bottom-center", "bottom-left", "left-center", "center"],),
+                "x_offset": ("INT", { "default": 0, "min": -99999, "step": 1, }),
+                "y_offset": ("INT", { "default": 0, "min": -99999, "step": 1, }),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE","INT","INT",)
+    RETURN_NAMES = ("IMAGE","x","y",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image manipulation"
+
+    def execute(self, image, width, height, position, x_offset, y_offset):
+        _, oh, ow, _ = image.shape
+
+        width = min(ow, width)
+        height = min(oh, height)
+
+        if "center" in position:
+            x = round((ow-width) / 2)
+            y = round((oh-height) / 2)
+        if "top" in position:
+            y = 0
+        if "bottom" in position:
+            y = oh-height
+        if "left" in position:
+            x = 0
+        if "right" in position:
+            x = ow-width
+
+        x += x_offset
+        y += y_offset
+
+        x2 = x+width
+        y2 = y+height
+
+        if x2 > ow:
+            x2 = ow
+        if x < 0:
+            x = 0
+        if y2 > oh:
+            y2 = oh
+        if y < 0:
+            y = 0
+
+        image = image[:, y:y2, x:x2, :]
+
+        return(image, x, y, )
+
+class ImageTile:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "rows": ("INT", { "default": 2, "min": 1, "max": 256, "step": 1, }),
+                "cols": ("INT", { "default": 2, "min": 1, "max": 256, "step": 1, }),
+                "overlap": ("FLOAT", { "default": 0, "min": 0, "max": 0.5, "step": 0.01, }),
+                "overlap_x": ("INT", { "default": 0, "min": 0, "max": MAX_RESOLUTION//2, "step": 1, }),
+                "overlap_y": ("INT", { "default": 0, "min": 0, "max": MAX_RESOLUTION//2, "step": 1, }),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "INT", "INT", "INT", "INT")
+    RETURN_NAMES = ("IMAGE", "tile_width", "tile_height", "overlap_x", "overlap_y",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image manipulation"
+
+    def execute(self, image, rows, cols, overlap, overlap_x, overlap_y):
+        h, w = image.shape[1:3]
+        tile_h = h // rows
+        tile_w = w // cols
+        h = tile_h * rows
+        w = tile_w * cols
+        overlap_h = int(tile_h * overlap) + overlap_y
+        overlap_w = int(tile_w * overlap) + overlap_x
+
+        # max overlap is half of the tile size
+        overlap_h = min(tile_h // 2, overlap_h)
+        overlap_w = min(tile_w // 2, overlap_w)
+
+        if rows == 1:
+            overlap_h = 0
+        if cols == 1:
+            overlap_w = 0
+        
+        tiles = []
+        for i in range(rows):
+            for j in range(cols):
+                y1 = i * tile_h
+                x1 = j * tile_w
+
+                if i > 0:
+                    y1 -= overlap_h
+                if j > 0:
+                    x1 -= overlap_w
+
+                y2 = y1 + tile_h + overlap_h
+                x2 = x1 + tile_w + overlap_w
+
+                if y2 > h:
+                    y2 = h
+                    y1 = y2 - tile_h - overlap_h
+                if x2 > w:
+                    x2 = w
+                    x1 = x2 - tile_w - overlap_w
+
+                tiles.append(image[:, y1:y2, x1:x2, :])
+        tiles = torch.cat(tiles, dim=0)
+
+        return(tiles, tile_w+overlap_w, tile_h+overlap_h, overlap_w, overlap_h,)
+
+class ImageUntile:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "tiles": ("IMAGE",),
+                "overlap_x": ("INT", { "default": 0, "min": 0, "max": MAX_RESOLUTION//2, "step": 1, }),
+                "overlap_y": ("INT", { "default": 0, "min": 0, "max": MAX_RESOLUTION//2, "step": 1, }),
+                "rows": ("INT", { "default": 2, "min": 1, "max": 256, "step": 1, }),
+                "cols": ("INT", { "default": 2, "min": 1, "max": 256, "step": 1, }),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image manipulation"
+
+    def execute(self, tiles, overlap_x, overlap_y, rows, cols):
+        tile_h, tile_w = tiles.shape[1:3]
+        tile_h -= overlap_y
+        tile_w -= overlap_x
+        out_w = cols * tile_w
+        out_h = rows * tile_h
+
+        out = torch.zeros((1, out_h, out_w, tiles.shape[3]), device=tiles.device, dtype=tiles.dtype)
+
+        for i in range(rows):
+            for j in range(cols):
+                y1 = i * tile_h
+                x1 = j * tile_w
+
+                if i > 0:
+                    y1 -= overlap_y
+                if j > 0:
+                    x1 -= overlap_x
+
+                y2 = y1 + tile_h + overlap_y
+                x2 = x1 + tile_w + overlap_x
+
+                if y2 > out_h:
+                    y2 = out_h
+                    y1 = y2 - tile_h - overlap_y
+                if x2 > out_w:
+                    x2 = out_w
+                    x1 = x2 - tile_w - overlap_x
+                
+                mask = torch.ones((1, tile_h+overlap_y, tile_w+overlap_x), device=tiles.device, dtype=tiles.dtype)
+
+                # feather the overlap on top
+                if i > 0 and overlap_y > 0:
+                    mask[:, :overlap_y, :] *= torch.linspace(0, 1, overlap_y, device=tiles.device, dtype=tiles.dtype).unsqueeze(1)
+                # feather the overlap on bottom
+                #if i < rows - 1:
+                #    mask[:, -overlap_y:, :] *= torch.linspace(1, 0, overlap_y, device=tiles.device, dtype=tiles.dtype).unsqueeze(1)
+                # feather the overlap on left
+                if j > 0 and overlap_x > 0:
+                    mask[:, :, :overlap_x] *= torch.linspace(0, 1, overlap_x, device=tiles.device, dtype=tiles.dtype).unsqueeze(0)
+                # feather the overlap on right
+                #if j < cols - 1:
+                #    mask[:, :, -overlap_x:] *= torch.linspace(1, 0, overlap_x, device=tiles.device, dtype=tiles.dtype).unsqueeze(0)
+                
+                mask = mask.unsqueeze(-1).repeat(1, 1, 1, tiles.shape[3])
+                tile = tiles[i * cols + j] * mask
+                out[:, y1:y2, x1:x2, :] = out[:, y1:y2, x1:x2, :] * (1 - mask) + tile
+        return(out, )
+
+class ImageSeamCarving:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "width": ("INT", { "default": 512, "min": 1, "max": MAX_RESOLUTION, "step": 1, }),
+                "height": ("INT", { "default": 512, "min": 1, "max": MAX_RESOLUTION, "step": 1, }),
+                "energy": (["backward", "forward"],),
+                "order": (["width-first", "height-first"],),
+            },
+            "optional": {
+                "keep_mask": ("MASK",),
+                "drop_mask": ("MASK",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    CATEGORY = "essentials/image manipulation"
+    FUNCTION = "execute"
+
+    def execute(self, image, width, height, energy, order, keep_mask=None, drop_mask=None):
+        from .carve import seam_carving
+
+        img = image.permute([0, 3, 1, 2])
+
+        if keep_mask is not None:
+            #keep_mask = keep_mask.reshape((-1, 1, keep_mask.shape[-2], keep_mask.shape[-1])).movedim(1, -1)
+            keep_mask = keep_mask.unsqueeze(1)
+
+            if keep_mask.shape[2] != img.shape[2] or keep_mask.shape[3] != img.shape[3]:
+                keep_mask = F.interpolate(keep_mask, size=(img.shape[2], img.shape[3]), mode="bilinear")
+        if drop_mask is not None:
+            drop_mask = drop_mask.unsqueeze(1)
+
+            if drop_mask.shape[2] != img.shape[2] or drop_mask.shape[3] != img.shape[3]:
+                drop_mask = F.interpolate(drop_mask, size=(img.shape[2], img.shape[3]), mode="bilinear")
+
+        out = []
+        for i in range(img.shape[0]):
+            resized = seam_carving(
+                T.ToPILImage()(img[i]),
+                size=(width, height),
+                energy_mode=energy,
+                order=order,
+                keep_mask=T.ToPILImage()(keep_mask[i]) if keep_mask is not None else None,
+                drop_mask=T.ToPILImage()(drop_mask[i]) if drop_mask is not None else None,
+            )
+            out.append(T.ToTensor()(resized))
+
+        out = torch.stack(out).permute([0, 2, 3, 1])
+
+        return(out, )
+
+class ImageRandomTransform:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                "repeat": ("INT", { "default": 1, "min": 1, "max": 256, "step": 1, }),
+                "variation": ("FLOAT", { "default": 0.1, "min": 0.0, "max": 1.0, "step": 0.05, }),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image manipulation"
+
+    def execute(self, image, seed, repeat, variation):
+        h, w = image.shape[1:3]
+        image = image.repeat(repeat, 1, 1, 1).permute([0, 3, 1, 2])
+
+        distortion = 0.2 * variation
+        rotation = 5 * variation
+        brightness = 0.5 * variation
+        contrast = 0.5 * variation
+        saturation = 0.5 * variation
+        hue = 0.2 * variation
+        scale = 0.5 * variation
+
+        torch.manual_seed(seed)
+
+        out = []
+        for i in image:
+            tramsforms = T.Compose([
+                T.RandomPerspective(distortion_scale=distortion, p=0.5),
+                T.RandomRotation(degrees=rotation, interpolation=T.InterpolationMode.BILINEAR, expand=True),
+                T.ColorJitter(brightness=brightness, contrast=contrast, saturation=saturation, hue=(-hue, hue)),
+                T.RandomHorizontalFlip(p=0.5),
+                T.RandomResizedCrop((h, w), scale=(1-scale, 1+scale), ratio=(w/h, w/h), interpolation=T.InterpolationMode.BICUBIC),
+            ])
+            out.append(tramsforms(i.unsqueeze(0)))
+
+        out = torch.cat(out, dim=0).permute([0, 2, 3, 1]).clamp(0, 1)
+
+        return (out,)
+
+class RemBGSession:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "model": (["u2net: general purpose", "u2netp: lightweight general purpose", "u2net_human_seg: human segmentation", "u2net_cloth_seg: cloths Parsing", "silueta: very small u2net", "isnet-general-use: general purpose", "isnet-anime: anime illustrations", "sam: general purpose"],),
+                "providers": (['CPU', 'CUDA', 'ROCM', 'DirectML', 'OpenVINO', 'CoreML', 'Tensorrt', 'Azure'],),
+            },
+        }
+
+    RETURN_TYPES = ("REMBG_SESSION",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image manipulation"
+
+    def execute(self, model, providers):
+        from rembg import new_session, remove
+
+        model = model.split(":")[0]
+
+        class Session:
+            def __init__(self, model, providers):
+                self.session = new_session(model, providers=[providers+"ExecutionProvider"])
+            def process(self, image):
+                return remove(image, session=self.session)
+            
+        return (Session(model, providers),)
+
+class TransparentBGSession:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "mode": (["base", "fast", "base-nightly"],),
+                "use_jit": ("BOOLEAN", { "default": True }),
+            },
+        }
+
+    RETURN_TYPES = ("REMBG_SESSION",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image manipulation"
+
+    def execute(self, mode, use_jit):
+        from transparent_background import Remover
+
+        class Session:
+            def __init__(self, mode, use_jit):
+                self.session = Remover(mode=mode, jit=use_jit)
+            def process(self, image):
+                return self.session.process(image)
+
+        return (Session(mode, use_jit),)
+
+class ImageRemoveBackground:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "rembg_session": ("REMBG_SESSION",),
+                "image": ("IMAGE",),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE", "MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image manipulation"
+
+    def execute(self, rembg_session, image):
+        image = image.permute([0, 3, 1, 2])
+        output = []
+        for img in image:
+            img = T.ToPILImage()(img)
+            img = rembg_session.process(img)
+            output.append(T.ToTensor()(img))
+
+        output = torch.stack(output, dim=0)
+        output = output.permute([0, 2, 3, 1])
+        mask = output[:, :, :, 3] if output.shape[3] == 4 else torch.ones_like(output[:, :, :, 0])
+        # output = output[:, :, :, :3]
+
+        return(output, mask,)
+
+"""
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    Image processing
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+class ImageDesaturate:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "factor": ("FLOAT", { "default": 1.00, "min": 0.00, "max": 1.00, "step": 0.05, }),
+                "method": (["luminance (Rec.709)", "luminance (Rec.601)", "average", "lightness"],),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image processing"
+
+    def execute(self, image, factor, method):
+        if method == "luminance (Rec.709)":
+            grayscale = 0.2126 * image[..., 0] + 0.7152 * image[..., 1] + 0.0722 * image[..., 2]
+        elif method == "luminance (Rec.601)":
+            grayscale = 0.299 * image[..., 0] + 0.587 * image[..., 1] + 0.114 * image[..., 2]
+        elif method == "average":
+            grayscale = image.mean(dim=3)
+        elif method == "lightness":
+            grayscale = (torch.max(image, dim=3)[0] + torch.min(image, dim=3)[0]) / 2
+
+        grayscale = (1.0 - factor) * image + factor * grayscale.unsqueeze(-1).repeat(1, 1, 1, 3)
+        grayscale = torch.clamp(grayscale, 0, 1)
+
+        return(grayscale,)
+
+class PixelOEPixelize:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "downscale_mode": (["contrast", "bicubic", "nearest", "center", "k-centroid"],),
+                "target_size": ("INT", { "default": 128, "min": 0, "max": MAX_RESOLUTION, "step": 8 }),
+                "patch_size": ("INT", { "default": 16, "min": 4, "max": 32, "step": 2 }),
+                "thickness": ("INT", { "default": 2, "min": 1, "max": 16, "step": 1 }),
+                "color_matching": ("BOOLEAN", { "default": True }),
+                "upscale": ("BOOLEAN", { "default": True }),
+                #"contrast": ("FLOAT", { "default": 1.0, "min": 0.0, "max": 100.0, "step": 0.1 }),
+                #"saturation": ("FLOAT", { "default": 1.0, "min": 0.0, "max": 100.0, "step": 0.1 }),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image processing"
+
+    def execute(self, image, downscale_mode, target_size, patch_size, thickness, color_matching, upscale):
+        from pixeloe.pixelize import pixelize
+
+        image = image.clone().mul(255).clamp(0, 255).byte().cpu().numpy()
+        output = []
+        for img in image:
+            img = pixelize(img,
+                           mode=downscale_mode,
+                           target_size=target_size,
+                           patch_size=patch_size,
+                           thickness=thickness,
+                           contrast=1.0,
+                           saturation=1.0,
+                           color_matching=color_matching,
+                           no_upscale=not upscale)
+            output.append(T.ToTensor()(img))
+
+        output = torch.stack(output, dim=0).permute([0, 2, 3, 1])
+
+        return(output,)
+
+class ImagePosterize:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "threshold": ("FLOAT", { "default": 0.50, "min": 0.00, "max": 1.00, "step": 0.05, }),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image processing"
+
+    def execute(self, image, threshold):
+        image = image.mean(dim=3, keepdim=True)
+        image = (image > threshold).float()
+        image = image.repeat(1, 1, 1, 3)
+
+        return(image,)
+
+# From https://github.com/yoonsikp/pycubelut/blob/master/pycubelut.py (MIT license)
+class ImageApplyLUT:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "lut_file": (folder_paths.get_filename_list("luts"),),
+                "gamma_correction": ("BOOLEAN", { "default": True }),
+                "clip_values": ("BOOLEAN", { "default": True }),
+                "strength": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.1 }),
+            }}
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image processing"
+
+    # TODO: check if we can do without numpy
+    def execute(self, image, lut_file, gamma_correction, clip_values, strength):
+        lut_file_path = folder_paths.get_full_path("luts", lut_file)
+        if not lut_file_path or not Path(lut_file_path).exists():
+            print(f"Could not find LUT file: {lut_file_path}")
+            return (image,)
+            
+        from colour.io.luts.iridas_cube import read_LUT_IridasCube
+        
+        device = image.device
+        lut = read_LUT_IridasCube(lut_file_path)
+        lut.name = lut_file
+
+        if clip_values:
+            if lut.domain[0].max() == lut.domain[0].min() and lut.domain[1].max() == lut.domain[1].min():
+                lut.table = np.clip(lut.table, lut.domain[0, 0], lut.domain[1, 0])
+            else:
+                if len(lut.table.shape) == 2:  # 3x1D
+                    for dim in range(3):
+                        lut.table[:, dim] = np.clip(lut.table[:, dim], lut.domain[0, dim], lut.domain[1, dim])
+                else:  # 3D
+                    for dim in range(3):
+                        lut.table[:, :, :, dim] = np.clip(lut.table[:, :, :, dim], lut.domain[0, dim], lut.domain[1, dim])
+
+        out = []
+        for img in image: # TODO: is this more resource efficient? should we use a batch instead?
+            lut_img = img.cpu().numpy().copy()
+
+            is_non_default_domain = not np.array_equal(lut.domain, np.array([[0., 0., 0.], [1., 1., 1.]]))
+            dom_scale = None
+            if is_non_default_domain:
+                dom_scale = lut.domain[1] - lut.domain[0]
+                lut_img = lut_img * dom_scale + lut.domain[0]
+            if gamma_correction:
+                lut_img = lut_img ** (1/2.2)
+            lut_img = lut.apply(lut_img)
+            if gamma_correction:
+                lut_img = lut_img ** (2.2)
+            if is_non_default_domain:
+                lut_img = (lut_img - lut.domain[0]) / dom_scale
+
+            lut_img = torch.from_numpy(lut_img).to(device)
+            if strength < 1.0:
+                lut_img = strength * lut_img + (1 - strength) * img
+            out.append(lut_img)
+
+        out = torch.stack(out)
+
+        return (out, )
+
+# From https://github.com/Jamy-L/Pytorch-Contrast-Adaptive-Sharpening/
+class ImageCAS:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "amount": ("FLOAT", {"default": 0.8, "min": 0, "max": 1, "step": 0.05}),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    CATEGORY = "essentials/image processing"
+    FUNCTION = "execute"
+
+    def execute(self, image, amount):
+        epsilon = 1e-5
+        img = F.pad(image.permute([0,3,1,2]), pad=(1, 1, 1, 1))
+
+        a = img[..., :-2, :-2]
+        b = img[..., :-2, 1:-1]
+        c = img[..., :-2, 2:]
+        d = img[..., 1:-1, :-2]
+        e = img[..., 1:-1, 1:-1]
+        f = img[..., 1:-1, 2:]
+        g = img[..., 2:, :-2]
+        h = img[..., 2:, 1:-1]
+        i = img[..., 2:, 2:]
+
+        # Computing contrast
+        cross = (b, d, e, f, h)
+        mn = min_(cross)
+        mx = max_(cross)
+
+        diag = (a, c, g, i)
+        mn2 = min_(diag)
+        mx2 = max_(diag)
+        mx = mx + mx2
+        mn = mn + mn2
+
+        # Computing local weight
+        inv_mx = torch.reciprocal(mx + epsilon)
+        amp = inv_mx * torch.minimum(mn, (2 - mx))
+
+        # scaling
+        amp = torch.sqrt(amp)
+        w = - amp * (amount * (1/5 - 1/8) + 1/8)
+        div = torch.reciprocal(1 + 4*w)
+
+        output = ((b + d + f + h)*w + e) * div
+        output = output.clamp(0, 1)
+        #output = torch.nan_to_num(output)
+
+        output = output.permute([0,2,3,1])
+
+        return (output,)
+
+class ImageSmartSharpen:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "noise_radius": ("INT", { "default": 7, "min": 1, "max": 25, "step": 1, }),
+                "preserve_edges": ("FLOAT", { "default": 0.75, "min": 0.0, "max": 1.0, "step": 0.05 }),
+                "sharpen": ("FLOAT", { "default": 5.0, "min": 0.0, "max": 25.0, "step": 0.5 }),
+                "ratio": ("FLOAT", { "default": 0.5, "min": 0.0, "max": 1.0, "step": 0.1 }),
+        }}
+
+    RETURN_TYPES = ("IMAGE",)
+    CATEGORY = "essentials/image processing"
+    FUNCTION = "execute"
+
+    def execute(self, image, noise_radius, preserve_edges, sharpen, ratio):
+        import cv2
+
+        output = []
+        #diagonal = np.sqrt(image.shape[1]**2 + image.shape[2]**2)
+        if preserve_edges > 0:
+            preserve_edges = max(1 - preserve_edges, 0.05)
+
+        for img in image:
+            if noise_radius > 1:
+                sigma = 0.3 * ((noise_radius - 1) * 0.5 - 1) + 0.8 # this is what pytorch uses for blur
+                #sigma_color = preserve_edges * (diagonal / 2048)
+                blurred = cv2.bilateralFilter(img.cpu().numpy(), noise_radius, preserve_edges, sigma)
+                blurred = torch.from_numpy(blurred)
+            else:
+                blurred = img
+
+            if sharpen > 0:
+                sharpened = kornia.enhance.sharpness(img.permute(2,0,1), sharpen).permute(1,2,0)
+            else:
+                sharpened = img
+
+            img = ratio * sharpened + (1 - ratio) * blurred
+            img = torch.clamp(img, 0, 1)
+            output.append(img)
+        
+        del blurred, sharpened
+        output = torch.stack(output)
+
+        return (output,)
+
+
+class ExtractKeyframes:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "threshold": ("FLOAT", { "default": 0.85, "min": 0.00, "max": 1.00, "step": 0.01, }),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "STRING")
+    RETURN_NAMES = ("KEYFRAMES", "indexes")
+
+    FUNCTION = "execute"
+    CATEGORY = "essentials"
+
+    def execute(self, image, threshold):
+        window_size = 2
+
+        variations = torch.sum(torch.abs(image[1:] - image[:-1]), dim=[1, 2, 3])
+        #variations = torch.sum((image[1:] - image[:-1]) ** 2, dim=[1, 2, 3])
+        threshold = torch.quantile(variations.float(), threshold).item()
+
+        keyframes = []
+        for i in range(image.shape[0] - window_size + 1):
+            window = image[i:i + window_size]
+            variation = torch.sum(torch.abs(window[-1] - window[0])).item()
+
+            if variation > threshold:
+                keyframes.append(i + window_size - 1)
+
+        return (image[keyframes], ','.join(map(str, keyframes)),)
+
+class ImageColorMatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "reference": ("IMAGE",),
+                "color_space": (["LAB", "YCbCr", "RGB", "LUV", "YUV", "XYZ"],),
+                "factor": ("FLOAT", { "default": 1.0, "min": 0.0, "max": 1.0, "step": 0.05, }),
+                "device": (["auto", "cpu", "gpu"],),
+                "batch_size": ("INT", { "default": 0, "min": 0, "max": 1024, "step": 1, }),
+            },
+            "optional": {
+                "reference_mask": ("MASK",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image processing"
+
+    def execute(self, image, reference, color_space, factor, device, batch_size, reference_mask=None):
+        if "gpu" == device:
+            device = comfy.model_management.get_torch_device()
+        elif "auto" == device:
+            device = comfy.model_management.intermediate_device()
+        else:
+            device = 'cpu'
+
+        image = image.permute([0, 3, 1, 2])
+        reference = reference.permute([0, 3, 1, 2]).to(device)
+         
+        # Ensure reference_mask is in the correct format and on the right device
+        if reference_mask is not None:
+            assert reference_mask.ndim == 3, f"Expected reference_mask to have 3 dimensions, but got {reference_mask.ndim}"
+            assert reference_mask.shape[0] == reference.shape[0], f"Frame count mismatch: reference_mask has {reference_mask.shape[0]} frames, but reference has {reference.shape[0]}"
+            
+            # Reshape mask to (batch, 1, height, width)
+            reference_mask = reference_mask.unsqueeze(1).to(device)
+             
+            # Ensure the mask is binary (0 or 1)
+            reference_mask = (reference_mask > 0.5).float()
+             
+            # Ensure spatial dimensions match
+            if reference_mask.shape[2:] != reference.shape[2:]:
+                reference_mask = comfy.utils.common_upscale(
+                    reference_mask,
+                    reference.shape[3], reference.shape[2],
+                    upscale_method='bicubic',
+                    crop='center'
+                )
+
+        if batch_size == 0 or batch_size > image.shape[0]:
+            batch_size = image.shape[0]
+
+        if "LAB" == color_space:
+            reference = kornia.color.rgb_to_lab(reference)
+        elif "YCbCr" == color_space:
+            reference = kornia.color.rgb_to_ycbcr(reference)
+        elif "LUV" == color_space:
+            reference = kornia.color.rgb_to_luv(reference)
+        elif "YUV" == color_space:
+            reference = kornia.color.rgb_to_yuv(reference)
+        elif "XYZ" == color_space:
+            reference = kornia.color.rgb_to_xyz(reference)
+
+        reference_mean, reference_std = self.compute_mean_std(reference, reference_mask)
+
+        image_batch = torch.split(image, batch_size, dim=0)
+        output = []
+
+        for image in image_batch:
+            image = image.to(device)
+
+            if color_space == "LAB":
+                image = kornia.color.rgb_to_lab(image)
+            elif color_space == "YCbCr":
+                image = kornia.color.rgb_to_ycbcr(image)
+            elif color_space == "LUV":
+                image = kornia.color.rgb_to_luv(image)
+            elif color_space == "YUV":
+                image = kornia.color.rgb_to_yuv(image)
+            elif color_space == "XYZ":
+                image = kornia.color.rgb_to_xyz(image)
+
+            image_mean, image_std = self.compute_mean_std(image)
+
+            matched = torch.nan_to_num((image - image_mean) / image_std) * torch.nan_to_num(reference_std) + reference_mean
+            matched = factor * matched + (1 - factor) * image
+
+            if color_space == "LAB":
+                matched = kornia.color.lab_to_rgb(matched)
+            elif color_space == "YCbCr":
+                matched = kornia.color.ycbcr_to_rgb(matched)
+            elif color_space == "LUV":
+                matched = kornia.color.luv_to_rgb(matched)
+            elif color_space == "YUV":
+                matched = kornia.color.yuv_to_rgb(matched)
+            elif color_space == "XYZ":
+                matched = kornia.color.xyz_to_rgb(matched)
+
+            out = matched.permute([0, 2, 3, 1]).clamp(0, 1).to(comfy.model_management.intermediate_device())
+            output.append(out)
+
+        out = None
+        output = torch.cat(output, dim=0)
+        return (output,)
+
+    def compute_mean_std(self, tensor, mask=None):
+        if mask is not None:
+            # Apply mask to the tensor
+            masked_tensor = tensor * mask
+
+            # Calculate the sum of the mask for each channel
+            mask_sum = mask.sum(dim=[2, 3], keepdim=True)
+
+            # Avoid division by zero
+            mask_sum = torch.clamp(mask_sum, min=1e-6)
+
+            # Calculate mean and std only for masked area
+            mean = torch.nan_to_num(masked_tensor.sum(dim=[2, 3], keepdim=True) / mask_sum)
+            std = torch.sqrt(torch.nan_to_num(((masked_tensor - mean) ** 2 * mask).sum(dim=[2, 3], keepdim=True) / mask_sum))
+        else:
+            mean = tensor.mean(dim=[2, 3], keepdim=True)
+            std = tensor.std(dim=[2, 3], keepdim=True)
+        return mean, std
+
+class ImageColorMatchAdobe(ImageColorMatch):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "reference": ("IMAGE",),
+                "color_space": (["RGB", "LAB"],),
+                "luminance_factor": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 2.0, "step": 0.05}),
+                "color_intensity_factor": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 2.0, "step": 0.05}),
+                "fade_factor": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.05}),
+                "neutralization_factor": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.05}),
+                "device": (["auto", "cpu", "gpu"],),
+            },
+            "optional": {
+                "reference_mask": ("MASK",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image processing"
+
+    def analyze_color_statistics(self, image, mask=None):
+        # Assuming image is in RGB format
+        l, a, b = kornia.color.rgb_to_lab(image).chunk(3, dim=1)
+
+        if mask is not None:
+            # Ensure mask is binary and has the same spatial dimensions as the image
+            mask = F.interpolate(mask, size=image.shape[2:], mode='nearest')
+            mask = (mask > 0.5).float()
+            
+            # Apply mask to each channel
+            l = l * mask
+            a = a * mask
+            b = b * mask
+            
+            # Compute masked mean and std
+            num_pixels = mask.sum()
+            mean_l = (l * mask).sum() / num_pixels
+            mean_a = (a * mask).sum() / num_pixels
+            mean_b = (b * mask).sum() / num_pixels
+            std_l = torch.sqrt(((l - mean_l)**2 * mask).sum() / num_pixels)
+            var_ab = ((a - mean_a)**2 + (b - mean_b)**2) * mask
+            std_ab = torch.sqrt(var_ab.sum() / num_pixels)
+        else:
+            mean_l = l.mean()
+            std_l = l.std()
+            mean_a = a.mean()
+            mean_b = b.mean()
+            std_ab = torch.sqrt(a.var() + b.var())
+
+        return mean_l, std_l, mean_a, mean_b, std_ab
+
+    def apply_color_transformation(self, image, source_stats, dest_stats, L, C, N):
+        l, a, b = kornia.color.rgb_to_lab(image).chunk(3, dim=1)
+        
+        # Unpack statistics
+        src_mean_l, src_std_l, src_mean_a, src_mean_b, src_std_ab = source_stats
+        dest_mean_l, dest_std_l, dest_mean_a, dest_mean_b, dest_std_ab = dest_stats
+
+        # Adjust luminance
+        l_new = (l - dest_mean_l) * (src_std_l / dest_std_l) * L + src_mean_l
+
+        # Neutralize color cast
+        a = a - N * dest_mean_a
+        b = b - N * dest_mean_b
+
+        # Adjust color intensity
+        a_new = a * (src_std_ab / dest_std_ab) * C
+        b_new = b * (src_std_ab / dest_std_ab) * C
+
+        # Combine channels
+        lab_new = torch.cat([l_new, a_new, b_new], dim=1)
+
+        # Convert back to RGB
+        rgb_new = kornia.color.lab_to_rgb(lab_new)
+
+        return rgb_new
+
+    def execute(self, image, reference, color_space, luminance_factor, color_intensity_factor, fade_factor, neutralization_factor, device, reference_mask=None):
+        if "gpu" == device:
+            device = comfy.model_management.get_torch_device()
+        elif "auto" == device:
+            device = comfy.model_management.intermediate_device()
+        else:
+            device = 'cpu'
+
+        # Ensure image and reference are in the correct shape (B, C, H, W)
+        image = image.permute(0, 3, 1, 2).to(device)
+        reference = reference.permute(0, 3, 1, 2).to(device)
+
+        # Handle reference_mask (if provided)
+        if reference_mask is not None:
+            # Ensure reference_mask is 4D (B, 1, H, W)
+            if reference_mask.ndim == 2:
+                reference_mask = reference_mask.unsqueeze(0).unsqueeze(0)
+            elif reference_mask.ndim == 3:
+                reference_mask = reference_mask.unsqueeze(1)
+            reference_mask = reference_mask.to(device)
+
+         # Analyze color statistics
+        source_stats = self.analyze_color_statistics(reference, reference_mask)
+        dest_stats = self.analyze_color_statistics(image)
+
+        # Apply color transformation
+        transformed = self.apply_color_transformation(
+            image, source_stats, dest_stats, 
+            luminance_factor, color_intensity_factor, neutralization_factor
+        )
+
+        # Apply fade factor
+        result = fade_factor * transformed + (1 - fade_factor) * image
+
+        # Convert back to (B, H, W, C) format and ensure values are in [0, 1] range
+        result = result.permute(0, 2, 3, 1).clamp(0, 1).to(comfy.model_management.intermediate_device())
+
+        return (result,)
+
+
+class ImageHistogramMatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "reference": ("IMAGE",),
+                "method": (["pytorch", "skimage"],),
+                "factor": ("FLOAT", { "default": 1.0, "min": 0.0, "max": 1.0, "step": 0.05, }),
+                "device": (["auto", "cpu", "gpu"],),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image processing"
+
+    def execute(self, image, reference, method, factor, device):
+        if "gpu" == device:
+            device = comfy.model_management.get_torch_device()
+        elif "auto" == device:
+            device = comfy.model_management.intermediate_device()
+        else:
+            device = 'cpu'
+
+        if "pytorch" in method:
+            from .histogram_matching import Histogram_Matching
+
+            image = image.permute([0, 3, 1, 2]).to(device)
+            reference = reference.permute([0, 3, 1, 2]).to(device)[0].unsqueeze(0)
+            image.requires_grad = True
+            reference.requires_grad = True
+
+            out = []
+
+            for i in image:
+                i = i.unsqueeze(0)
+                hm = Histogram_Matching(differentiable=True)
+                out.append(hm(i, reference))
+            out = torch.cat(out, dim=0)
+            out = factor * out + (1 - factor) * image
+            out = out.permute([0, 2, 3, 1]).clamp(0, 1)
+        else:
+            from skimage.exposure import match_histograms
+
+            out = torch.from_numpy(match_histograms(image.cpu().numpy(), reference.cpu().numpy(), channel_axis=3)).to(device)
+            out = factor * out + (1 - factor) * image.to(device)
+
+        return (out.to(comfy.model_management.intermediate_device()),)
+
+"""
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    Utilities
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+class ImageToDevice:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "device": (["auto", "cpu", "gpu"],),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image utils"
+
+    def execute(self, image, device):
+        if "gpu" == device:
+            device = comfy.model_management.get_torch_device()
+        elif "auto" == device:
+            device = comfy.model_management.intermediate_device()
+        else:
+            device = 'cpu'
+
+        image = image.clone().to(device)
+        torch.cuda.empty_cache()
+
+        return (image,)
+
+class GetImageSize:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+            }
+        }
+
+    RETURN_TYPES = ("INT", "INT", "INT",)
+    RETURN_NAMES = ("width", "height", "count")
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image utils"
+
+    def execute(self, image):
+        return (image.shape[2], image.shape[1], image.shape[0])
+
+class ImageRemoveAlpha:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image utils"
+
+    def execute(self, image):
+        if image.shape[3] == 4:
+            image = image[..., :3]
+        return (image,)
+
+class ImagePreviewFromLatent(SaveImage):
+    def __init__(self):
+        self.output_dir = folder_paths.get_temp_directory()
+        self.type = "temp"
+        self.prefix_append = "_temp_" + ''.join(random.choice("abcdefghijklmnopqrstupvxyz") for x in range(5))
+        self.compress_level = 1
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "latent": ("LATENT",),
+                "vae": ("VAE", ),
+                "tile_size": ("INT", {"default": 0, "min": 0, "max": 4096, "step": 64})
+            }, "optional": {
+                "image": (["none"], {"image_upload": False}),
+            }, "hidden": {
+                "prompt": "PROMPT",
+                "extra_pnginfo": "EXTRA_PNGINFO",
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE", "MASK", "INT", "INT",)
+    RETURN_NAMES = ("IMAGE", "MASK", "width", "height",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image utils"
+
+    def execute(self, latent, vae, tile_size, prompt=None, extra_pnginfo=None, image=None, filename_prefix="ComfyUI"):
+        mask = torch.zeros((64,64), dtype=torch.float32, device="cpu")
+        ui = None
+
+        if image.startswith("clipspace"):
+            image_path = folder_paths.get_annotated_filepath(image)
+            if not os.path.exists(image_path):
+                raise ValueError(f"Clipspace image does not exist anymore, select 'none' in the image field.")
+
+            img = pillow(Image.open, image_path)
+            img = pillow(ImageOps.exif_transpose, img)
+            if img.mode == "I":
+                img = img.point(lambda i: i * (1 / 255))
+            image = img.convert("RGB")
+            image = np.array(image).astype(np.float32) / 255.0
+            image = torch.from_numpy(image)[None,]
+            if "A" in img.getbands():
+                mask = np.array(img.getchannel('A')).astype(np.float32) / 255.0
+                mask = 1. - torch.from_numpy(mask)
+            ui = {
+                "filename": os.path.basename(image_path),
+                "subfolder": os.path.dirname(image_path),
+                "type": "temp",
+            }
+        else:
+            if tile_size > 0:
+                tile_size = max(tile_size, 320)
+                image = vae.decode_tiled(latent["samples"], tile_x=tile_size // 8, tile_y=tile_size // 8, )
+            else:
+                image = vae.decode(latent["samples"])
+            ui = self.save_images(image, filename_prefix, prompt, extra_pnginfo)
+
+        out = {**ui, "result": (image, mask, image.shape[2], image.shape[1],)}
+        return out
+
+class NoiseFromImage:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "noise_strenght": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01 }),
+                "noise_size": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01 }),
+                "color_noise": ("FLOAT", {"default": 0.2, "min": 0.0, "max": 1.0, "step": 0.01 }),
+                "mask_strength": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01 }),
+                "mask_scale_diff": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01 }),
+                "mask_contrast": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 100.0, "step": 0.1 }),
+                "saturation": ("FLOAT", {"default": 2.0, "min": 0.0, "max": 100.0, "step": 0.1 }),
+                "contrast": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 100.0, "step": 0.1 }),
+                "blur": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.1 }),
+            },
+            "optional": {
+                "noise_mask": ("IMAGE",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image utils"
+
+    def execute(self, image, noise_size, color_noise, mask_strength, mask_scale_diff, mask_contrast, noise_strenght, saturation, contrast, blur, noise_mask=None):
+        torch.manual_seed(0)
+
+        elastic_alpha = max(image.shape[1], image.shape[2])# * noise_size
+        elastic_sigma = elastic_alpha / 400 * noise_size
+
+        blur_size = int(6 * blur+1)
+        if blur_size % 2 == 0:
+            blur_size+= 1
+
+        if noise_mask is None:
+            noise_mask = image
+        
+        # increase contrast of the mask
+        if mask_contrast != 1:
+            noise_mask = T.ColorJitter(contrast=(mask_contrast,mask_contrast))(noise_mask.permute([0, 3, 1, 2])).permute([0, 2, 3, 1])
+
+        # Ensure noise mask is the same size as the image
+        if noise_mask.shape[1:] != image.shape[1:]:
+            noise_mask = F.interpolate(noise_mask.permute([0, 3, 1, 2]), size=(image.shape[1], image.shape[2]), mode='bicubic', align_corners=False)
+            noise_mask = noise_mask.permute([0, 2, 3, 1])
+        # Ensure we have the same number of masks and images
+        if noise_mask.shape[0] > image.shape[0]:
+            noise_mask = noise_mask[:image.shape[0]]
+        else:
+            noise_mask = torch.cat((noise_mask, noise_mask[-1:].repeat((image.shape[0]-noise_mask.shape[0], 1, 1, 1))), dim=0)
+
+        # Convert mask to grayscale mask
+        noise_mask = noise_mask.mean(dim=3).unsqueeze(-1)
+
+        # add color noise
+        imgs = image.clone().permute([0, 3, 1, 2])
+        if color_noise > 0:
+            color_noise = torch.normal(torch.zeros_like(imgs), std=color_noise)
+            color_noise *= (imgs - imgs.min()) / (imgs.max() - imgs.min())
+
+            imgs = imgs + color_noise
+            imgs = imgs.clamp(0, 1)
+
+        # create fine and coarse noise
+        fine_noise = []
+        for n in imgs:
+            avg_color = n.mean(dim=[1,2])
+
+            tmp_noise = T.ElasticTransform(alpha=elastic_alpha, sigma=elastic_sigma, fill=avg_color.tolist())(n)
+            if blur > 0:
+                tmp_noise = T.GaussianBlur(blur_size, blur)(tmp_noise)
+            tmp_noise = T.ColorJitter(contrast=(contrast,contrast), saturation=(saturation,saturation))(tmp_noise)
+            fine_noise.append(tmp_noise)
+
+        imgs = None
+        del imgs
+
+        fine_noise = torch.stack(fine_noise, dim=0)
+        fine_noise = fine_noise.permute([0, 2, 3, 1])
+        #fine_noise = torch.stack(fine_noise, dim=0)
+        #fine_noise = pb(fine_noise)
+        mask_scale_diff = min(mask_scale_diff, 0.99)
+        if mask_scale_diff > 0:
+            coarse_noise = F.interpolate(fine_noise.permute([0, 3, 1, 2]), scale_factor=1-mask_scale_diff, mode='area')
+            coarse_noise = F.interpolate(coarse_noise, size=(fine_noise.shape[1], fine_noise.shape[2]), mode='bilinear', align_corners=False)
+            coarse_noise = coarse_noise.permute([0, 2, 3, 1])
+        else:
+            coarse_noise = fine_noise
+
+        output = (1 - noise_mask) * coarse_noise + noise_mask * fine_noise
+
+        if mask_strength < 1:
+            noise_mask = noise_mask.pow(mask_strength)
+            noise_mask = torch.nan_to_num(noise_mask).clamp(0, 1)
+        output = noise_mask * output + (1 - noise_mask) * image
+
+        # apply noise to image
+        output = output * noise_strenght + image * (1 - noise_strenght)
+        output = output.clamp(0, 1)
+
+        return (output, )
+
+IMAGE_CLASS_MAPPINGS = {
+    # Image analysis
+    "ImageEnhanceDifference+": ImageEnhanceDifference,
+
+    # Image batch
+    "ImageBatchMultiple+": ImageBatchMultiple,
+    "ImageExpandBatch+": ImageExpandBatch,
+    "ImageFromBatch+": ImageFromBatch,
+    "ImageListToBatch+": ImageListToBatch,
+    "ImageBatchToList+": ImageBatchToList,
+
+    # Image manipulation
+    "ImageCompositeFromMaskBatch+": ImageCompositeFromMaskBatch,
+    "ImageComposite+": ImageComposite,
+    "ImageCrop+": ImageCrop,
+    "ImageFlip+": ImageFlip,
+    "ImageRandomTransform+": ImageRandomTransform,
+    "ImageRemoveAlpha+": ImageRemoveAlpha,
+    "ImageRemoveBackground+": ImageRemoveBackground,
+    "ImageResize+": ImageResize,
+    "ImageSeamCarving+": ImageSeamCarving,
+    "ImageTile+": ImageTile,
+    "ImageUntile+": ImageUntile,
+    "RemBGSession+": RemBGSession,
+    "TransparentBGSession+": TransparentBGSession,
+
+    # Image processing
+    "ImageApplyLUT+": ImageApplyLUT,
+    "ImageCASharpening+": ImageCAS,
+    "ImageDesaturate+": ImageDesaturate,
+    "PixelOEPixelize+": PixelOEPixelize,
+    "ImagePosterize+": ImagePosterize,
+    "ImageColorMatch+": ImageColorMatch,
+    "ImageColorMatchAdobe+": ImageColorMatchAdobe,
+    "ImageHistogramMatch+": ImageHistogramMatch,
+    "ImageSmartSharpen+": ImageSmartSharpen,
+
+    # Utilities
+    "GetImageSize+": GetImageSize,
+    "ImageToDevice+": ImageToDevice,
+    "ImagePreviewFromLatent+": ImagePreviewFromLatent,
+    "NoiseFromImage+": NoiseFromImage,
+    #"ExtractKeyframes+": ExtractKeyframes,
+}
+
+IMAGE_NAME_MAPPINGS = {
+    # Image analysis
+    "ImageEnhanceDifference+": "🔧 Image Enhance Difference",
+
+    # Image batch
+    "ImageBatchMultiple+": "🔧 Images Batch Multiple",
+    "ImageExpandBatch+": "🔧 Image Expand Batch",
+    "ImageFromBatch+": "🔧 Image From Batch",
+    "ImageListToBatch+": "🔧 Image List To Batch",
+    "ImageBatchToList+": "🔧 Image Batch To List",
+
+    # Image manipulation
+    "ImageCompositeFromMaskBatch+": "🔧 Image Composite From Mask Batch",
+    "ImageComposite+": "🔧 Image Composite",
+    "ImageCrop+": "🔧 Image Crop",
+    "ImageFlip+": "🔧 Image Flip",
+    "ImageRandomTransform+": "🔧 Image Random Transform",
+    "ImageRemoveAlpha+": "🔧 Image Remove Alpha",
+    "ImageRemoveBackground+": "🔧 Image Remove Background",
+    "ImageResize+": "🔧 Image Resize",
+    "ImageSeamCarving+": "🔧 Image Seam Carving",
+    "ImageTile+": "🔧 Image Tile",
+    "ImageUntile+": "🔧 Image Untile",
+    "RemBGSession+": "🔧 RemBG Session",
+    "TransparentBGSession+": "🔧 InSPyReNet TransparentBG",
+
+    # Image processing
+    "ImageApplyLUT+": "🔧 Image Apply LUT",
+    "ImageCASharpening+": "🔧 Image Contrast Adaptive Sharpening",
+    "ImageDesaturate+": "🔧 Image Desaturate",
+    "PixelOEPixelize+": "🔧 Pixelize",
+    "ImagePosterize+": "🔧 Image Posterize",
+    "ImageColorMatch+": "🔧 Image Color Match",
+    "ImageColorMatchAdobe+": "🔧 Image Color Match Adobe",
+    "ImageHistogramMatch+": "🔧 Image Histogram Match",
+    "ImageSmartSharpen+": "🔧 Image Smart Sharpen",
+
+    # Utilities
+    "GetImageSize+": "🔧 Get Image Size",
+    "ImageToDevice+": "🔧 Image To Device",
+    "ImagePreviewFromLatent+": "🔧 Image Preview From Latent",
+    "NoiseFromImage+": "🔧 Noise From Image",
+}

ComfyUI_essentials/js/DisplayAny.js

@@ -0,0 +1,36 @@
+import { app } from "../../scripts/app.js";
+import { ComfyWidgets } from "../../scripts/widgets.js";
+
+app.registerExtension({
+    name: "essentials.DisplayAny",
+    async beforeRegisterNodeDef(nodeType, nodeData, app) {
+        if (!nodeData?.category?.startsWith("essentials")) {
+            return;
+        }
+
+        if (nodeData.name === "DisplayAny") {
+            const onExecuted = nodeType.prototype.onExecuted;
+
+            nodeType.prototype.onExecuted = function (message) {
+                onExecuted?.apply(this, arguments);
+
+                if (this.widgets) {
+					for (let i = 1; i < this.widgets.length; i++) {
+						this.widgets[i].onRemove?.();
+					}
+					this.widgets.length = 1;
+				}
+
+                // Check if the "text" widget already exists.
+                let textWidget = this.widgets && this.widgets.find(w => w.name === "displaytext");
+                if (!textWidget) {
+                    textWidget = ComfyWidgets["STRING"](this, "displaytext", ["STRING", { multiline: true }], app).widget;
+                    textWidget.inputEl.readOnly = true;
+                    textWidget.inputEl.style.border = "none";
+                    textWidget.inputEl.style.backgroundColor = "transparent";
+                }
+                textWidget.value = message["text"].join("");
+            };
+        }
+    },
+});

ComfyUI_essentials/js/FluxAttentionSeeker.js

@@ -0,0 +1,133 @@
+import { app } from "../../scripts/app.js";
+
+app.registerExtension({
+    name: "essentials.FluxAttentionSeeker",
+    async beforeRegisterNodeDef(nodeType, nodeData, app) {
+        if (!nodeData?.category?.startsWith("essentials")) {
+            return;
+        }
+
+        if (nodeData.name === "FluxAttentionSeeker+") {
+            const onCreated = nodeType.prototype.onNodeCreated;
+
+            nodeType.prototype.onNodeCreated = function () {
+                this.addWidget("button", "RESET ALL", null, () => {
+                    this.widgets.forEach(w => {
+                        if (w.type === "slider") {
+                            w.value = 1.0;
+                        }
+                    });
+                });
+
+                this.addWidget("button", "ZERO ALL", null, () => {
+                    this.widgets.forEach(w => {
+                        if (w.type === "slider") {
+                            w.value = 0.0;
+                        }
+                    });
+                });
+
+                this.addWidget("button", "REPEAT FIRST", null, () => {
+                    var clip_value = undefined;
+                    var t5_value = undefined;
+                    this.widgets.forEach(w => {
+                        if (w.name.startsWith('clip_l')) {
+                            if (clip_value === undefined) {
+                                clip_value = w.value;
+                            }
+                            w.value = clip_value;
+                        } else if (w.name.startsWith('t5')) {
+                            if (t5_value === undefined) {
+                                t5_value = w.value;
+                            }
+                            w.value = t5_value;
+                        }
+                    });
+                });
+            };
+        }
+    },
+});
+
+app.registerExtension({
+    name: "essentials.SD3AttentionSeekerLG",
+    async beforeRegisterNodeDef(nodeType, nodeData, app) {
+        if (!nodeData?.category?.startsWith("essentials")) {
+            return;
+        }
+
+        if (nodeData.name === "SD3AttentionSeekerLG+") {
+            const onCreated = nodeType.prototype.onNodeCreated;
+
+            nodeType.prototype.onNodeCreated = function () {
+                this.addWidget("button", "RESET L", null, () => {
+                    this.widgets.forEach(w => {
+                        if (w.type === "slider" && w.name.startsWith('clip_l')) {
+                            w.value = 1.0;
+                        }
+                    });
+                });
+                this.addWidget("button", "RESET G", null, () => {
+                    this.widgets.forEach(w => {
+                        if (w.type === "slider" && w.name.startsWith('clip_g')) {
+                            w.value = 1.0;
+                        }
+                    });
+                });
+
+                this.addWidget("button", "REPEAT FIRST", null, () => {
+                    var clip_l_value = undefined;
+                    var clip_g_value = undefined;
+                    this.widgets.forEach(w => {
+                        if (w.name.startsWith('clip_l')) {
+                            if (clip_l_value === undefined) {
+                                clip_l_value = w.value;
+                            }
+                            w.value = clip_l_value;
+                        } else if (w.name.startsWith('clip_g')) {
+                            if (clip_g_value === undefined) {
+                                clip_g_value = w.value;
+                            }
+                            w.value = clip_g_value;
+                        }
+                    });
+                });
+            };
+        }
+    },
+});
+
+app.registerExtension({
+    name: "essentials.SD3AttentionSeekerT5",
+    async beforeRegisterNodeDef(nodeType, nodeData, app) {
+        if (!nodeData?.category?.startsWith("essentials")) {
+            return;
+        }
+
+        if (nodeData.name === "SD3AttentionSeekerT5+") {
+            const onCreated = nodeType.prototype.onNodeCreated;
+
+            nodeType.prototype.onNodeCreated = function () {
+                this.addWidget("button", "RESET ALL", null, () => {
+                    this.widgets.forEach(w => {
+                        if (w.type === "slider") {
+                            w.value = 1.0;
+                        }
+                    });
+                });
+
+                this.addWidget("button", "REPEAT FIRST", null, () => {
+                    var t5_value = undefined;
+                    this.widgets.forEach(w => {
+                        if (w.name.startsWith('t5')) {
+                            if (t5_value === undefined) {
+                                t5_value = w.value;
+                            }
+                            w.value = t5_value;
+                        }
+                    });
+                });
+            };
+        }
+    },
+});