324 lines
14 KiB
Python
324 lines
14 KiB
Python
"""Generic image utilities for ComfyUI."""
|
|
|
|
import os
|
|
import json
|
|
import re
|
|
import threading
|
|
import time
|
|
import uuid
|
|
from collections import OrderedDict
|
|
from pathlib import Path
|
|
|
|
from PIL import Image
|
|
|
|
import folder_paths
|
|
|
|
|
|
_IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".webp", ".bmp", ".gif", ".tif", ".tiff"}
|
|
_SERVE_TOKENS = OrderedDict()
|
|
_SAVE_COUNTER_LOCK = threading.Lock()
|
|
|
|
|
|
def resolve_serve_token(token):
|
|
return _SERVE_TOKENS.get(str(token or ""))
|
|
|
|
|
|
def _folder_is_image(name):
|
|
return Path(str(name)).suffix.lower() in _IMAGE_EXTENSIONS
|
|
|
|
|
|
def _list_folder_image_files(real_folder, recursive=False):
|
|
root = Path(real_folder)
|
|
paths = root.rglob("*") if recursive else root.glob("*")
|
|
files = []
|
|
for path in paths:
|
|
if path.is_file() and _folder_is_image(path.name):
|
|
files.append({
|
|
"file": str(path.relative_to(root)).replace(os.sep, "/"),
|
|
"mtime": path.stat().st_mtime,
|
|
})
|
|
return sorted(files, key=lambda item: item["file"].lower())
|
|
|
|
|
|
def _next_counter_for_relative_path(base_directory, relative_template):
|
|
relative_template = str(relative_template).replace("\\", "/")
|
|
if "%counter%" not in relative_template:
|
|
return 1
|
|
base = Path(base_directory)
|
|
if not base.exists():
|
|
return 1
|
|
pattern = re.compile(
|
|
re.escape(relative_template).replace(re.escape("%counter%"), r"(\d+)")
|
|
)
|
|
highest = 0
|
|
for path in base.rglob("*"):
|
|
if not path.is_file():
|
|
continue
|
|
relative_path = path.relative_to(base).as_posix()
|
|
match = pattern.fullmatch(relative_path)
|
|
if match:
|
|
highest = max(highest, int(match.group(1)))
|
|
return highest + 1
|
|
|
|
|
|
def _next_available_relative_path(base_directory, relative_path):
|
|
"""Return a collision-free relative path, adding a counter when needed."""
|
|
relative_path = str(relative_path).replace("\\", "/")
|
|
if "%counter%" in relative_path:
|
|
counter = _next_counter_for_relative_path(base_directory, relative_path)
|
|
return relative_path.replace("%counter%", str(counter).zfill(3))
|
|
|
|
candidate = Path(base_directory) / Path(relative_path)
|
|
if not candidate.exists():
|
|
return relative_path
|
|
|
|
path = Path(relative_path)
|
|
suffix = path.suffix
|
|
name = path.name[:-len(suffix)] if suffix else path.name
|
|
counter_template = str(path.with_name(f"{name}_%counter%{suffix}")).replace("\\", "/")
|
|
counter = _next_counter_for_relative_path(base_directory, counter_template)
|
|
return counter_template.replace("%counter%", str(counter).zfill(3))
|
|
|
|
|
|
def _image_to_pil(image):
|
|
array = image.detach().cpu().numpy() if hasattr(image, "detach") else image.cpu().numpy()
|
|
array = (array[..., :3].clip(0, 1) * 255).astype("uint8")
|
|
return Image.fromarray(array)
|
|
|
|
|
|
def _is_within_directory(parent, child):
|
|
try:
|
|
return os.path.commonpath([os.path.realpath(parent), os.path.realpath(child)]) == os.path.realpath(parent)
|
|
except ValueError:
|
|
return False
|
|
|
|
|
|
def _build_pnginfo(prompt=None, extra_pnginfo=None):
|
|
if not prompt and not extra_pnginfo:
|
|
return None
|
|
from PIL.PngImagePlugin import PngInfo
|
|
info = PngInfo()
|
|
if prompt is not None:
|
|
info.add_text("prompt", json.dumps(prompt, ensure_ascii=False))
|
|
for key, value in (extra_pnginfo or {}).items():
|
|
info.add_text(str(key), json.dumps(value, ensure_ascii=False))
|
|
return info
|
|
|
|
|
|
class DumasImageCompareNode:
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {"optional": {"image1": ("IMAGE",), "image2": ("IMAGE",)}}
|
|
|
|
RETURN_TYPES = ("IMAGE",)
|
|
RETURN_NAMES = ("result",)
|
|
FUNCTION = "compare_images"
|
|
CATEGORY = "Dumas/Image"
|
|
OUTPUT_NODE = True
|
|
|
|
def compare_images(self, image1=None, image2=None):
|
|
images = []
|
|
for slot, image in enumerate((image1, image2), 1):
|
|
if image is None:
|
|
continue
|
|
# The compare viewer can be used by several executions at once.
|
|
# Fixed filenames caused one run to replace another run's preview.
|
|
path = Path(folder_paths.get_temp_directory()) / f"dumas_compare_{uuid.uuid4().hex}_{slot}.png"
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
_image_to_pil(image[0]).save(path)
|
|
images.append({"filename": path.name, "subfolder": "", "type": "temp", "slot": slot})
|
|
return {"ui": {"images": images}, "result": (image2 or image1,)}
|
|
|
|
|
|
class DumasSaveImageNode:
|
|
DESCRIPTION = "Save image batches with collision-safe names and ComfyUI previews."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {
|
|
"required": {
|
|
"images": ("IMAGE",),
|
|
"folder": ("STRING", {"default": ""}),
|
|
"pattern": ("STRING", {"default": "image_%counter%"}),
|
|
"format": (["png", "jpg", "webp"], {"default": "png"}),
|
|
"quality": ("INT", {"default": 95, "min": 1, "max": 100}),
|
|
"embed_workflow": ("BOOLEAN", {"default": True}),
|
|
"save_on_run": ("BOOLEAN", {"default": True}),
|
|
},
|
|
"optional": {"name": ("STRING", {"default": ""}), "name_2": ("STRING", {"default": ""})},
|
|
"hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO"},
|
|
}
|
|
|
|
@classmethod
|
|
def IS_CHANGED(cls, **_kwargs):
|
|
return float("nan")
|
|
|
|
RETURN_TYPES = ()
|
|
FUNCTION = "save_images"
|
|
CATEGORY = "Dumas/Image"
|
|
OUTPUT_NODE = True
|
|
|
|
def save_images(self, images, folder, pattern, format, quality, embed_workflow, save_on_run,
|
|
name="", name_2="", prompt=None, extra_pnginfo=None, **_kwargs):
|
|
if not save_on_run:
|
|
# Match the preview/save split used by Pixaroma: Preview mode must
|
|
# still produce visible, temporary images, but must not write to
|
|
# the selected destination folder.
|
|
temp_dir = Path(folder_paths.get_temp_directory()).resolve()
|
|
temp_dir.mkdir(parents=True, exist_ok=True)
|
|
preview_images = []
|
|
preview_format = str(format or "png").lower()
|
|
extension = ".jpg" if preview_format == "jpg" else (
|
|
".webp" if preview_format == "webp" else ".png"
|
|
)
|
|
for index, image in enumerate(images):
|
|
path = temp_dir / f"dumas_save_preview_{uuid.uuid4().hex}{extension}"
|
|
pil = _image_to_pil(image)
|
|
if preview_format == "jpg":
|
|
pil.convert("RGB").save(path, "JPEG", quality=max(1, min(100, int(quality))))
|
|
elif preview_format == "webp":
|
|
pil.save(path, "WEBP", quality=max(1, min(100, int(quality))))
|
|
else:
|
|
pil.save(path, "PNG", pnginfo=_build_pnginfo(prompt, extra_pnginfo) if embed_workflow else None)
|
|
preview_images.append({"filename": path.name, "subfolder": "", "type": "temp"})
|
|
return {"ui": {"images": preview_images}}
|
|
output_dir = Path(folder_paths.get_output_directory()).resolve()
|
|
base = Path(folder).expanduser().resolve() if str(folder or "").strip() else output_dir
|
|
base.mkdir(parents=True, exist_ok=True)
|
|
ui_images = []
|
|
extension = ".jpg" if format == "jpg" else f".{format}"
|
|
# Counter selection and the corresponding writes must be one critical
|
|
# section. Without this, overlapping ComfyUI executions can both see
|
|
# the same highest existing counter and overwrite one another.
|
|
with _SAVE_COUNTER_LOCK:
|
|
for index, image in enumerate(images):
|
|
width, height = int(image.shape[2]), int(image.shape[1])
|
|
stem = str(pattern or "image_%counter%")
|
|
stem = stem.replace("%input%", _safe_token(name)).replace("%input2%", _safe_token(name_2))
|
|
stem = stem.replace("%width%", str(width)).replace("%height%", str(height)).replace("%batch_num%", str(index))
|
|
relative = stem.replace("\\", "/") + extension
|
|
relative = _next_available_relative_path(str(base), relative)
|
|
path = base / Path(relative)
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
pil = _image_to_pil(image)
|
|
if format == "jpg":
|
|
pil.convert("RGB").save(path, "JPEG", quality=max(1, min(100, int(quality))))
|
|
elif format == "webp":
|
|
pil.save(path, "WEBP", quality=max(1, min(100, int(quality))))
|
|
else:
|
|
pil.save(path, "PNG", pnginfo=_build_pnginfo(prompt, extra_pnginfo) if embed_workflow else None)
|
|
if _is_within_directory(str(output_dir), str(path)):
|
|
subfolder = str(path.parent.relative_to(output_dir)).replace(os.sep, "/")
|
|
ui_images.append({"filename": path.name, "subfolder": "" if subfolder == "." else subfolder, "type": "output"})
|
|
else:
|
|
token = uuid.uuid4().hex
|
|
_SERVE_TOKENS[token] = str(path)
|
|
ui_images.append({"filename": path.name, "subfolder": str(path.parent).replace(os.sep, "/"), "type": "external", "token": token})
|
|
return {"ui": {"images": ui_images}}
|
|
|
|
|
|
def _safe_token(value):
|
|
return re.sub(r"[^A-Za-z0-9_.-]+", "_", Path(str(value or "")).stem).strip("._")
|
|
|
|
|
|
class DumasLoadImagesFolderNode:
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
# The browser UI stores its complete selection in this hidden input.
|
|
# Keep an optional folder for old workflows which used the original
|
|
# single-folder widget before the Pixaroma-style picker was added.
|
|
return {
|
|
"optional": {"folder": ("STRING", {"default": ""})},
|
|
"hidden": {"LoadImagesFolderState": ("STRING", {"default": ""})},
|
|
}
|
|
|
|
RETURN_TYPES = ("IMAGE", "MASK", "INT", "INT", "STRING", "INT", "INT", "STRING")
|
|
RETURN_NAMES = ("image", "mask", "width", "height", "filename", "index", "total", "path")
|
|
OUTPUT_IS_LIST = (True, True, True, True, True, True, True, True)
|
|
FUNCTION = "load"
|
|
CATEGORY = "Dumas/Image"
|
|
|
|
def load(self, folder="", LoadImagesFolderState="", **_kwargs):
|
|
state = {}
|
|
if LoadImagesFolderState:
|
|
try:
|
|
state = json.loads(LoadImagesFolderState)
|
|
except (TypeError, ValueError):
|
|
state = {}
|
|
|
|
selected_folder = str(state.get("folder") or folder or "").strip()
|
|
root = Path(selected_folder).expanduser()
|
|
if not root.is_dir():
|
|
raise ValueError("Selected image folder does not exist.")
|
|
|
|
recursive = bool(state.get("recursive", False))
|
|
candidates = [Path(item["file"]) for item in _list_folder_image_files(str(root), recursive)]
|
|
by_relative = {path.as_posix(): path for path in candidates}
|
|
selected = [str(value).replace("\\", "/") for value in (state.get("selected") or [])]
|
|
mode = str(state.get("selection_mode") or "selected")
|
|
|
|
if state:
|
|
if mode == "all":
|
|
relative_files = [path.as_posix() for path in candidates]
|
|
elif mode == "first_n":
|
|
try:
|
|
count = max(0, int(state.get("first_n", 0)))
|
|
except (TypeError, ValueError):
|
|
count = 0
|
|
relative_files = [path.as_posix() for path in candidates[:count]]
|
|
elif mode == "random":
|
|
import random
|
|
relative_files = [random.choice([path.as_posix() for path in candidates])] if candidates else []
|
|
else:
|
|
relative_files = [value for value in selected if value in by_relative]
|
|
else:
|
|
# Legacy workflows without the hidden state load the whole folder.
|
|
relative_files = [path.as_posix() for path in candidates]
|
|
|
|
if not relative_files:
|
|
raise ValueError("No images selected in the folder.")
|
|
|
|
sort_name = str(state.get("sort") or "name")
|
|
reverse = str(state.get("sort_dir") or "asc").lower() == "desc"
|
|
if sort_name == "date":
|
|
relative_files.sort(key=lambda name: (root / name).stat().st_mtime, reverse=reverse)
|
|
else:
|
|
relative_files.sort(key=str.lower, reverse=reverse)
|
|
|
|
import numpy as np
|
|
import torch
|
|
images, masks, widths, heights, names, indexes, totals, paths = [], [], [], [], [], [], [], []
|
|
total = len(relative_files)
|
|
for index, relative in enumerate(relative_files):
|
|
path = (root / relative).resolve()
|
|
if not _is_within_directory(root, path) or not path.is_file():
|
|
continue
|
|
with Image.open(path) as source:
|
|
source = source.convert("RGBA")
|
|
rgba = np.asarray(source).astype("float32") / 255.0
|
|
image = torch.from_numpy(rgba[..., :3].copy())[None, ...]
|
|
mask = torch.from_numpy((1.0 - rgba[..., 3]).copy())
|
|
images.append(image)
|
|
masks.append(mask)
|
|
widths.append(int(source.width))
|
|
heights.append(int(source.height))
|
|
names.append(path.name)
|
|
indexes.append(index)
|
|
totals.append(total)
|
|
paths.append(str(path))
|
|
if not images:
|
|
raise ValueError("No readable images were found in the selected folder.")
|
|
return images, masks, widths, heights, names, indexes, totals, paths
|
|
|
|
|
|
NODE_CLASS_MAPPINGS = {
|
|
"DumasImageCompare": DumasImageCompareNode,
|
|
"DumasSaveImage": DumasSaveImageNode,
|
|
"DumasLoadImagesFolder": DumasLoadImagesFolderNode,
|
|
}
|
|
|
|
NODE_DISPLAY_NAME_MAPPINGS = {
|
|
"DumasImageCompare": "Dumas Image Compare",
|
|
"DumasSaveImage": "Save Image Dumas",
|
|
"DumasLoadImagesFolder": "Load Images from Folder Dumas",
|
|
}
|