-
----
-#### Node: IsOneOfGroupsActive
-
-Checks the state of all groups whose names **contain a specified substring**.
-
-- If **at least one** matching group is Active -> output is `true`.
-- If **all** matching groups are Muted/Bypassed -> output is `false`.
-
-
-
----
-#### Node: AK Index Multiple
-
-Extracts a specific range from any **List** (images, masks, latents, text etc..) and creates individual outputs for that range.
-Optionally replaces missing values with a fallback (`if_none`).
-
-
-
----
-#### Node: AK CLIP Encode Multiple
-
-Extracts a specific range from any **List** of strings and CLIP encodes individual outputs for that range.
-
-Same as **AK Index Multiple** but for CLIP encoding. Works faster than regular CLIP Encoders because does only one encoding for all NONE input strings. Caches the stings and does not encode them if no changes. Also outputs combined conditioning.
-
-
-
----
-#### Node: AK KSampler Settings & AK KSampler Settings Out
-
-Allows you to define sampler settings anywhere in the workflow.
-The Out node lets you retrieve these settings wherever they are needed.
-
-- `Seed`, `Sampler`, `Scheduler`, `Steps`, `Cfg`, `Denoise`, `xz_steps`
-
-> [!NOTE]
-> This node includes an additional field called xz_steps.
-> It is used to control the number of steps when working with my 📘 [ComfyUI-AK-XZ-Axis](https://github.com/akawana/ComfyUI-AK-XZ-Axis) nodes.
-> This field is also convenient when used together with the **AK Base** node, because it can automatically set xz_steps = 1 when a single image is selected in the gallery.
-
----
-#### Node: AK Replace Alpha With Color & AK Replace Color With Alpha
-
-`AK Replace Alpha With Color` Replaces alpha with a color.
-
-`AK Replace Color With Alpha` Performs the reverse operation: Replaces a color with alpha. You can specify the color manually, or use automatic modes that detect the color from pixels in different corners of the image. Image **cropping** is also available. This is useful because when rendering images on a flat background, the outermost pixels around the edges often have color artifacts and are better removed.
-
-> [!NOTE]
-> Both of these nodes are useful when working with images that have a transparent background. You can first replace alpha with a color, perform the generation, and then, before saving, remove that color and convert it back to alpha.
-
-
-
----
-#### Other nodes
-
-##### Node: AK Pipe & AK Pipe Loop
-
-AK Pipe is a zero-copy pipeline node that passes a structured pipe object through the graph and updates only explicitly connected inputs. It avoids unnecessary allocations by reusing the original pipe when no values change and creates a new container only on real object replacement. This design minimizes memory churn and Python overhead, making it significantly faster than traditional pipe merge nodes.
-
-`AK Pipe Loop` Always outputs the most recently modified connected AK Pipe.
-
-##### Node: CLIP Text Encode Cached
-
-Simple node for encoding conditioning with a small caching experiment.
-
-##### Node: CLIP Text Encode and Combine Cached
-
-Can combine the input conditioning with the text entered in the node.
-
-
-
-##### Node: AK Resize On Boolean
-
-Resizes the image and optional mask based on a boolean parameter (enable / disable). Useful when working with the **Project Settings** panel.
-
-
-
-##### Node: AK Contrast And Saturate Image
-
-Node for adjusting image contrast and saturation.
-
-##### Node: Preview Raw Text
-
-Displays text and can format **JSON**. It also supports displaying a list of texts.
-
----
-
-# Installation
-
-From your ComfyUI root directory:
-
-```bash
-cd ComfyUI/custom_nodes
-git clone https://github.com/akawana/ComfyUI-Utils-extra.git
\ No newline at end of file
diff --git a/custom_nodes/ComfyUI-AK-Pack/__init__.py b/custom_nodes/ComfyUI-AK-Pack/__init__.py
deleted file mode 100644
index 38354b3463150598e1587788d75e05316ec5dd86..0000000000000000000000000000000000000000
--- a/custom_nodes/ComfyUI-AK-Pack/__init__.py
+++ /dev/null
@@ -1,109 +0,0 @@
-WEB_DIRECTORY = "./js"
-
-from .nodes.AKIndexMultiple import NODE_CLASS_MAPPINGS as AKIndexMultiple_MAPPINGS
-from .nodes.AKIndexMultiple import NODE_DISPLAY_NAME_MAPPINGS as AKIndexMultiple_DISPLAY
-
-from .nodes.AKCLIPEncodeMultiple import NODE_CLASS_MAPPINGS as AKCLIPEncodeMultiple_MAPPINGS
-from .nodes.AKCLIPEncodeMultiple import NODE_DISPLAY_NAME_MAPPINGS as AKCLIPEncodeMultiple_DISPLAY
-
-from .nodes.IsOneOfGroupsActive import NODE_CLASS_MAPPINGS as GROUPCHK_MAPPINGS
-from .nodes.IsOneOfGroupsActive import NODE_DISPLAY_NAME_MAPPINGS as GROUPCHK_DISPLAY
-
-from .nodes.RepeatGroupState import NODE_CLASS_MAPPINGS as RPSTATE_MAPPINGS
-from .nodes.RepeatGroupState import NODE_DISPLAY_NAME_MAPPINGS as RPSTATE_DISPLAY
-
-from .nodes.PreviewRawText import NODE_CLASS_MAPPINGS as PRTSTATE_MAPPINGS
-from .nodes.PreviewRawText import NODE_DISPLAY_NAME_MAPPINGS as PRTSTATE_DISPLAY
-
-from .nodes.CLIPTextEncodeCached import NODE_CLASS_MAPPINGS as CLCSTATE_MAPPINGS
-from .nodes.CLIPTextEncodeCached import NODE_DISPLAY_NAME_MAPPINGS as CLCSTATE_DISPLAY
-
-from .nodes.CLIPTextEncodeAndCombineCached import NODE_CLASS_MAPPINGS as CLCOMBINE_STATE_MAPPINGS
-from .nodes.CLIPTextEncodeAndCombineCached import NODE_DISPLAY_NAME_MAPPINGS as CLCOMBINE_STATE_DISPLAY
-
-from .nodes.AKBase import NODE_CLASS_MAPPINGS as AKBSTATE_MAPPINGS
-from .nodes.AKBase import NODE_DISPLAY_NAME_MAPPINGS as AKBSTATE_DISPLAY
-
-from .nodes.AKPipe import NODE_CLASS_MAPPINGS as AKPIPESTATE_MAPPINGS
-from .nodes.AKPipe import NODE_DISPLAY_NAME_MAPPINGS as AKPIPESTATE_DISPLAY
-
-from .nodes.AKPipeLoop import NODE_CLASS_MAPPINGS as AKPIPEL_STATE_MAPPINGS
-from .nodes.AKPipeLoop import NODE_DISPLAY_NAME_MAPPINGS as AKPIPEL_STATE_DISPLAY
-
-from .nodes.Setter import NODE_CLASS_MAPPINGS as SETTERSTATE_MAPPINGS
-from .nodes.Setter import NODE_DISPLAY_NAME_MAPPINGS as SETTERSTATE_DISPLAY
-
-from .nodes.Getter import NODE_CLASS_MAPPINGS as GETTERSTATE_MAPPINGS
-from .nodes.Getter import NODE_DISPLAY_NAME_MAPPINGS as GETTERSTATE_DISPLAY
-
-from .nodes.AKResizeOnBoolean import NODE_CLASS_MAPPINGS as RESIZESTATE_MAPPINGS
-from .nodes.AKResizeOnBoolean import NODE_DISPLAY_NAME_MAPPINGS as RESIZESTATE_DISPLAY
-
-from .nodes.IsMaskEmpty import NODE_CLASS_MAPPINGS as ISMSTATE_MAPPINGS
-from .nodes.IsMaskEmpty import NODE_DISPLAY_NAME_MAPPINGS as ISMSTATE_DISPLAY
-
-from .nodes.AKContrastAndSaturateImage import NODE_CLASS_MAPPINGS as AKSAT_STATE_MAPPINGS
-from .nodes.AKContrastAndSaturateImage import NODE_DISPLAY_NAME_MAPPINGS as AKSAT_STATE_DISPLAY
-
-from .nodes.AKReplaceAlphaWithColor import NODE_CLASS_MAPPINGS as AKRALPHA_STATE_MAPPINGS
-from .nodes.AKReplaceAlphaWithColor import NODE_DISPLAY_NAME_MAPPINGS as AKRALPHA_STATE_DISPLAY
-
-from .nodes.AKReplaceColorWithAlpha import NODE_CLASS_MAPPINGS as AKRCOLOR_STATE_MAPPINGS
-from .nodes.AKReplaceColorWithAlpha import NODE_DISPLAY_NAME_MAPPINGS as AKRCOLOR_STATE_DISPLAY
-
-from .nodes.AKControlMultipleKSamplers import NODE_CLASS_MAPPINGS as AK_CONTROL_SAMPLERS_COLOR_STATE_MAPPINGS
-from .nodes.AKControlMultipleKSamplers import NODE_DISPLAY_NAME_MAPPINGS as AK_CONTROL_SAMPLERS_COLOR_STATE_DISPLAY
-
-from .nodes.AKKSamplerSettings import NODE_CLASS_MAPPINGS as AKKSamplerSettings_STATE_MAPPINGS
-from .nodes.AKKSamplerSettings import NODE_DISPLAY_NAME_MAPPINGS as AKKSamplerSettings_STATE_DISPLAY
-
-from .nodes.AKProjectSettingsOut import NODE_CLASS_MAPPINGS as AKProjectSettingsOut_STATE_MAPPINGS
-from .nodes.AKProjectSettingsOut import NODE_DISPLAY_NAME_MAPPINGS as AKProjectSettingsOut_STATE_DISPLAY
-
-NODE_CLASS_MAPPINGS = {
- **AKIndexMultiple_MAPPINGS,
- **AKCLIPEncodeMultiple_MAPPINGS,
- **GROUPCHK_MAPPINGS,
- **RPSTATE_MAPPINGS,
- **PRTSTATE_MAPPINGS,
- **CLCSTATE_MAPPINGS,
- **CLCOMBINE_STATE_MAPPINGS,
- **AKBSTATE_MAPPINGS,
- **AKPIPESTATE_MAPPINGS,
- **AKPIPEL_STATE_MAPPINGS,
- **SETTERSTATE_MAPPINGS,
- **GETTERSTATE_MAPPINGS,
- **RESIZESTATE_MAPPINGS,
- **ISMSTATE_MAPPINGS,
- **AKSAT_STATE_MAPPINGS,
- **AKRALPHA_STATE_MAPPINGS,
- **AKRCOLOR_STATE_MAPPINGS,
- **AK_CONTROL_SAMPLERS_COLOR_STATE_MAPPINGS,
- **AKKSamplerSettings_STATE_MAPPINGS,
- **AKProjectSettingsOut_STATE_MAPPINGS,
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
- **AKIndexMultiple_DISPLAY,
- **AKCLIPEncodeMultiple_DISPLAY,
- **GROUPCHK_DISPLAY,
- **RPSTATE_DISPLAY,
- **PRTSTATE_DISPLAY,
- **CLCSTATE_DISPLAY,
- **CLCOMBINE_STATE_DISPLAY,
- **AKBSTATE_DISPLAY,
- **AKPIPESTATE_DISPLAY,
- **AKPIPEL_STATE_DISPLAY,
- **SETTERSTATE_DISPLAY,
- **GETTERSTATE_DISPLAY,
- **RESIZESTATE_DISPLAY,
- **ISMSTATE_DISPLAY,
- **AKSAT_STATE_DISPLAY,
- **AKRALPHA_STATE_DISPLAY,
- **AKRCOLOR_STATE_DISPLAY,
- **AK_CONTROL_SAMPLERS_COLOR_STATE_DISPLAY,
- **AKKSamplerSettings_STATE_DISPLAY,
- **AKProjectSettingsOut_STATE_DISPLAY,
-}
-
-__all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS", "WEB_DIRECTORY"]
diff --git a/custom_nodes/ComfyUI-AK-Pack/icon.jpg b/custom_nodes/ComfyUI-AK-Pack/icon.jpg
deleted file mode 100644
index afe5503b42b9edf670e59a602edae852969de3b9..0000000000000000000000000000000000000000
Binary files a/custom_nodes/ComfyUI-AK-Pack/icon.jpg and /dev/null differ
diff --git a/custom_nodes/ComfyUI-AK-Pack/nodes/AKBase.py b/custom_nodes/ComfyUI-AK-Pack/nodes/AKBase.py
deleted file mode 100644
index 704f74e6d3431f82cad931d330c67a26f8fa17ab..0000000000000000000000000000000000000000
--- a/custom_nodes/ComfyUI-AK-Pack/nodes/AKBase.py
+++ /dev/null
@@ -1,248 +0,0 @@
-
-# === AKXZ embedded JSON fallback (read from IMAGE tensors) ===
-import json as _akxz_json
-import torch as _akxz_torch
-
-_AKXZ_MAGIC = b"AKXZ"
-_AKXZ_HEADER_LEN = 8
-
-def _akxz_float01_to_bytes(x: _akxz_torch.Tensor) -> bytes:
- x = _akxz_torch.clamp(x * 255.0 + 0.5, 0, 255).to(_akxz_torch.uint8).cpu()
- return x.numpy().tobytes()
-
-def akxz_extract_image_cfg_list(images: _akxz_torch.Tensor):
- if not isinstance(images, _akxz_torch.Tensor) or images.ndim != 4:
- return []
- b = int(images.shape[0])
- out = []
- for i in range(b):
- row = images[i, 0, :, :3].reshape(-1)
- raw = _akxz_float01_to_bytes(row)
- if len(raw) < _AKXZ_HEADER_LEN or raw[:4] != _AKXZ_MAGIC:
- continue
- size = int.from_bytes(raw[4:8], "big")
- if size <= 0 or (8 + size) > len(raw):
- continue
- payload = raw[8:8+size]
- try:
- obj = _akxz_json.loads(payload.decode("utf-8"))
- if isinstance(obj, dict):
- out.append(obj)
- except Exception:
- pass
- return out
-
-
-import os
-import json
-
-import numpy as np
-from PIL import Image
-from PIL.PngImagePlugin import PngInfo
-
-import folder_paths
-
-
-AKBASE_STATE_FILENAME = "ak_base_state.json"
-AKBASE_XZ_CONFIG_FILENAME = "ak_base_xz_config.json"
-
-AKBASE_A_FILENAME = "ak_base_image_a.png"
-AKBASE_B_FILENAME = "ak_base_image_b.png"
-
-AKBASE_GALLERY_PREFIX = "ak_base_image_xy_"
-AKBASE_GALLERY_MAX = 512
-
-
-def _tensor_to_pil(img_tensor):
- arr = img_tensor.detach().cpu().numpy()
- arr = np.clip(arr * 255.0, 0, 255).astype(np.uint8)
- return Image.fromarray(arr)
-
-
-def _temp_dir():
- d = folder_paths.get_temp_directory()
- os.makedirs(d, exist_ok=True)
- return d
-
-
-def _temp_path(filename: str) -> str:
- return os.path.join(_temp_dir(), filename)
-
-
-def _save_temp_png(img_tensor, filename: str, meta: dict = None) -> None:
- img = _tensor_to_pil(img_tensor)
-
- pnginfo = None
- if isinstance(meta, dict) and meta:
- pnginfo = PngInfo()
- for k, v in meta.items():
- if v is None:
- v = ""
- pnginfo.add_text(str(k), str(v))
-
- img.save(_temp_path(filename), compress_level=4, pnginfo=pnginfo)
-
-def _safe_remove(filename: str) -> None:
- try:
- p = _temp_path(filename)
- if os.path.isfile(p):
- os.remove(p)
- except Exception:
- pass
-
-
-def _clear_gallery_files() -> None:
- d = _temp_dir()
- for fn in os.listdir(d):
- if fn.startswith(AKBASE_GALLERY_PREFIX) and fn.lower().endswith(".png"):
- try:
- os.remove(os.path.join(d, fn))
- except Exception:
- pass
-
-
-def _clear_compare_files() -> None:
- _safe_remove(AKBASE_A_FILENAME)
- _safe_remove(AKBASE_B_FILENAME)
-
-
-def _write_state(state: dict, filename: str = None) -> None:
- try:
- fn = filename if filename else AKBASE_STATE_FILENAME
- with open(_temp_path(fn), "w", encoding="utf-8") as f:
- json.dump(state, f, ensure_ascii=False)
- except Exception:
- pass
-
-
-class AKBase:
- @classmethod
- def INPUT_TYPES(cls):
- return {
- "required": {
- "a_image": ("IMAGE",),
- },
- "optional": {
- "b_image": ("IMAGE",),
- },
- "hidden": {
- "unique_id": "UNIQUE_ID",
- },
- }
-
- RETURN_TYPES = ()
- FUNCTION = "run"
- CATEGORY = "AK"
- OUTPUT_NODE = True
-
- def run(
- self,
- a_image,
- b_image=None,
- # ak_settings: str = None,
- unique_id=None,
- ):
- a_n = int(a_image.shape[0]) if hasattr(a_image, "shape") else 1
- b_n = int(b_image.shape[0]) if (b_image is not None and hasattr(b_image, "shape")) else 0
-
- ak_base_config = "{}"
-
- node_id = unique_id if unique_id is not None else getattr(self, "node_id", None)
- node_id = str(node_id) if node_id is not None else None
- suffix = f"_{node_id}" if node_id is not None else ""
-
-
- xz_fname = f"ak_base_xz_config{suffix}.json" if suffix else AKBASE_XZ_CONFIG_FILENAME
- try:
-
- content = "{}"
- cfg_list = []
- try:
- if (a_n > 1) or (b_n > 1):
- imgs = []
- if a_n > 1:
- imgs.extend([a_image[i] for i in range(min(a_n, AKBASE_GALLERY_MAX))])
- if b_n > 1 and b_image is not None:
- remaining = AKBASE_GALLERY_MAX - len(imgs)
- if remaining > 0:
- imgs.extend([b_image[i] for i in range(min(b_n, remaining))])
- if imgs:
- cfg_list = akxz_extract_image_cfg_list(_akxz_torch.stack(imgs, dim=0))
- else:
- cfg_list = akxz_extract_image_cfg_list(a_image)
- except Exception:
- cfg_list = []
-
- if cfg_list:
- content = json.dumps({"image": cfg_list}, ensure_ascii=False)
- with open(_temp_path(xz_fname), "w", encoding="utf-8") as f:
- f.write(content)
-
- except Exception:
- pass
-
- if a_n > 1 or b_n > 1:
- _clear_compare_files()
- if suffix:
- _safe_remove(f"ak_base_image_a{suffix}.png")
- _safe_remove(f"ak_base_image_b{suffix}.png")
- _clear_gallery_files()
-
- _save_temp_png(a_image[0], f"ak_base_image_a{suffix}.png" if suffix else AKBASE_A_FILENAME)
- if b_image is None:
- _save_temp_png(a_image[0], f"ak_base_image_b{suffix}.png" if suffix else AKBASE_B_FILENAME)
- else:
- _save_temp_png(b_image[0], f"ak_base_image_b{suffix}.png" if suffix else AKBASE_B_FILENAME)
-
- imgs = []
- if a_n > 1:
- imgs.extend([a_image[i] for i in range(min(a_n, AKBASE_GALLERY_MAX))])
-
- if b_n > 1 and b_image is not None:
- remaining = AKBASE_GALLERY_MAX - len(imgs)
- if remaining > 0:
- imgs.extend([b_image[i] for i in range(min(b_n, remaining))])
-
- gallery_prefix = f"{AKBASE_GALLERY_PREFIX}{node_id}_" if node_id is not None else AKBASE_GALLERY_PREFIX
- for i, t in enumerate(imgs):
- _save_temp_png(t, f"{gallery_prefix}{i}.png")
-
- _write_state(
- {
- "mode": "gallery",
- "count": len(imgs),
- "gallery_prefix": gallery_prefix,
- },
- filename=(f"ak_base_state{suffix}.json" if suffix else AKBASE_STATE_FILENAME),
- )
-
- return {"ui": {"ak_base_saved": [True]}, "result": (ak_base_config,)}
-
- _clear_gallery_files()
- if suffix:
- _safe_remove(f"ak_base_image_a{suffix}.png")
- _safe_remove(f"ak_base_image_b{suffix}.png")
-
- _save_temp_png(a_image[0], f"ak_base_image_a{suffix}.png" if suffix else AKBASE_A_FILENAME)
-
- if b_image is None:
- _save_temp_png(a_image[0], f"ak_base_image_b{suffix}.png" if suffix else AKBASE_B_FILENAME)
- else:
- _save_temp_png(b_image[0], f"ak_base_image_b{suffix}.png" if suffix else AKBASE_B_FILENAME)
-
- _write_state(
- {
- "mode": "compare",
- "a": {"filename": (f"ak_base_image_a{suffix}.png" if suffix else AKBASE_A_FILENAME), "type": "temp", "subfolder": ""},
- "b": {"filename": (f"ak_base_image_b{suffix}.png" if suffix else AKBASE_B_FILENAME), "type": "temp", "subfolder": ""},
- "preview_width": 512,
- "preview_height": 512,
- },
- filename=(f"ak_base_state{suffix}.json" if suffix else AKBASE_STATE_FILENAME),
- )
-
- return {"ui": {"ak_base_saved": [True]}, "result": (ak_base_config,)}
-
-
-NODE_CLASS_MAPPINGS = {"AK Base": AKBase}
-NODE_DISPLAY_NAME_MAPPINGS = {"AK Base": "AK Base"}
diff --git a/custom_nodes/ComfyUI-AK-Pack/nodes/AKCLIPEncodeMultiple.py b/custom_nodes/ComfyUI-AK-Pack/nodes/AKCLIPEncodeMultiple.py
deleted file mode 100644
index ce6f7f08f09e572adf2a4e2eb7255241cee59883..0000000000000000000000000000000000000000
--- a/custom_nodes/ComfyUI-AK-Pack/nodes/AKCLIPEncodeMultiple.py
+++ /dev/null
@@ -1,243 +0,0 @@
-import zlib
-
-
-class AnyType(str):
- def __ne__(self, __value: object) -> bool:
- return False
-
-
-ANY_TYPE = AnyType("*")
-
-
-class AKCLIPEncodeMultiple:
- empty_cache = {}
- # text_cache = {}
-
- last_items = None
- idx_cache = {}
- hash_cache = {}
-
- @classmethod
- def INPUT_TYPES(cls):
- return {
- "required": {
- "str_list": (ANY_TYPE, {"forceInput": False}),
- "clip": ("CLIP",),
- "starting_index": ("INT", {"default": 0, "min": 0, "step": 1}),
- "length": ("INT", {"default": 1, "min": 1, "max": 20, "step": 1}),
- },
- "optional": {
- "mask_list": ("MASK",),
- },
- }
-
- RETURN_TYPES = ("CONDITIONING",) + ("CONDITIONING",) * 20
- RETURN_NAMES = ("combined_con",) + tuple(f"cond_{i}" for i in range(20))
-
- FUNCTION = "execute"
- CATEGORY = "AK/conditioning"
- OUTPUT_NODE = False
-
- INPUT_IS_LIST = True
-
- @classmethod
- def _get_empty_cond(cls, clip):
- key = id(clip)
- cached = cls.empty_cache.get(key)
- if cached is not None:
- return cached
-
- tokens = clip.tokenize("")
- cond, pooled = clip.encode_from_tokens(tokens, return_pooled=True)
- empty = [[cond, {"pooled_output": pooled}]]
- cls.empty_cache[key] = empty
- return empty
-
- @classmethod
- def _encode_text(cls, clip, text):
- tokens = clip.tokenize(text)
- cond, pooled = clip.encode_from_tokens(tokens, return_pooled=True)
- return [[cond, {"pooled_output": pooled}]]
-
- @staticmethod
- def _clip_key(clip):
- inner = getattr(clip, "cond_stage_model", None)
- if inner is not None:
- return id(inner)
- inner = getattr(clip, "clip", None) or getattr(clip, "model", None)
- if inner is not None:
- return id(inner)
- return id(clip)
-
- @staticmethod
- def _apply_mask_to_cond(base_cond, mask):
- if mask is None:
- return base_cond
- cond_with_mask = []
- for t, data in base_cond:
- data_copy = dict(data) if data is not None else {}
- data_copy["mask"] = mask
- data_copy["mask_strength"] = 1.0
- cond_with_mask.append([t, data_copy])
- return cond_with_mask
-
- @classmethod
- def _compute_hash(cls, items, masks, start, length):
- max_bytes = 64 * 1024
- buf = bytearray()
-
- def add_bytes(b):
- nonlocal buf
- if not b:
- return
- remaining = max_bytes - len(buf)
- if remaining <= 0:
- return
- if len(b) > remaining:
- buf.extend(b[:remaining])
- else:
- buf.extend(b)
-
- for v in items:
- s = "" if v is None else v
- add_bytes(s.encode("utf-8", errors="ignore") + b"\n")
- if len(buf) >= max_bytes:
- break
-
- if len(buf) < max_bytes and masks:
- for m in masks:
- if m is None:
- add_bytes(b"MNONE\n")
- else:
- try:
- t = m
- if isinstance(t, (list, tuple)):
- t = t[0]
- if hasattr(t, "detach"):
- t = t.detach()
- arr = t.cpu().contiguous().numpy()
- add_bytes(arr.tobytes())
- except Exception:
- add_bytes(repr(type(m)).encode("utf-8", errors="ignore"))
- if len(buf) >= max_bytes:
- break
-
- add_bytes(f"|start={start}|len={length}".encode("ascii"))
-
- return zlib.adler32(bytes(buf)) & 0xFFFFFFFF
-
- def execute(self, clip, str_list, starting_index, length, mask_list=None):
- if isinstance(clip, (list, tuple)):
- clip_obj = clip[0]
- else:
- clip_obj = clip
-
- if isinstance(str_list, (list, tuple)):
- if len(str_list) == 1 and isinstance(str_list[0], (list, tuple)):
- items = list(str_list[0])
- else:
- items = list(str_list)
- else:
- items = [str_list]
-
- if not isinstance(items, list) or not all(
- (isinstance(v, str) or v is None) for v in items
- ):
- raise RuntimeError("Require array of strings")
-
- masks = []
- if mask_list is not None:
- if isinstance(mask_list, (list, tuple)):
- if len(mask_list) == 1 and isinstance(mask_list[0], (list, tuple)):
- masks = list(mask_list[0])
- else:
- masks = list(mask_list)
- else:
- masks = [mask_list]
-
- if isinstance(starting_index, (list, tuple)):
- start_raw = starting_index[0] if starting_index else 0
- else:
- start_raw = starting_index
-
- if isinstance(length, (list, tuple)):
- length_raw = length[0] if length else 1
- else:
- length_raw = length
-
- start = max(0, int(start_raw))
- length_val = max(1, min(20, int(length_raw)))
-
- if AKCLIPEncodeMultiple.last_items is None or len(AKCLIPEncodeMultiple.last_items) != len(items):
- AKCLIPEncodeMultiple.last_items = [None] * len(items)
- AKCLIPEncodeMultiple.idx_cache.clear()
-
- clip_id = self._clip_key(clip_obj)
- items_copy = list(items)
- masks_copy = list(masks) if masks else []
- hval = self._compute_hash(items_copy, masks_copy, start, length_val)
- cache_key = (clip_id, hval)
-
- cached_entry = AKCLIPEncodeMultiple.hash_cache.get(cache_key)
- if cached_entry is not None:
- combined_cached, per_idx_cached = cached_entry
- per_idx_cached = list(per_idx_cached)
- if len(per_idx_cached) < 20:
- per_idx_cached.extend([None] * (20 - len(per_idx_cached)))
- elif len(per_idx_cached) > 20:
- per_idx_cached = per_idx_cached[:20]
- return (combined_cached,) + tuple(per_idx_cached)
-
- result = []
- empty_cond = None
- combined_cond = None
-
- for i in range(length_val):
- idx = start + i
-
- cond = None
- if 0 <= idx < len(items):
- v = items[idx]
-
- mask_for_idx = None
- if 0 <= idx < len(masks):
- mask_for_idx = masks[idx]
-
- if v is None:
- if empty_cond is None:
- empty_cond = self._get_empty_cond(clip_obj)
- base_cond = empty_cond
- AKCLIPEncodeMultiple.last_items[idx] = None
- else:
- prev = AKCLIPEncodeMultiple.last_items[idx]
- if v == prev:
- cached = AKCLIPEncodeMultiple.idx_cache.get((clip_id, idx))
- if cached is not None:
- base_cond = cached
- else:
- base_cond = self._encode_text(clip_obj, v)
- AKCLIPEncodeMultiple.idx_cache[(clip_id, idx)] = base_cond
- else:
- base_cond = self._encode_text(clip_obj, v)
- AKCLIPEncodeMultiple.idx_cache[(clip_id, idx)] = base_cond
- AKCLIPEncodeMultiple.last_items[idx] = v
- cond = self._apply_mask_to_cond(base_cond, mask_for_idx)
- if v is not None and cond is not None:
- if combined_cond is None:
- combined_cond = []
- for t, data in cond:
- data_copy = dict(data) if data is not None else {}
- combined_cond.append([t, data_copy])
-
- result.append(cond)
-
- if length_val < 20:
- result.extend([None] * (20 - length_val))
-
- AKCLIPEncodeMultiple.hash_cache[cache_key] = (combined_cond, list(result))
-
- return (combined_cond,) + tuple(result)
-
-
-NODE_CLASS_MAPPINGS = {"AKCLIPEncodeMultiple": AKCLIPEncodeMultiple}
-NODE_DISPLAY_NAME_MAPPINGS = {"AKCLIPEncodeMultiple": "AK CLIP Encode Multiple"}
diff --git a/custom_nodes/ComfyUI-AK-Pack/nodes/AKContrastAndSaturateImage.py b/custom_nodes/ComfyUI-AK-Pack/nodes/AKContrastAndSaturateImage.py
deleted file mode 100644
index 55229991b4595b503b982c92d36222754744cea0..0000000000000000000000000000000000000000
--- a/custom_nodes/ComfyUI-AK-Pack/nodes/AKContrastAndSaturateImage.py
+++ /dev/null
@@ -1,281 +0,0 @@
-import torch
-import numpy as np
-from PIL import Image
-
-# Hue band definitions (soft ranges in degrees)
-FEATHER_DEG = 15.0
-
-RED_RANGES_SOFT = [(315.0, 345.0), (15.0, 45.0)]
-YELLOW_RANGES_SOFT = [(15.0, 45.0), (75.0, 105.0)]
-GREEN_RANGES_SOFT = [(75.0, 105.0), (135.0, 165.0)]
-CYAN_RANGES_SOFT = [(135.0, 165.0), (195.0, 225.0)]
-BLUE_RANGES_SOFT = [(195.0, 225.0), (225.0, 285.0)]
-MAGENTA_RANGES_SOFT = [(255.0, 285.0), (315.0, 345.0)]
-
-
-def _compute_band_weight(h_deg: np.ndarray, ranges_soft):
- """Compute per-pixel weight for a hue band with soft feathered edges."""
- if h_deg.ndim != 2:
- raise ValueError("Expected 2D hue array")
-
- weight_total = np.zeros_like(h_deg, dtype=np.float32)
-
- for start_soft, end_soft in ranges_soft:
- width = end_soft - start_soft
- if width <= 0.0:
- continue
-
- feather = min(FEATHER_DEG, width * 0.5)
- start_hard = start_soft + feather
- end_hard = end_soft - feather
-
- seg_weight = np.zeros_like(h_deg, dtype=np.float32)
-
- # Fully inside hard region
- inside_hard = (h_deg >= start_hard) & (h_deg <= end_hard)
- seg_weight[inside_hard] = 1.0
-
- # Soft rising edge
- if feather > 0.0:
- rising = (h_deg >= start_soft) & (h_deg < start_hard)
- seg_weight[rising] = (h_deg[rising] - start_soft) / feather
-
- falling = (h_deg > end_hard) & (h_deg <= end_soft)
- seg_weight[falling] = (end_soft - h_deg[falling]) / feather
-
- weight_total = np.maximum(weight_total, seg_weight)
-
- return weight_total
-
-
-def _slider_to_factor(value: int) -> float:
- """Convert slider value in [-100, 100] to saturation multiplier."""
- v = float(value)
- return max(0.0, 1.0 + v / 100.0)
-
-def _apply_brightness_contrast_rgb01(frame: np.ndarray, brightness: int, contrast: int) -> np.ndarray:
- """Apply brightness and contrast to an RGB image in [0,1] float32 format."""
- out = frame.astype(np.float32, copy=False)
-
- if brightness != 0:
- out = out + (float(brightness) / 100.0)
-
- if contrast != 0:
- factor = 1.0 + (float(contrast) / 100.0)
- out = (out - 0.5) * factor + 0.5
-
- return np.clip(out, 0.0, 1.0)
-
-
-
-class AKContrastAndSaturateImage:
- @classmethod
- def INPUT_TYPES(cls):
- return {
- "required": {
- "image": ("IMAGE",),
- "brightness": (
- "INT",
- {
- "default": 0,
- "min": -100,
- "max": 100,
- "step": 1,
- },
- ),
- "contrast": (
- "INT",
- {
- "default": 0,
- "min": -100,
- "max": 100,
- "step": 1,
- },
- ),
- "master": (
- "INT",
- {
- "default": 0,
- "min": -100,
- "max": 100,
- "step": 1,
- },
- ),
- "reds": (
- "INT",
- {
- "default": 0,
- "min": -100,
- "max": 100,
- "step": 1,
- },
- ),
- "yellows": (
- "INT",
- {
- "default": 0,
- "min": -100,
- "max": 100,
- "step": 1,
- },
- ),
- "greens": (
- "INT",
- {
- "default": 0,
- "min": -100,
- "max": 100,
- "step": 1,
- },
- ),
- "cyans": (
- "INT",
- {
- "default": 0,
- "min": -100,
- "max": 100,
- "step": 1,
- },
- ),
- "blues": (
- "INT",
- {
- "default": 0,
- "min": -100,
- "max": 100,
- "step": 1,
- },
- ),
- "magentas": (
- "INT",
- {
- "default": 0,
- "min": -100,
- "max": 100,
- "step": 1,
- },
- ),
- }
- }
-
- RETURN_TYPES = ("IMAGE",)
- RETURN_NAMES = ("image",)
- FUNCTION = "apply"
- CATEGORY = "AK/image"
-
- def apply(
- self,
- image: torch.Tensor,
- brightness: int,
- contrast: int,
- master: int,
- reds: int,
- yellows: int,
- greens: int,
- cyans: int,
- blues: int,
- magentas: int,
- ):
- if not isinstance(image, torch.Tensor):
- raise TypeError("Expected image as torch.Tensor")
-
- if image.ndim != 4 or image.shape[-1] != 3:
- raise ValueError("Expected image with shape [B, H, W, 3]")
-
- if (
- brightness == 0
- and contrast == 0
- and master == 0
- and reds == 0
- and yellows == 0
- and greens == 0
- and cyans == 0
- and blues == 0
- and magentas == 0
- ):
- return (image,)
-
- device = image.device
- batch_size, h, w, c = image.shape
-
- img_np = image.detach().cpu().numpy()
- out_list = []
-
- master_factor = _slider_to_factor(master)
- reds_factor = _slider_to_factor(reds)
- yellows_factor = _slider_to_factor(yellows)
- greens_factor = _slider_to_factor(greens)
- cyans_factor = _slider_to_factor(cyans)
- blues_factor = _slider_to_factor(blues)
- magentas_factor = _slider_to_factor(magentas)
-
- for i in range(batch_size):
- frame = img_np[i]
-
- if brightness != 0 or contrast != 0:
- frame = _apply_brightness_contrast_rgb01(frame, brightness, contrast)
-
- frame_u8 = (frame * 255.0).clip(0, 255).astype(np.uint8)
-
- pil_rgb = Image.fromarray(frame_u8, mode="RGB")
- pil_hsv = pil_rgb.convert("HSV")
- hsv = np.array(pil_hsv, dtype=np.uint8)
-
- H = hsv[..., 0].astype(np.float32)
- S = hsv[..., 1].astype(np.float32)
- V = hsv[..., 2]
-
- h_deg = H * (360.0 / 255.0)
-
- # Base master factor
- S = S * master_factor
-
- # Per-band masks
- reds_w = _compute_band_weight(h_deg, RED_RANGES_SOFT)
- yellows_w = _compute_band_weight(h_deg, YELLOW_RANGES_SOFT)
- greens_w = _compute_band_weight(h_deg, GREEN_RANGES_SOFT)
- cyans_w = _compute_band_weight(h_deg, CYAN_RANGES_SOFT)
- blues_w = _compute_band_weight(h_deg, BLUE_RANGES_SOFT)
- magentas_w = _compute_band_weight(h_deg, MAGENTA_RANGES_SOFT)
-
- # Sequential multiplicative adjustments
- def apply_band(S_arr, weight, factor):
- if factor == 1.0:
- return S_arr
- band_scale = 1.0 + weight * (factor - 1.0)
- return S_arr * band_scale
-
- S = apply_band(S, reds_w, reds_factor)
- S = apply_band(S, yellows_w, yellows_factor)
- S = apply_band(S, greens_w, greens_factor)
- S = apply_band(S, cyans_w, cyans_factor)
- S = apply_band(S, blues_w, blues_factor)
- S = apply_band(S, magentas_w, magentas_factor)
-
- S = np.clip(S, 0.0, 255.0).astype(np.uint8)
-
- hsv_new = np.stack(
- [
- H.astype(np.uint8),
- S,
- V.astype(np.uint8),
- ],
- axis=-1,
- )
-
- pil_hsv_new = Image.fromarray(hsv_new, mode="HSV")
- pil_rgb_new = pil_hsv_new.convert("RGB")
- rgb_np = np.array(pil_rgb_new).astype(np.float32) / 255.0
- out_list.append(rgb_np)
-
- out_np = np.stack(out_list, axis=0)
- out_tensor = torch.from_numpy(out_np).to(device)
- return (out_tensor,)
-
-
-NODE_CLASS_MAPPINGS = {
- "AKContrastAndSaturateImage": AKContrastAndSaturateImage,
-}
-NODE_DISPLAY_NAME_MAPPINGS = {
- "AKContrastAndSaturateImage": "AK Contrast & Saturate Image",
-}
diff --git a/custom_nodes/ComfyUI-AK-Pack/nodes/AKControlMultipleKSamplers.py b/custom_nodes/ComfyUI-AK-Pack/nodes/AKControlMultipleKSamplers.py
deleted file mode 100644
index caf6591e4ff134c1f684b8bb4624aa67ccb3f058..0000000000000000000000000000000000000000
--- a/custom_nodes/ComfyUI-AK-Pack/nodes/AKControlMultipleKSamplers.py
+++ /dev/null
@@ -1,46 +0,0 @@
-import comfy.samplers
-
-class AKControlMultipleKSamplers:
- """
- UI-only control node (no outputs). Frontend JS drives synchronization.
- """
-
- @classmethod
- def INPUT_TYPES(cls):
- return {
- "required": {
- "choose_ksampler": ([" 0 ? 'mt-12' : ''}`}>
- {/* 已上传图片预览 */}
- {uploadedImages.length > 0 && (
-
- {uploadedImages.map(image => (
-
- )}
-
-
- 
- {
- !!image?.url && image?.url !== '' ? :
- ))}
-
-
-
-