Mirror from https://github.com/MinorBoy/ComfyUI_essentials_mb

.github/workflows/publish.yml

@@ -0,0 +1,24 @@
+name: Publish to Comfy registry
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+    paths:
+      - "pyproject.toml"
+
+permissions:
+  issues: write
+
+jobs:
+  publish-node:
+    name: Publish Custom Node to registry
+    runs-on: ubuntu-latest
+    if: ${{ github.repository_owner == 'MinorBoy' }}
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+      - name: Publish Custom Node
+        uses: Comfy-Org/publish-node-action@v1
+        with:
+          personal_access_token: ${{ secrets.REGISTRY_ACCESS_TOKEN }}

.gitignore

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

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 mboy
+
+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.

README.md

@@ -0,0 +1,14 @@
+
+# ComfyUI Essentials mb
+
+## Change
+
+1. Add `alpha` and `background_alpha` to `🔧 Draw Text` node, let you can set the alpha of the text and the background.
+
+
+## About
+
+This repo fork from [ComfyUI_essentials](https://github.com/cubiq/ComfyUI_essentials)
+
+Thanks to [cubiq](https://github.com/cubiq) for the original repo.
+

__init__.py

@@ -0,0 +1,36 @@
+#from .essentials_mb 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"]

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

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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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",
+}

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

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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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_mb"
+
+    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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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_mb/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",
+}

js/DisplayAny.js

@@ -0,0 +1,36 @@
+import { app } from "../../scripts/app.js";
+import { ComfyWidgets } from "../../scripts/widgets.js";
+
+app.registerExtension({
+    name: "essentials_mb.DisplayAny",
+    async beforeRegisterNodeDef(nodeType, nodeData, app) {
+        if (!nodeData?.category?.startsWith("essentials_mb")) {
+            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("");
+            };
+        }
+    },
+});

js/FluxAttentionSeeker.js

@@ -0,0 +1,133 @@
+import { app } from "../../scripts/app.js";
+
+app.registerExtension({
+    name: "essentials_mb.FluxAttentionSeeker",
+    async beforeRegisterNodeDef(nodeType, nodeData, app) {
+        if (!nodeData?.category?.startsWith("essentials_mb")) {
+            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_mb.SD3AttentionSeekerLG",
+    async beforeRegisterNodeDef(nodeType, nodeData, app) {
+        if (!nodeData?.category?.startsWith("essentials_mb")) {
+            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_mb.SD3AttentionSeekerT5",
+    async beforeRegisterNodeDef(nodeType, nodeData, app) {
+        if (!nodeData?.category?.startsWith("essentials_mb")) {
+            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;
+                        }
+                    });
+                });
+            };
+        }
+    },
+});

mask.py

@@ -0,0 +1,596 @@
+from nodes import SaveImage
+import torch
+import torchvision.transforms.v2 as T
+import random
+import folder_paths
+import comfy.utils
+from .image import ImageExpandBatch
+from .utils import AnyType
+import numpy as np
+import scipy
+from PIL import Image
+from nodes import MAX_RESOLUTION
+import math
+
+any = AnyType("*")
+
+class MaskBlur:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "mask": ("MASK",),
+                "amount": ("INT", { "default": 6, "min": 0, "max": 256, "step": 1, }),
+                "device": (["auto", "cpu", "gpu"],),
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/mask"
+
+    def execute(self, mask, amount, device):
+        if amount == 0:
+            return (mask,)
+
+        if "gpu" == device:
+            mask = mask.to(comfy.model_management.get_torch_device())
+        elif "cpu" == device:
+            mask = mask.to('cpu')
+
+        if amount % 2 == 0:
+            amount+= 1
+
+        if mask.dim() == 2:
+            mask = mask.unsqueeze(0)
+
+        mask = T.functional.gaussian_blur(mask.unsqueeze(1), amount).squeeze(1)
+
+        if "gpu" == device or "cpu" == device:
+            mask = mask.to(comfy.model_management.intermediate_device())
+
+        return(mask,)
+
+class MaskFlip:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "mask": ("MASK",),
+                "axis": (["x", "y", "xy"],),
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/mask"
+
+    def execute(self, mask, axis):
+        if mask.dim() == 2:
+            mask = mask.unsqueeze(0)
+
+        dim = ()
+        if "y" in axis:
+            dim += (1,)
+        if "x" in axis:
+            dim += (2,)
+        mask = torch.flip(mask, dims=dim)
+
+        return(mask,)
+
+class MaskPreview(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 = 4
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {"mask": ("MASK",), },
+            "hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO"},
+        }
+
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/mask"
+
+    def execute(self, mask, filename_prefix="ComfyUI", prompt=None, extra_pnginfo=None):
+        preview = mask.reshape((-1, 1, mask.shape[-2], mask.shape[-1])).movedim(1, -1).expand(-1, -1, -1, 3)
+        return self.save_images(preview, filename_prefix, prompt, extra_pnginfo)
+
+class MaskBatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "mask1": ("MASK",),
+                "mask2": ("MASK",),
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/mask batch"
+
+    def execute(self, mask1, mask2):
+        if mask1.shape[1:] != mask2.shape[1:]:
+            mask2 = comfy.utils.common_upscale(mask2.unsqueeze(1).expand(-1,3,-1,-1), mask1.shape[2], mask1.shape[1], upscale_method='bicubic', crop='center')[:,0,:,:]
+
+        return (torch.cat((mask1, mask2), dim=0),)
+
+class MaskExpandBatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "mask": ("MASK",),
+                "size": ("INT", { "default": 16, "min": 1, "step": 1, }),
+                "method": (["expand", "repeat all", "repeat first", "repeat last"],)
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/mask batch"
+
+    def execute(self, mask, size, method):
+        return (ImageExpandBatch().execute(mask.unsqueeze(1).expand(-1,3,-1,-1), size, method)[0][:,0,:,:],)
+
+
+class MaskBoundingBox:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "mask": ("MASK",),
+                "padding": ("INT", { "default": 0, "min": 0, "max": 4096, "step": 1, }),
+                "blur": ("INT", { "default": 0, "min": 0, "max": 256, "step": 1, }),
+            },
+            "optional": {
+                "image_optional": ("IMAGE",),
+            }
+        }
+
+    RETURN_TYPES = ("MASK", "IMAGE", "INT", "INT", "INT", "INT")
+    RETURN_NAMES = ("MASK", "IMAGE", "x", "y", "width", "height")
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/mask"
+
+    def execute(self, mask, padding, blur, image_optional=None):
+        if mask.dim() == 2:
+            mask = mask.unsqueeze(0)
+
+        if image_optional is None:
+            image_optional = mask.unsqueeze(3).repeat(1, 1, 1, 3)
+
+        # resize the image if it's not the same size as the mask
+        if image_optional.shape[1:] != mask.shape[1:]:
+            image_optional = comfy.utils.common_upscale(image_optional.permute([0,3,1,2]), mask.shape[2], mask.shape[1], upscale_method='bicubic', crop='center').permute([0,2,3,1])
+
+        # match batch size
+        if image_optional.shape[0] < mask.shape[0]:
+            image_optional = torch.cat((image_optional, image_optional[-1].unsqueeze(0).repeat(mask.shape[0]-image_optional.shape[0], 1, 1, 1)), dim=0)
+        elif image_optional.shape[0] > mask.shape[0]:
+            image_optional = image_optional[:mask.shape[0]]
+
+        # blur the mask
+        if blur > 0:
+            if blur % 2 == 0:
+                blur += 1
+            mask = T.functional.gaussian_blur(mask.unsqueeze(1), blur).squeeze(1)
+
+        _, y, x = torch.where(mask)
+        x1 = max(0, x.min().item() - padding)
+        x2 = min(mask.shape[2], x.max().item() + 1 + padding)
+        y1 = max(0, y.min().item() - padding)
+        y2 = min(mask.shape[1], y.max().item() + 1 + padding)
+
+        # crop the mask
+        mask = mask[:, y1:y2, x1:x2]
+        image_optional = image_optional[:, y1:y2, x1:x2, :]
+
+        return (mask, image_optional, x1, y1, x2 - x1, y2 - y1)
+
+
+class MaskFromColor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE", ),
+                "red": ("INT", { "default": 255, "min": 0, "max": 255, "step": 1, }),
+                "green": ("INT", { "default": 255, "min": 0, "max": 255, "step": 1, }),
+                "blue": ("INT", { "default": 255, "min": 0, "max": 255, "step": 1, }),
+                "threshold": ("INT", { "default": 0, "min": 0, "max": 127, "step": 1, }),
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/mask"
+
+    def execute(self, image, red, green, blue, threshold):
+        temp = (torch.clamp(image, 0, 1.0) * 255.0).round().to(torch.int)
+        color = torch.tensor([red, green, blue])
+        lower_bound = (color - threshold).clamp(min=0)
+        upper_bound = (color + threshold).clamp(max=255)
+        lower_bound = lower_bound.view(1, 1, 1, 3)
+        upper_bound = upper_bound.view(1, 1, 1, 3)
+        mask = (temp >= lower_bound) & (temp <= upper_bound)
+        mask = mask.all(dim=-1)
+        mask = mask.float()
+
+        return (mask, )
+
+
+class MaskFromSegmentation:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE", ),
+                "segments": ("INT", { "default": 6, "min": 1, "max": 16, "step": 1, }),
+                "remove_isolated_pixels": ("INT", { "default": 0, "min": 0, "max": 32, "step": 1, }),
+                "remove_small_masks": ("FLOAT", { "default": 0.0, "min": 0., "max": 1., "step": 0.01, }),
+                "fill_holes": ("BOOLEAN", { "default": False }),
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/mask"
+
+    def execute(self, image, segments, remove_isolated_pixels, fill_holes, remove_small_masks):
+        im = image[0] # we only work on the first image in the batch
+        im = Image.fromarray((im * 255).to(torch.uint8).cpu().numpy(), mode="RGB")
+        im = im.quantize(palette=im.quantize(colors=segments), dither=Image.Dither.NONE)
+        im = torch.tensor(np.array(im.convert("RGB"))).float() / 255.0
+
+        colors = im.reshape(-1, im.shape[-1])
+        colors = torch.unique(colors, dim=0)
+
+        masks = []
+        for color in colors:
+            mask = (im == color).all(dim=-1).float()
+            # remove isolated pixels
+            if remove_isolated_pixels > 0:
+                mask = torch.from_numpy(scipy.ndimage.binary_opening(mask.cpu().numpy(), structure=np.ones((remove_isolated_pixels, remove_isolated_pixels))))
+
+            # fill holes
+            if fill_holes:
+                mask = torch.from_numpy(scipy.ndimage.binary_fill_holes(mask.cpu().numpy()))
+
+            # if the mask is too small, it's probably noise
+            if mask.sum() / (mask.shape[0]*mask.shape[1]) > remove_small_masks:
+                masks.append(mask)
+
+        if masks == []:
+            masks.append(torch.zeros_like(im)[:,:,0]) # return an empty mask if no masks were found, prevents errors
+
+        mask = torch.stack(masks, dim=0).float()
+
+        return (mask, )
+
+
+class MaskFix:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "mask": ("MASK",),
+                "erode_dilate": ("INT", { "default": 0, "min": -256, "max": 256, "step": 1, }),
+                "fill_holes": ("INT", { "default": 0, "min": 0, "max": 128, "step": 1, }),
+                "remove_isolated_pixels": ("INT", { "default": 0, "min": 0, "max": 32, "step": 1, }),
+                "smooth": ("INT", { "default": 0, "min": 0, "max": 256, "step": 1, }),
+                "blur": ("INT", { "default": 0, "min": 0, "max": 256, "step": 1, }),
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/mask"
+
+    def execute(self, mask, erode_dilate, smooth, remove_isolated_pixels, blur, fill_holes):
+        masks = []
+        for m in mask:
+            # erode and dilate
+            if erode_dilate != 0:
+                if erode_dilate < 0:
+                    m = torch.from_numpy(scipy.ndimage.grey_erosion(m.cpu().numpy(), size=(-erode_dilate, -erode_dilate)))
+                else:
+                    m = torch.from_numpy(scipy.ndimage.grey_dilation(m.cpu().numpy(), size=(erode_dilate, erode_dilate)))
+
+            # fill holes
+            if fill_holes > 0:
+                #m = torch.from_numpy(scipy.ndimage.binary_fill_holes(m.cpu().numpy(), structure=np.ones((fill_holes,fill_holes)))).float()
+                m = torch.from_numpy(scipy.ndimage.grey_closing(m.cpu().numpy(), size=(fill_holes, fill_holes)))
+
+            # remove isolated pixels
+            if remove_isolated_pixels > 0:
+                m = torch.from_numpy(scipy.ndimage.grey_opening(m.cpu().numpy(), size=(remove_isolated_pixels, remove_isolated_pixels)))
+
+            # smooth the mask
+            if smooth > 0:
+                if smooth % 2 == 0:
+                    smooth += 1
+                m = T.functional.gaussian_blur((m > 0.5).unsqueeze(0), smooth).squeeze(0)
+
+            # blur the mask
+            if blur > 0:
+                if blur % 2 == 0:
+                    blur += 1
+                m = T.functional.gaussian_blur(m.float().unsqueeze(0), blur).squeeze(0)
+
+            masks.append(m.float())
+
+        masks = torch.stack(masks, dim=0).float()
+
+        return (masks, )
+
+class MaskSmooth:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "mask": ("MASK",),
+                "amount": ("INT", { "default": 0, "min": 0, "max": 127, "step": 1, }),
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/mask"
+
+    def execute(self, mask, amount):
+        if amount == 0:
+            return (mask,)
+        
+        if amount % 2 == 0:
+            amount += 1
+
+        mask = mask > 0.5
+        mask = T.functional.gaussian_blur(mask.unsqueeze(1), amount).squeeze(1).float()
+
+        return (mask,)
+
+class MaskFromBatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "mask": ("MASK", ),
+                "start": ("INT", { "default": 0, "min": 0, "step": 1, }),
+                "length": ("INT", { "default": 1, "min": 1, "step": 1, }),
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/mask batch"
+
+    def execute(self, mask, start, length):
+        if length > mask.shape[0]:
+            length = mask.shape[0]
+
+        start = min(start, mask.shape[0]-1)
+        length = min(mask.shape[0]-start, length)
+        return (mask[start:start + length], )
+
+class MaskFromList:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "width": ("INT", { "default": 32, "min": 0, "max": MAX_RESOLUTION, "step": 8, }),
+                "height": ("INT", { "default": 32, "min": 0, "max": MAX_RESOLUTION, "step": 8, }),
+            }, "optional": {
+                "values": (any, { "default": 0.0, "min": 0.0, "max": 1.0, }),
+                "str_values": ("STRING", { "default": "", "multiline": True, "placeholder": "0.0, 0.5, 1.0",}),
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/mask"
+
+    def execute(self, width, height, values=None, str_values=""):
+        out = []
+
+        if values is not None:
+            if not isinstance(values, list):
+                out = [values]
+            else:
+                out.extend([float(v) for v in values])
+
+        if str_values != "":
+            str_values = [float(v) for v in str_values.split(",")]
+            out.extend(str_values)
+
+        if out == []:
+            raise ValueError("No values provided")
+        
+        out = torch.tensor(out).float().clamp(0.0, 1.0)
+        out = out.view(-1, 1, 1).expand(-1, height, width)
+        
+        values = None
+        str_values = ""
+
+        return (out, )
+
+class MaskFromRGBCMYBW:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE", ),
+                "threshold_r": ("FLOAT", { "default": 0.15, "min": 0.0, "max": 1, "step": 0.01, }),
+                "threshold_g": ("FLOAT", { "default": 0.15, "min": 0.0, "max": 1, "step": 0.01, }),
+                "threshold_b": ("FLOAT", { "default": 0.15, "min": 0.0, "max": 1, "step": 0.01, }),
+            }
+        }
+
+    RETURN_TYPES = ("MASK","MASK","MASK","MASK","MASK","MASK","MASK","MASK",)
+    RETURN_NAMES = ("red","green","blue","cyan","magenta","yellow","black","white",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/mask"
+
+    def execute(self, image, threshold_r, threshold_g, threshold_b):
+        red = ((image[..., 0] >= 1-threshold_r) & (image[..., 1] < threshold_g) & (image[..., 2] < threshold_b)).float()
+        green = ((image[..., 0] < threshold_r) & (image[..., 1] >= 1-threshold_g) & (image[..., 2] < threshold_b)).float()
+        blue = ((image[..., 0] < threshold_r) & (image[..., 1] < threshold_g) & (image[..., 2] >= 1-threshold_b)).float()
+
+        cyan = ((image[..., 0] < threshold_r) & (image[..., 1] >= 1-threshold_g) & (image[..., 2] >= 1-threshold_b)).float()
+        magenta = ((image[..., 0] >= 1-threshold_r) & (image[..., 1] < threshold_g) & (image[..., 2] > 1-threshold_b)).float()
+        yellow = ((image[..., 0] >= 1-threshold_r) & (image[..., 1] >= 1-threshold_g) & (image[..., 2] < threshold_b)).float()
+
+        black = ((image[..., 0] <= threshold_r) & (image[..., 1] <= threshold_g) & (image[..., 2] <= threshold_b)).float()
+        white = ((image[..., 0] >= 1-threshold_r) & (image[..., 1] >= 1-threshold_g) & (image[..., 2] >= 1-threshold_b)).float()
+        
+        return (red, green, blue, cyan, magenta, yellow, black, white,)
+
+class TransitionMask:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "width": ("INT", { "default": 512, "min": 1, "max": MAX_RESOLUTION, "step": 1, }),
+                "height": ("INT", { "default": 512, "min": 1, "max": MAX_RESOLUTION, "step": 1, }),
+                "frames": ("INT", { "default": 16, "min": 1, "max": 9999, "step": 1, }),
+                "start_frame": ("INT", { "default": 0, "min": 0, "step": 1, }),
+                "end_frame": ("INT", { "default": 9999, "min": 0, "step": 1, }),
+                "transition_type": (["horizontal slide", "vertical slide", "horizontal bar", "vertical bar", "center box", "horizontal door", "vertical door", "circle", "fade"],),
+                "timing_function": (["linear", "in", "out", "in-out"],)
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/mask"
+
+    def linear(self, i, t):
+        return i/t
+    def ease_in(self, i, t):
+        return pow(i/t, 2)
+    def ease_out(self, i, t):
+        return 1 - pow(1 - i/t, 2)
+    def ease_in_out(self, i, t):
+        if i < t/2:
+            return pow(i/(t/2), 2) / 2
+        else:
+            return 1 - pow(1 - (i - t/2)/(t/2), 2) / 2
+
+    def execute(self, width, height, frames, start_frame, end_frame, transition_type, timing_function):
+        if timing_function == 'in':
+            timing_function = self.ease_in
+        elif timing_function == 'out':
+            timing_function = self.ease_out
+        elif timing_function == 'in-out':
+            timing_function = self.ease_in_out
+        else:
+            timing_function = self.linear
+
+        out = []
+
+        end_frame = min(frames, end_frame)
+        transition = end_frame - start_frame
+
+        if start_frame > 0:
+            out = out + [torch.full((height, width), 0.0, dtype=torch.float32, device="cpu")] * start_frame
+
+        for i in range(transition):
+            frame = torch.full((height, width), 0.0, dtype=torch.float32, device="cpu")
+            progress = timing_function(i, transition-1)
+
+            if "horizontal slide" in transition_type:
+                pos = round(width*progress)
+                frame[:, :pos] = 1.0
+            elif "vertical slide" in transition_type:
+                pos = round(height*progress)
+                frame[:pos, :] = 1.0
+            elif "box" in transition_type:
+                box_w = round(width*progress)
+                box_h = round(height*progress)
+                x1 = (width - box_w) // 2
+                y1 = (height - box_h) // 2
+                x2 = x1 + box_w
+                y2 = y1 + box_h
+                frame[y1:y2, x1:x2] = 1.0
+            elif "circle" in transition_type:
+                radius = math.ceil(math.sqrt(pow(width,2)+pow(height,2))*progress/2)
+                c_x = width // 2
+                c_y = height // 2
+                # is this real life? Am I hallucinating?
+                x = torch.arange(0, width, dtype=torch.float32, device="cpu")
+                y = torch.arange(0, height, dtype=torch.float32, device="cpu")
+                y, x = torch.meshgrid((y, x), indexing="ij")
+                circle = ((x - c_x) ** 2 + (y - c_y) ** 2) <= (radius ** 2)
+                frame[circle] = 1.0
+            elif "horizontal bar" in transition_type:
+                bar = round(height*progress)
+                y1 = (height - bar) // 2
+                y2 = y1 + bar
+                frame[y1:y2, :] = 1.0
+            elif "vertical bar" in transition_type:
+                bar = round(width*progress)
+                x1 = (width - bar) // 2
+                x2 = x1 + bar
+                frame[:, x1:x2] = 1.0
+            elif "horizontal door" in transition_type:
+                bar = math.ceil(height*progress/2)
+                if bar > 0:
+                    frame[:bar, :] = 1.0
+                    frame[-bar:, :] = 1.0
+            elif "vertical door" in transition_type:
+                bar = math.ceil(width*progress/2)
+                if bar > 0:
+                    frame[:, :bar] = 1.0
+                    frame[:, -bar:] = 1.0
+            elif "fade" in transition_type:
+                frame[:,:] = progress
+
+            out.append(frame)
+
+        if end_frame < frames:
+            out = out + [torch.full((height, width), 1.0, dtype=torch.float32, device="cpu")] * (frames - end_frame)
+
+        out = torch.stack(out, dim=0)
+
+        return (out, )
+
+MASK_CLASS_MAPPINGS = {
+    "MaskBlur+": MaskBlur,
+    "MaskBoundingBox+": MaskBoundingBox,
+    "MaskFix+": MaskFix,
+    "MaskFlip+": MaskFlip,
+    "MaskFromColor+": MaskFromColor,
+    "MaskFromList+": MaskFromList,
+    "MaskFromRGBCMYBW+": MaskFromRGBCMYBW,
+    "MaskFromSegmentation+": MaskFromSegmentation,
+    "MaskPreview+": MaskPreview,
+    "MaskSmooth+": MaskSmooth,
+    "TransitionMask+": TransitionMask,
+
+    # Batch
+    "MaskBatch+": MaskBatch,
+    "MaskExpandBatch+": MaskExpandBatch,
+    "MaskFromBatch+": MaskFromBatch,
+}
+
+MASK_NAME_MAPPINGS = {
+    "MaskBlur+": "🔧 Mask Blur",
+    "MaskFix+": "🔧 Mask Fix",
+    "MaskFlip+": "🔧 Mask Flip",
+    "MaskFromColor+": "🔧 Mask From Color",
+    "MaskFromList+": "🔧 Mask From List",
+    "MaskFromRGBCMYBW+": "🔧 Mask From RGB/CMY/BW",
+    "MaskFromSegmentation+": "🔧 Mask From Segmentation",
+    "MaskPreview+": "🔧 Mask Preview",
+    "MaskBoundingBox+": "🔧 Mask Bounding Box",
+    "MaskSmooth+": "🔧 Mask Smooth",
+    "TransitionMask+": "🔧 Transition Mask",
+
+    "MaskBatch+": "🔧 Mask Batch",
+    "MaskExpandBatch+": "🔧 Mask Expand Batch",
+    "MaskFromBatch+": "🔧 Mask From Batch",
+}

misc.py

@@ -0,0 +1,574 @@
+import math
+import torch
+from .utils import AnyType
+import comfy.model_management
+from nodes import MAX_RESOLUTION
+import time
+
+any = AnyType("*")
+
+class SimpleMathFloat:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "value": ("FLOAT", { "default": 0.0, "min": -0xffffffffffffffff, "max": 0xffffffffffffffff, "step": 0.05 }),
+            },
+        }
+
+    RETURN_TYPES = ("FLOAT", )
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/utilities"
+
+    def execute(self, value):
+        return (float(value), )
+
+class SimpleMathPercent:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "value": ("FLOAT", { "default": 0.0, "min": 0, "max": 1, "step": 0.05 }),
+            },
+        }
+
+    RETURN_TYPES = ("FLOAT", )
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/utilities"
+
+    def execute(self, value):
+        return (float(value), )
+
+class SimpleMathInt:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "value": ("INT", { "default": 0, "min": -0xffffffffffffffff, "max": 0xffffffffffffffff, "step": 1 }),
+            },
+        }
+
+    RETURN_TYPES = ("INT",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/utilities"
+
+    def execute(self, value):
+        return (int(value), )
+
+class SimpleMathSlider:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "value": ("FLOAT", { "display": "slider", "default": 0.5, "min": 0.0, "max": 1.0, "step": 0.001 }),
+                "min": ("FLOAT", { "default": 0.0, "min": -0xffffffffffffffff, "max": 0xffffffffffffffff, "step": 0.001 }),
+                "max": ("FLOAT", { "default": 1.0, "min": -0xffffffffffffffff, "max": 0xffffffffffffffff, "step": 0.001 }),
+                "rounding": ("INT", { "default": 0, "min": 0, "max": 10, "step": 1 }),
+            },
+        }
+
+    RETURN_TYPES = ("FLOAT", "INT",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/utilities"
+
+    def execute(self, value, min, max, rounding):
+        value = min + value * (max - min)
+        
+        if rounding > 0:
+            value = round(value, rounding)
+
+        return (value, int(value), )
+
+class SimpleMathSliderLowRes:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "value": ("INT", { "display": "slider", "default": 5, "min": 0, "max": 10, "step": 1 }),
+                "min": ("FLOAT", { "default": 0.0, "min": -0xffffffffffffffff, "max": 0xffffffffffffffff, "step": 0.001 }),
+                "max": ("FLOAT", { "default": 1.0, "min": -0xffffffffffffffff, "max": 0xffffffffffffffff, "step": 0.001 }),
+                "rounding": ("INT", { "default": 0, "min": 0, "max": 10, "step": 1 }),
+            },
+        }
+
+    RETURN_TYPES = ("FLOAT", "INT",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/utilities"
+
+    def execute(self, value, min, max, rounding):
+        value = 0.1 * value
+        value = min + value * (max - min)
+        if rounding > 0:
+            value = round(value, rounding)
+
+        return (value, )
+
+class SimpleMathBoolean:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "value": ("BOOLEAN", { "default": False }),
+            },
+        }
+
+    RETURN_TYPES = ("BOOLEAN",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/utilities"
+
+    def execute(self, value):
+        return (value, int(value), )
+
+class SimpleMath:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "optional": {
+                "a": (any, { "default": 0.0 }),
+                "b": (any, { "default": 0.0 }),
+                "c": (any, { "default": 0.0 }),
+            },
+            "required": {
+                "value": ("STRING", { "multiline": False, "default": "" }),
+            },
+        }
+
+    RETURN_TYPES = ("INT", "FLOAT", )
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/utilities"
+
+    def execute(self, value, a = 0.0, b = 0.0, c = 0.0, d = 0.0):
+        import ast
+        import operator as op
+
+        h, w = 0.0, 0.0
+        if hasattr(a, 'shape'):
+            a = list(a.shape)
+        if hasattr(b, 'shape'):
+            b = list(b.shape)
+        if hasattr(c, 'shape'):
+            c = list(c.shape)
+        if hasattr(d, 'shape'):
+            d = list(d.shape)
+
+        if isinstance(a, str):
+            a = float(a)
+        if isinstance(b, str):
+            b = float(b)
+        if isinstance(c, str):
+            c = float(c)
+        if isinstance(d, str):
+            d = float(d)
+        
+        operators = {
+            ast.Add: op.add,
+            ast.Sub: op.sub,
+            ast.Mult: op.mul,
+            ast.Div: op.truediv,
+            ast.FloorDiv: op.floordiv,
+            ast.Pow: op.pow,
+            #ast.BitXor: op.xor,
+            #ast.BitOr: op.or_,
+            #ast.BitAnd: op.and_,
+            ast.USub: op.neg,
+            ast.Mod: op.mod,
+            ast.Eq: op.eq,
+            ast.NotEq: op.ne,
+            ast.Lt: op.lt,
+            ast.LtE: op.le,
+            ast.Gt: op.gt,
+            ast.GtE: op.ge,
+            ast.And: lambda x, y: x and y,
+            ast.Or: lambda x, y: x or y,
+            ast.Not: op.not_
+        }
+
+        op_functions = {
+            'min': min,
+            'max': max,
+            'round': round,
+            'sum': sum,
+            'len': len,
+        }
+
+        def eval_(node):
+            if isinstance(node, ast.Num): # number
+                return node.n
+            elif isinstance(node, ast.Name): # variable
+                if node.id == "a":
+                    return a
+                if node.id == "b":
+                    return b
+                if node.id == "c":
+                    return c
+                if node.id == "d":
+                    return d
+            elif isinstance(node, ast.BinOp): # <left> <operator> <right>
+                return operators[type(node.op)](eval_(node.left), eval_(node.right))
+            elif isinstance(node, ast.UnaryOp): # <operator> <operand> e.g., -1
+                return operators[type(node.op)](eval_(node.operand))
+            elif isinstance(node, ast.Compare):  # comparison operators
+                left = eval_(node.left)
+                for op, comparator in zip(node.ops, node.comparators):
+                    if not operators[type(op)](left, eval_(comparator)):
+                        return 0
+                return 1
+            elif isinstance(node, ast.BoolOp):  # boolean operators (And, Or)
+                values = [eval_(value) for value in node.values]
+                return operators[type(node.op)](*values)
+            elif isinstance(node, ast.Call): # custom function
+                if node.func.id in op_functions:
+                    args =[eval_(arg) for arg in node.args]
+                    return op_functions[node.func.id](*args)
+            elif isinstance(node, ast.Subscript): # indexing or slicing
+                value = eval_(node.value)
+                if isinstance(node.slice, ast.Constant):
+                    return value[node.slice.value]
+                else:
+                    return 0
+            else:
+                return 0
+
+        result = eval_(ast.parse(value, mode='eval').body)
+
+        if math.isnan(result):
+            result = 0.0
+        
+        return (round(result), result, )
+
+class SimpleMathDual:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "optional": {
+                "a": (any, { "default": 0.0 }),
+                "b": (any, { "default": 0.0 }),
+                "c": (any, { "default": 0.0 }),
+                "d": (any, { "default": 0.0 }),
+            },
+            "required": {
+                "value_1": ("STRING", { "multiline": False, "default": "" }),
+                "value_2": ("STRING", { "multiline": False, "default": "" }),
+            },
+        }
+    
+    RETURN_TYPES = ("INT", "FLOAT", "INT", "FLOAT", )
+    RETURN_NAMES = ("int_1", "float_1", "int_2", "float_2" )
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/utilities"
+
+    def execute(self, value_1, value_2, a = 0.0, b = 0.0, c = 0.0, d = 0.0):
+        return SimpleMath().execute(value_1, a, b, c, d) + SimpleMath().execute(value_2, a, b, c, d)
+
+class SimpleMathCondition:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "optional": {
+                "a": (any, { "default": 0.0 }),
+                "b": (any, { "default": 0.0 }),
+                "c": (any, { "default": 0.0 }),
+            },
+            "required": {
+                "evaluate": (any, {"default": 0}),
+                "on_true": ("STRING", { "multiline": False, "default": "" }),
+                "on_false": ("STRING", { "multiline": False, "default": "" }),
+            },
+        }
+    
+    RETURN_TYPES = ("INT", "FLOAT", )
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/utilities"
+
+    def execute(self, evaluate, on_true, on_false, a = 0.0, b = 0.0, c = 0.0):
+        return SimpleMath().execute(on_true if evaluate else on_false, a, b, c)
+
+class SimpleCondition:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "evaluate": (any, {"default": 0}),
+                "on_true": (any, {"default": 0}),
+            },
+            "optional": {
+                "on_false": (any, {"default": None}),
+            },
+        }
+
+    RETURN_TYPES = (any,)
+    RETURN_NAMES = ("result",)
+    FUNCTION = "execute"
+
+    CATEGORY = "essentials_mb/utilities"
+
+    def execute(self, evaluate, on_true, on_false=None):
+        from comfy_execution.graph import ExecutionBlocker
+        if not evaluate:
+            return (on_false if on_false is not None else ExecutionBlocker(None),)
+
+        return (on_true,)
+
+class SimpleComparison:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "a": (any, {"default": 0}),
+                "b": (any, {"default": 0}),
+                "comparison": (["==", "!=", "<", "<=", ">", ">="],),
+            },
+        }
+
+    RETURN_TYPES = ("BOOLEAN",)
+    FUNCTION = "execute"
+
+    CATEGORY = "essentials_mb/utilities"
+
+    def execute(self, a, b, comparison):
+        if comparison == "==":
+            return (a == b,)
+        elif comparison == "!=":
+            return (a != b,)
+        elif comparison == "<":
+            return (a < b,)
+        elif comparison == "<=":
+            return (a <= b,)
+        elif comparison == ">":
+            return (a > b,)
+        elif comparison == ">=":
+            return (a >= b,)
+
+class ConsoleDebug:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "value": (any, {}),
+            },
+            "optional": {
+                "prefix": ("STRING", { "multiline": False, "default": "Value:" })
+            }
+        }
+
+    RETURN_TYPES = ()
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/utilities"
+    OUTPUT_NODE = True
+
+    def execute(self, value, prefix):
+        print(f"\033[96m{prefix} {value}\033[0m")
+
+        return (None,)
+
+class DebugTensorShape:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "tensor": (any, {}),
+            },
+        }
+
+    RETURN_TYPES = ()
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/utilities"
+    OUTPUT_NODE = True
+
+    def execute(self, tensor):
+        shapes = []
+        def tensorShape(tensor):
+            if isinstance(tensor, dict):
+                for k in tensor:
+                    tensorShape(tensor[k])
+            elif isinstance(tensor, list):
+                for i in range(len(tensor)):
+                    tensorShape(tensor[i])
+            elif hasattr(tensor, 'shape'):
+                shapes.append(list(tensor.shape))
+
+        tensorShape(tensor)
+
+        print(f"\033[96mShapes found: {shapes}\033[0m")
+
+        return (None,)
+
+class BatchCount:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "batch": (any, {}),
+            },
+        }
+
+    RETURN_TYPES = ("INT",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/utilities"
+
+    def execute(self, batch):
+        count = 0
+        if hasattr(batch, 'shape'):
+            count = batch.shape[0]
+        elif isinstance(batch, dict) and 'samples' in batch:
+            count = batch['samples'].shape[0]
+        elif isinstance(batch, list) or isinstance(batch, dict):
+            count = len(batch)
+
+        return (count, )
+
+class ModelCompile():
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "model": ("MODEL",),
+                "fullgraph": ("BOOLEAN", { "default": False }),
+                "dynamic": ("BOOLEAN", { "default": False }),
+                "mode": (["default", "reduce-overhead", "max-autotune", "max-autotune-no-cudagraphs"],),
+            },
+        }
+
+    RETURN_TYPES = ("MODEL", )
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/utilities"
+
+    def execute(self, model, fullgraph, dynamic, mode):
+        work_model = model.clone()
+        torch._dynamo.config.suppress_errors = True
+        work_model.add_object_patch("diffusion_model", torch.compile(model=work_model.get_model_object("diffusion_model"), dynamic=dynamic, fullgraph=fullgraph, mode=mode))
+        return (work_model, )
+
+class RemoveLatentMask:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { "samples": ("LATENT",),}}
+    RETURN_TYPES = ("LATENT",)
+    FUNCTION = "execute"
+
+    CATEGORY = "essentials_mb/utilities"
+
+    def execute(self, samples):
+        s = samples.copy()
+        if "noise_mask" in s:
+            del s["noise_mask"]
+
+        return (s,)
+
+class SDXLEmptyLatentSizePicker:
+    def __init__(self):
+        self.device = comfy.model_management.intermediate_device()
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+            "resolution": (["704x1408 (0.5)","704x1344 (0.52)","768x1344 (0.57)","768x1280 (0.6)","832x1216 (0.68)","832x1152 (0.72)","896x1152 (0.78)","896x1088 (0.82)","960x1088 (0.88)","960x1024 (0.94)","1024x1024 (1.0)","1024x960 (1.07)","1088x960 (1.13)","1088x896 (1.21)","1152x896 (1.29)","1152x832 (1.38)","1216x832 (1.46)","1280x768 (1.67)","1344x768 (1.75)","1344x704 (1.91)","1408x704 (2.0)","1472x704 (2.09)","1536x640 (2.4)","1600x640 (2.5)","1664x576 (2.89)","1728x576 (3.0)",], {"default": "1024x1024 (1.0)"}),
+            "batch_size": ("INT", {"default": 1, "min": 1, "max": 4096}),
+            "width_override": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),
+            "height_override": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),
+            }}
+
+    RETURN_TYPES = ("LATENT","INT","INT",)
+    RETURN_NAMES = ("LATENT","width","height",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/utilities"
+
+    def execute(self, resolution, batch_size, width_override=0, height_override=0):
+        width, height = resolution.split(" ")[0].split("x")
+        width = width_override if width_override > 0 else int(width)
+        height = height_override if height_override > 0 else int(height)
+
+        latent = torch.zeros([batch_size, 4, height // 8, width // 8], device=self.device)
+
+        return ({"samples":latent}, width, height,)
+
+class DisplayAny:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "input": (("*",{})),
+                "mode": (["raw value", "tensor shape"],),
+            },
+        }
+
+    @classmethod
+    def VALIDATE_INPUTS(s, input_types):
+        return True
+
+    RETURN_TYPES = ("STRING",)
+    FUNCTION = "execute"
+    OUTPUT_NODE = True
+
+    CATEGORY = "essentials_mb/utilities"
+
+    def execute(self, input, mode):
+        if mode == "tensor shape":
+            text = []
+            def tensorShape(tensor):
+                if isinstance(tensor, dict):
+                    for k in tensor:
+                        tensorShape(tensor[k])
+                elif isinstance(tensor, list):
+                    for i in range(len(tensor)):
+                        tensorShape(tensor[i])
+                elif hasattr(tensor, 'shape'):
+                    text.append(list(tensor.shape))
+
+            tensorShape(input)
+            input = text
+
+        text = str(input)
+
+        return {"ui": {"text": text}, "result": (text,)}
+
+MISC_CLASS_MAPPINGS = {
+    "BatchCount+": BatchCount,
+    "ConsoleDebug+": ConsoleDebug,
+    "DebugTensorShape+": DebugTensorShape,
+    "DisplayAny": DisplayAny,
+    "ModelCompile+": ModelCompile,
+    "RemoveLatentMask+": RemoveLatentMask,
+    "SDXLEmptyLatentSizePicker+": SDXLEmptyLatentSizePicker,
+    "SimpleComparison+": SimpleComparison,
+    "SimpleCondition+": SimpleCondition,
+    "SimpleMath+": SimpleMath,
+    "SimpleMathDual+": SimpleMathDual,
+    "SimpleMathCondition+": SimpleMathCondition,
+    "SimpleMathBoolean+": SimpleMathBoolean,
+    "SimpleMathFloat+": SimpleMathFloat,
+    "SimpleMathInt+": SimpleMathInt,
+    "SimpleMathPercent+": SimpleMathPercent,
+    "SimpleMathSlider+": SimpleMathSlider,
+    "SimpleMathSliderLowRes+": SimpleMathSliderLowRes,
+}
+
+MISC_NAME_MAPPINGS = {
+    "BatchCount+": "🔧 Batch Count",
+    "ConsoleDebug+": "🔧 Console Debug",
+    "DebugTensorShape+": "🔧 Debug Tensor Shape",
+    "DisplayAny": "🔧 Display Any",
+    "ModelCompile+": "🔧 Model Compile",
+    "RemoveLatentMask+": "🔧 Remove Latent Mask",
+    "SDXLEmptyLatentSizePicker+": "🔧 Empty Latent Size Picker",
+    "SimpleComparison+": "🔧 Simple Comparison",
+    "SimpleCondition+": "🔧 Simple Condition",
+    "SimpleMath+": "🔧 Simple Math",
+    "SimpleMathDual+": "🔧 Simple Math Dual",
+    "SimpleMathCondition+": "🔧 Simple Math Condition",
+    "SimpleMathBoolean+": "🔧 Simple Math Boolean",
+    "SimpleMathFloat+": "🔧 Simple Math Float",
+    "SimpleMathInt+": "🔧 Simple Math Int",
+    "SimpleMathPercent+": "🔧 Simple Math Percent",
+    "SimpleMathSlider+": "🔧 Simple Math Slider",
+    "SimpleMathSliderLowRes+": "🔧 Simple Math Slider low-res",
+}

node.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:522c3b665b8772008e245994e4a6650b31d55ecd4f8785592cc39ce5e3881f3f
+size 68245

pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "comfyui_essentials_mb"
+description = "Essential nodes. Fork from ComfyUI_essentials"
+version = "1.1.1"
+license = { file = "LICENSE" }
+dependencies = ["numba", "colour-science", "rembg", "pixeloe"]
+
+[project.urls]
+Repository = "https://github.com/MinorBoy/ComfyUI_essentials_mb"
+#  Used by Comfy Registry https://comfyregistry.org
+
+[tool.comfy]
+PublisherId = "mboy"
+DisplayName = "ComfyUI_essentials_mb"
+Icon = ""

requirements.txt

@@ -0,0 +1,5 @@
+numba
+colour-science
+rembg
+pixeloe
+transparent-background

sampling.py

@@ -0,0 +1,811 @@
+import os
+import comfy.samplers
+import comfy.sample
+import torch
+from nodes import common_ksampler, CLIPTextEncode
+from comfy.utils import ProgressBar
+from .utils import expand_mask, FONTS_DIR, parse_string_to_list
+import torchvision.transforms.v2 as T
+import torch.nn.functional as F
+import logging
+import folder_paths
+
+# From https://github.com/BlenderNeko/ComfyUI_Noise/
+def slerp(val, low, high):
+    dims = low.shape
+
+    low = low.reshape(dims[0], -1)
+    high = high.reshape(dims[0], -1)
+
+    low_norm = low/torch.norm(low, dim=1, keepdim=True)
+    high_norm = high/torch.norm(high, dim=1, keepdim=True)
+
+    low_norm[low_norm != low_norm] = 0.0
+    high_norm[high_norm != high_norm] = 0.0
+
+    omega = torch.acos((low_norm*high_norm).sum(1))
+    so = torch.sin(omega)
+    res = (torch.sin((1.0-val)*omega)/so).unsqueeze(1)*low + (torch.sin(val*omega)/so).unsqueeze(1) * high
+
+    return res.reshape(dims)
+
+class KSamplerVariationsWithNoise:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                    "model": ("MODEL", ),
+                    "latent_image": ("LATENT", ),
+                    "main_seed": ("INT:seed", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                    "steps": ("INT", {"default": 20, "min": 1, "max": 10000}),
+                    "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0, "step":0.1, "round": 0.01}),
+                    "sampler_name": (comfy.samplers.KSampler.SAMPLERS, ),
+                    "scheduler": (comfy.samplers.KSampler.SCHEDULERS, ),
+                    "positive": ("CONDITIONING", ),
+                    "negative": ("CONDITIONING", ),
+                    "variation_strength": ("FLOAT", {"default": 0.17, "min": 0.0, "max": 1.0, "step":0.01, "round": 0.01}),
+                    #"start_at_step": ("INT", {"default": 0, "min": 0, "max": 10000}),
+                    #"end_at_step": ("INT", {"default": 10000, "min": 0, "max": 10000}),
+                    #"return_with_leftover_noise": (["disable", "enable"], ),
+                    "variation_seed": ("INT:seed", {"default": 12345, "min": 0, "max": 0xffffffffffffffff}),
+                    "denoise": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step":0.01, "round": 0.01}),
+                }}
+
+    RETURN_TYPES = ("LATENT",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/sampling"
+
+    def prepare_mask(self, mask, shape):
+        mask = torch.nn.functional.interpolate(mask.reshape((-1, 1, mask.shape[-2], mask.shape[-1])), size=(shape[2], shape[3]), mode="bilinear")
+        mask = mask.expand((-1,shape[1],-1,-1))
+        if mask.shape[0] < shape[0]:
+            mask = mask.repeat((shape[0] -1) // mask.shape[0] + 1, 1, 1, 1)[:shape[0]]
+        return mask
+
+    def execute(self, model, latent_image, main_seed, steps, cfg, sampler_name, scheduler, positive, negative, variation_strength, variation_seed, denoise):
+        if main_seed == variation_seed:
+            variation_seed += 1
+
+        end_at_step = steps #min(steps, end_at_step)
+        start_at_step = round(end_at_step - end_at_step * denoise)
+
+        force_full_denoise = True
+        disable_noise = True
+
+        device = comfy.model_management.get_torch_device()
+
+        # Generate base noise
+        batch_size, _, height, width = latent_image["samples"].shape
+        generator = torch.manual_seed(main_seed)
+        base_noise = torch.randn((1, 4, height, width), dtype=torch.float32, device="cpu", generator=generator).repeat(batch_size, 1, 1, 1).cpu()
+
+        # Generate variation noise
+        generator = torch.manual_seed(variation_seed)
+        variation_noise = torch.randn((batch_size, 4, height, width), dtype=torch.float32, device="cpu", generator=generator).cpu()
+
+        slerp_noise = slerp(variation_strength, base_noise, variation_noise)
+
+        # Calculate sigma
+        comfy.model_management.load_model_gpu(model)
+        sampler = comfy.samplers.KSampler(model, steps=steps, device=device, sampler=sampler_name, scheduler=scheduler, denoise=1.0, model_options=model.model_options)
+        sigmas = sampler.sigmas
+        sigma = sigmas[start_at_step] - sigmas[end_at_step]
+        sigma /= model.model.latent_format.scale_factor
+        sigma = sigma.detach().cpu().item()
+
+        work_latent = latent_image.copy()
+        work_latent["samples"] = latent_image["samples"].clone() + slerp_noise * sigma
+
+        # if there's a mask we need to expand it to avoid artifacts, 5 pixels should be enough
+        if "noise_mask" in latent_image:
+            noise_mask = self.prepare_mask(latent_image["noise_mask"], latent_image['samples'].shape)
+            work_latent["samples"] = noise_mask * work_latent["samples"] + (1-noise_mask) * latent_image["samples"]
+            work_latent['noise_mask'] = expand_mask(latent_image["noise_mask"].clone(), 5, True)
+
+        return common_ksampler(model, main_seed, steps, cfg, sampler_name, scheduler, positive, negative, work_latent, denoise=1.0, disable_noise=disable_noise, start_step=start_at_step, last_step=end_at_step, force_full_denoise=force_full_denoise)
+
+
+class KSamplerVariationsStochastic:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required":{
+                    "model": ("MODEL",),
+                    "latent_image": ("LATENT", ),
+                    "noise_seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                    "steps": ("INT", {"default": 25, "min": 1, "max": 10000}),
+                    "cfg": ("FLOAT", {"default": 7.0, "min": 0.0, "max": 100.0, "step":0.1, "round": 0.01}),
+                    "sampler": (comfy.samplers.KSampler.SAMPLERS, ),
+                    "scheduler": (comfy.samplers.KSampler.SCHEDULERS, ),
+                    "positive": ("CONDITIONING", ),
+                    "negative": ("CONDITIONING", ),
+                    "variation_seed": ("INT:seed", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                    "variation_strength": ("FLOAT", {"default": 0.2, "min": 0.0, "max": 1.0, "step":0.05, "round": 0.01}),
+                    #"variation_sampler": (comfy.samplers.KSampler.SAMPLERS, ),
+                    "cfg_scale": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step":0.05, "round": 0.01}),
+                }}
+
+    RETURN_TYPES = ("LATENT", )
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/sampling"
+
+    def execute(self, model, latent_image, noise_seed, steps, cfg, sampler, scheduler, positive, negative, variation_seed, variation_strength, cfg_scale, variation_sampler="dpmpp_2m_sde"):
+        # Stage 1: composition sampler
+        force_full_denoise = False # return with leftover noise = "enable"
+        disable_noise = False # add noise = "enable"
+
+        end_at_step = max(int(steps * (1-variation_strength)), 1)
+        start_at_step = 0
+
+        work_latent = latent_image.copy()
+        batch_size = work_latent["samples"].shape[0]
+        work_latent["samples"] = work_latent["samples"][0].unsqueeze(0)
+
+        stage1 = common_ksampler(model, noise_seed, steps, cfg, sampler, scheduler, positive, negative, work_latent, denoise=1.0, disable_noise=disable_noise, start_step=start_at_step, last_step=end_at_step, force_full_denoise=force_full_denoise)[0]
+
+        if batch_size > 1:
+            stage1["samples"] = stage1["samples"].clone().repeat(batch_size, 1, 1, 1)
+
+        # Stage 2: variation sampler
+        force_full_denoise = True
+        disable_noise = True
+        cfg = max(cfg * cfg_scale, 1.0)
+        start_at_step = end_at_step
+        end_at_step = steps
+
+        return common_ksampler(model, variation_seed, steps, cfg, variation_sampler, scheduler, positive, negative, stage1, denoise=1.0, disable_noise=disable_noise, start_step=start_at_step, last_step=end_at_step, force_full_denoise=force_full_denoise)
+
+class InjectLatentNoise:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                    "latent": ("LATENT", ),
+                    "noise_seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                    "noise_strength": ("FLOAT", {"default": 1.0, "min": -20.0, "max": 20.0, "step":0.01, "round": 0.01}),
+                    "normalize": (["false", "true"], {"default": "false"}),
+                },
+                "optional": {
+                    "mask": ("MASK", ),
+                }}
+
+    RETURN_TYPES = ("LATENT",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/sampling"
+
+    def execute(self, latent, noise_seed, noise_strength, normalize="false", mask=None):
+        torch.manual_seed(noise_seed)
+        noise_latent = latent.copy()
+        original_samples = noise_latent["samples"].clone()
+        random_noise = torch.randn_like(original_samples)
+
+        if normalize == "true":
+            mean = original_samples.mean()
+            std = original_samples.std()
+            random_noise = random_noise * std + mean
+
+        random_noise = original_samples + random_noise * noise_strength
+
+        if mask is not None:
+            mask = F.interpolate(mask.reshape((-1, 1, mask.shape[-2], mask.shape[-1])), size=(random_noise.shape[2], random_noise.shape[3]), mode="bilinear")
+            mask = mask.expand((-1,random_noise.shape[1],-1,-1)).clamp(0.0, 1.0)
+            if mask.shape[0] < random_noise.shape[0]:
+                mask = mask.repeat((random_noise.shape[0] -1) // mask.shape[0] + 1, 1, 1, 1)[:random_noise.shape[0]]
+            elif mask.shape[0] > random_noise.shape[0]:
+                mask = mask[:random_noise.shape[0]]
+            random_noise = mask * random_noise + (1-mask) * original_samples
+
+        noise_latent["samples"] = random_noise
+
+        return (noise_latent, )
+
+class TextEncodeForSamplerParams:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "text": ("STRING", {"multiline": True, "dynamicPrompts": True, "default": "Separate prompts with at least three dashes\n---\nLike so"}),
+                "clip": ("CLIP", )
+            }}
+
+    RETURN_TYPES = ("CONDITIONING", )
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/sampling"
+
+    def execute(self, text, clip):
+        import re
+        output_text = []
+        output_encoded = []
+        text = re.sub(r'[-*=~]{4,}\n', '---\n', text)
+        text = text.split("---\n")
+
+        for t in text:
+            t = t.strip()
+            if t:
+                output_text.append(t)
+                output_encoded.append(CLIPTextEncode().encode(clip, t)[0])
+
+        #if len(output_encoded) == 1:
+        #    output = output_encoded[0]
+        #else:
+        output = {"text": output_text, "encoded": output_encoded}
+
+        return (output, )
+
+class SamplerSelectHelper:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+            **{s: ("BOOLEAN", { "default": False }) for s in comfy.samplers.KSampler.SAMPLERS},
+        }}
+
+    RETURN_TYPES = ("STRING", )
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/sampling"
+
+    def execute(self, **values):
+        values = [v for v in values if values[v]]
+        values = ", ".join(values)
+
+        return (values, )
+
+class SchedulerSelectHelper:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+            **{s: ("BOOLEAN", { "default": False }) for s in comfy.samplers.KSampler.SCHEDULERS},
+        }}
+
+    RETURN_TYPES = ("STRING", )
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/sampling"
+
+    def execute(self, **values):
+        values = [v for v in values if values[v]]
+        values = ", ".join(values)
+
+        return (values, )
+
+class LorasForFluxParams:
+    @classmethod
+    def INPUT_TYPES(s):
+        optional_loras = ['none'] + folder_paths.get_filename_list("loras")
+        return {
+            "required": {
+                "lora_1": (folder_paths.get_filename_list("loras"), {"tooltip": "The name of the LoRA."}),
+                "strength_model_1": ("STRING", { "multiline": False, "dynamicPrompts": False, "default": "1.0" }),
+            },
+            #"optional": {
+            #    "lora_2": (optional_loras, ),
+            #    "strength_lora_2": ("STRING", { "multiline": False, "dynamicPrompts": False }),
+            #    "lora_3": (optional_loras, ),
+            #    "strength_lora_3": ("STRING", { "multiline": False, "dynamicPrompts": False }),
+            #    "lora_4": (optional_loras, ),
+            #    "strength_lora_4": ("STRING", { "multiline": False, "dynamicPrompts": False }),
+            #}
+        }
+
+    RETURN_TYPES = ("LORA_PARAMS", )
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/sampling"
+
+    def execute(self, lora_1, strength_model_1, lora_2="none", strength_lora_2="", lora_3="none", strength_lora_3="", lora_4="none", strength_lora_4=""):
+        output = { "loras": [], "strengths": [] }
+        output["loras"].append(lora_1)
+        output["strengths"].append(parse_string_to_list(strength_model_1))
+
+        if lora_2 != "none":
+            output["loras"].append(lora_2)
+            if strength_lora_2 == "":
+                strength_lora_2 = "1.0"
+            output["strengths"].append(parse_string_to_list(strength_lora_2))
+        if lora_3 != "none":
+            output["loras"].append(lora_3)
+            if strength_lora_3 == "":
+                strength_lora_3 = "1.0"
+            output["strengths"].append(parse_string_to_list(strength_lora_3))
+        if lora_4 != "none":
+            output["loras"].append(lora_4)
+            if strength_lora_4 == "":
+                strength_lora_4 = "1.0"
+            output["strengths"].append(parse_string_to_list(strength_lora_4))
+
+        return (output,)
+
+
+class FluxSamplerParams:
+    def __init__(self):
+        self.loraloader = None
+        self.lora = (None, None)
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                    "model": ("MODEL", ),
+                    "conditioning": ("CONDITIONING", ),
+                    "latent_image": ("LATENT", ),
+
+                    "seed": ("STRING", { "multiline": False, "dynamicPrompts": False, "default": "?" }),
+                    "sampler": ("STRING", { "multiline": False, "dynamicPrompts": False, "default": "euler" }),
+                    "scheduler": ("STRING", { "multiline": False, "dynamicPrompts": False, "default": "simple" }),
+                    "steps": ("STRING", { "multiline": False, "dynamicPrompts": False, "default": "20" }),
+                    "guidance": ("STRING", { "multiline": False, "dynamicPrompts": False, "default": "3.5" }),
+                    "max_shift": ("STRING", { "multiline": False, "dynamicPrompts": False, "default": "" }),
+                    "base_shift": ("STRING", { "multiline": False, "dynamicPrompts": False, "default": "" }),
+                    "denoise": ("STRING", { "multiline": False, "dynamicPrompts": False, "default": "1.0" }),
+                },
+                "optional": {
+                    "loras": ("LORA_PARAMS",),
+                }}
+
+    RETURN_TYPES = ("LATENT","SAMPLER_PARAMS")
+    RETURN_NAMES = ("latent", "params")
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/sampling"
+
+    def execute(self, model, conditioning, latent_image, seed, sampler, scheduler, steps, guidance, max_shift, base_shift, denoise, loras=None):
+        import random
+        import time
+        from comfy_extras.nodes_custom_sampler import Noise_RandomNoise, BasicScheduler, BasicGuider, SamplerCustomAdvanced
+        from comfy_extras.nodes_latent import LatentBatch
+        from comfy_extras.nodes_model_advanced import ModelSamplingFlux, ModelSamplingAuraFlow
+        from node_helpers import conditioning_set_values
+        from nodes import LoraLoader
+
+        is_schnell = model.model.model_type == comfy.model_base.ModelType.FLOW
+
+        noise = seed.replace("\n", ",").split(",")
+        noise = [random.randint(0, 999999) if "?" in n else int(n) for n in noise]
+        if not noise:
+            noise = [random.randint(0, 999999)]
+
+        if sampler == '*':
+            sampler = comfy.samplers.KSampler.SAMPLERS
+        elif sampler.startswith("!"):
+            sampler = sampler.replace("\n", ",").split(",")
+            sampler = [s.strip("! ") for s in sampler]
+            sampler = [s for s in comfy.samplers.KSampler.SAMPLERS if s not in sampler]
+        else:
+            sampler = sampler.replace("\n", ",").split(",")
+            sampler = [s.strip() for s in sampler if s.strip() in comfy.samplers.KSampler.SAMPLERS]
+        if not sampler:
+            sampler = ['ipndm']
+
+        if scheduler == '*':
+            scheduler = comfy.samplers.KSampler.SCHEDULERS
+        elif scheduler.startswith("!"):
+            scheduler = scheduler.replace("\n", ",").split(",")
+            scheduler = [s.strip("! ") for s in scheduler]
+            scheduler = [s for s in comfy.samplers.KSampler.SCHEDULERS if s not in scheduler]
+        else:
+            scheduler = scheduler.replace("\n", ",").split(",")
+            scheduler = [s.strip() for s in scheduler]
+            scheduler = [s for s in scheduler if s in comfy.samplers.KSampler.SCHEDULERS]
+        if not scheduler:
+            scheduler = ['simple']
+
+        if steps == "":
+            if is_schnell:
+                steps = "4"
+            else:
+                steps = "20"
+        steps = parse_string_to_list(steps)
+
+        denoise = "1.0" if denoise == "" else denoise
+        denoise = parse_string_to_list(denoise)
+
+        guidance = "3.5" if guidance == "" else guidance
+        guidance = parse_string_to_list(guidance)
+
+        if not is_schnell:
+            max_shift = "1.15" if max_shift == "" else max_shift
+            base_shift = "0.5" if base_shift == "" else base_shift
+        else:
+            max_shift = "0"
+            base_shift = "1.0" if base_shift == "" else base_shift
+
+        max_shift = parse_string_to_list(max_shift)
+        base_shift = parse_string_to_list(base_shift)
+
+        cond_text = None
+        if isinstance(conditioning, dict) and "encoded" in conditioning:
+            cond_text = conditioning["text"]
+            cond_encoded = conditioning["encoded"]
+        else:
+            cond_encoded = [conditioning]
+
+        out_latent = None
+        out_params = []
+
+        basicschedueler = BasicScheduler()
+        basicguider = BasicGuider()
+        samplercustomadvanced = SamplerCustomAdvanced()
+        latentbatch = LatentBatch()
+        modelsamplingflux = ModelSamplingFlux() if not is_schnell else ModelSamplingAuraFlow()
+        width = latent_image["samples"].shape[3]*8
+        height = latent_image["samples"].shape[2]*8
+
+        lora_strength_len = 1
+        if loras:
+            lora_model = loras["loras"]
+            lora_strength = loras["strengths"]
+            lora_strength_len = sum(len(i) for i in lora_strength)
+
+            if self.loraloader is None:
+                self.loraloader = LoraLoader()
+
+        # count total number of samples
+        total_samples = len(cond_encoded) * len(noise) * len(max_shift) * len(base_shift) * len(guidance) * len(sampler) * len(scheduler) * len(steps) * len(denoise) * lora_strength_len
+        current_sample = 0
+        if total_samples > 1:
+            pbar = ProgressBar(total_samples)
+
+        lora_strength_len = 1
+        if loras:
+            lora_strength_len = len(lora_strength[0])
+
+        for los in range(lora_strength_len):
+            if loras:
+                patched_model = self.loraloader.load_lora(model, None, lora_model[0], lora_strength[0][los], 0)[0]
+            else:
+                patched_model = model
+
+            for i in range(len(cond_encoded)):
+                conditioning = cond_encoded[i]
+                ct = cond_text[i] if cond_text else None
+                for n in noise:
+                    randnoise = Noise_RandomNoise(n)
+                    for ms in max_shift:
+                        for bs in base_shift:
+                            if is_schnell:
+                                work_model = modelsamplingflux.patch_aura(patched_model, bs)[0]
+                            else:
+                                work_model = modelsamplingflux.patch(patched_model, ms, bs, width, height)[0]
+                            for g in guidance:
+                                cond = conditioning_set_values(conditioning, {"guidance": g})
+                                guider = basicguider.get_guider(work_model, cond)[0]
+                                for s in sampler:
+                                    samplerobj = comfy.samplers.sampler_object(s)
+                                    for sc in scheduler:
+                                        for st in steps:
+                                            for d in denoise:
+                                                sigmas = basicschedueler.get_sigmas(work_model, sc, st, d)[0]
+                                                current_sample += 1
+                                                log = f"Sampling {current_sample}/{total_samples} with seed {n}, sampler {s}, scheduler {sc}, steps {st}, guidance {g}, max_shift {ms}, base_shift {bs}, denoise {d}"
+                                                lora_name = None
+                                                lora_str = 0
+                                                if loras:
+                                                    lora_name = lora_model[0]
+                                                    lora_str = lora_strength[0][los]
+                                                    log += f", lora {lora_name}, lora_strength {lora_str}"
+                                                logging.info(log)
+                                                start_time = time.time()
+                                                latent = samplercustomadvanced.sample(randnoise, guider, samplerobj, sigmas, latent_image)[1]
+                                                elapsed_time = time.time() - start_time
+                                                out_params.append({"time": elapsed_time,
+                                                                "seed": n,
+                                                                "width": width,
+                                                                "height": height,
+                                                                "sampler": s,
+                                                                "scheduler": sc,
+                                                                "steps": st,
+                                                                "guidance": g,
+                                                                "max_shift": ms,
+                                                                "base_shift": bs,
+                                                                "denoise": d,
+                                                                "prompt": ct,
+                                                                "lora": lora_name,
+                                                                "lora_strength": lora_str})
+
+                                                if out_latent is None:
+                                                    out_latent = latent
+                                                else:
+                                                    out_latent = latentbatch.batch(out_latent, latent)[0]
+                                                if total_samples > 1:
+                                                    pbar.update(1)
+
+        return (out_latent, out_params)
+
+class PlotParameters:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                    "images": ("IMAGE", ),
+                    "params": ("SAMPLER_PARAMS", ),
+                    "order_by": (["none", "time", "seed", "steps", "denoise", "sampler", "scheduler", "guidance", "max_shift", "base_shift", "lora_strength"], ),
+                    "cols_value": (["none", "time", "seed", "steps", "denoise", "sampler", "scheduler", "guidance", "max_shift", "base_shift", "lora_strength"], ),
+                    "cols_num": ("INT", {"default": -1, "min": -1, "max": 1024 }),
+                    "add_prompt": (["false", "true", "excerpt"], ),
+                    "add_params": (["false", "true", "changes only"], {"default": "true"}),
+                }}
+
+    RETURN_TYPES = ("IMAGE", )
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/sampling"
+
+    def execute(self, images, params, order_by, cols_value, cols_num, add_prompt, add_params):
+        from PIL import Image, ImageDraw, ImageFont
+        import math
+        import textwrap
+
+        if images.shape[0] != len(params):
+            raise ValueError("Number of images and number of parameters do not match.")
+
+        _params = params.copy()
+
+        if order_by != "none":
+            sorted_params = sorted(_params, key=lambda x: x[order_by])
+            indices = [_params.index(item) for item in sorted_params]
+            images = images[torch.tensor(indices)]
+            _params = sorted_params
+
+        if cols_value != "none" and cols_num > -1:
+            groups = {}
+            for p in _params:
+                value = p[cols_value]
+                if value not in groups:
+                    groups[value] = []
+                groups[value].append(p)
+            cols_num = len(groups)
+
+            sorted_params = []
+            groups = list(groups.values())
+            for g in zip(*groups):
+                sorted_params.extend(g)
+
+            indices = [_params.index(item) for item in sorted_params]
+            images = images[torch.tensor(indices)]
+            _params = sorted_params
+        elif cols_num == 0:
+            cols_num = int(math.sqrt(images.shape[0]))
+            cols_num = max(1, min(cols_num, 1024))
+
+        width = images.shape[2]
+        out_image = []
+
+        font = ImageFont.truetype(os.path.join(FONTS_DIR, 'ShareTechMono-Regular.ttf'), min(48, int(32*(width/1024))))
+        text_padding = 3
+        line_height = font.getmask('Q').getbbox()[3] + font.getmetrics()[1] + text_padding*2
+        char_width = font.getbbox('M')[2]+1 # using monospace font
+
+        if add_params == "changes only":
+            value_tracker = {}
+            for p in _params:
+                for key, value in p.items():
+                    if key != "time":
+                        if key not in value_tracker:
+                            value_tracker[key] = set()
+                        value_tracker[key].add(value)
+            changing_keys = {key for key, values in value_tracker.items() if len(values) > 1 or key == "prompt"}
+
+            result = []
+            for p in _params:
+                changing_params = {key: value for key, value in p.items() if key in changing_keys}
+                result.append(changing_params)
+
+            _params = result
+
+        for (image, param) in zip(images, _params):
+            image = image.permute(2, 0, 1)
+
+            if add_params != "false":
+                if add_params == "changes only":
+                    text = "\n".join([f"{key}: {value}" for key, value in param.items() if key != "prompt"])
+                else:
+                    text = f"time: {param['time']:.2f}s, seed: {param['seed']}, steps: {param['steps']}, size: {param['width']}×{param['height']}\ndenoise: {param['denoise']}, sampler: {param['sampler']}, sched: {param['scheduler']}\nguidance: {param['guidance']}, max/base shift: {param['max_shift']}/{param['base_shift']}"
+                    if 'lora' in param and param['lora']:
+                        text += f"\nLoRA: {param['lora'][:32]}, str: {param['lora_strength']}"
+
+                lines = text.split("\n")
+                text_height = line_height * len(lines)
+                text_image = Image.new('RGB', (width, text_height), color=(0, 0, 0))
+
+                for i, line in enumerate(lines):
+                    draw = ImageDraw.Draw(text_image)
+                    draw.text((text_padding, i * line_height + text_padding), line, font=font, fill=(255, 255, 255))
+
+                text_image = T.ToTensor()(text_image).to(image.device)
+                image = torch.cat([image, text_image], 1)
+
+            if 'prompt' in param and param['prompt'] and add_prompt != "false":
+                prompt = param['prompt']
+                if add_prompt == "excerpt":
+                    prompt = " ".join(param['prompt'].split()[:64])
+                    prompt += "..."
+
+                cols = math.ceil(width / char_width)
+                prompt_lines = textwrap.wrap(prompt, width=cols)
+                prompt_height = line_height * len(prompt_lines)
+                prompt_image = Image.new('RGB', (width, prompt_height), color=(0, 0, 0))
+
+                for i, line in enumerate(prompt_lines):
+                    draw = ImageDraw.Draw(prompt_image)
+                    draw.text((text_padding, i * line_height + text_padding), line, font=font, fill=(255, 255, 255))
+
+                prompt_image = T.ToTensor()(prompt_image).to(image.device)
+                image = torch.cat([image, prompt_image], 1)
+
+            # a little cleanup
+            image = torch.nan_to_num(image, nan=0.0).clamp(0.0, 1.0)
+            out_image.append(image)
+
+        # ensure all images have the same height
+        if add_prompt != "false" or add_params == "changes only":
+            max_height = max([image.shape[1] for image in out_image])
+            out_image = [F.pad(image, (0, 0, 0, max_height - image.shape[1])) for image in out_image]
+
+        out_image = torch.stack(out_image, 0).permute(0, 2, 3, 1)
+
+        # merge images
+        if cols_num > -1:
+            cols = min(cols_num, out_image.shape[0])
+            b, h, w, c = out_image.shape
+            rows = math.ceil(b / cols)
+
+            # Pad the tensor if necessary
+            if b % cols != 0:
+                padding = cols - (b % cols)
+                out_image = F.pad(out_image, (0, 0, 0, 0, 0, 0, 0, padding))
+                b = out_image.shape[0]
+
+            # Reshape and transpose
+            out_image = out_image.reshape(rows, cols, h, w, c)
+            out_image = out_image.permute(0, 2, 1, 3, 4)
+            out_image = out_image.reshape(rows * h, cols * w, c).unsqueeze(0)
+
+            """
+            width = out_image.shape[2]
+            # add the title and notes on top
+            if title and export_labels:
+                title_font = ImageFont.truetype(os.path.join(FONTS_DIR, 'ShareTechMono-Regular.ttf'), 48)
+                title_width = title_font.getbbox(title)[2]
+                title_padding = 6
+                title_line_height = title_font.getmask(title).getbbox()[3] + title_font.getmetrics()[1] + title_padding*2
+                title_text_height = title_line_height
+                title_text_image = Image.new('RGB', (width, title_text_height), color=(0, 0, 0, 0))
+
+                draw = ImageDraw.Draw(title_text_image)
+                draw.text((width//2 - title_width//2, title_padding), title, font=title_font, fill=(255, 255, 255))
+
+                title_text_image = T.ToTensor()(title_text_image).unsqueeze(0).permute([0,2,3,1]).to(out_image.device)
+                out_image = torch.cat([title_text_image, out_image], 1)
+            """
+
+        return (out_image, )
+
+class GuidanceTimestepping:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "model": ("MODEL",),
+                "value": ("FLOAT", {"default": 2.0, "min": 0.0, "max": 100.0, "step": 0.05}),
+                "start_at": ("FLOAT", {"default": 0.2, "min": 0.0, "max": 1.0, "step": 0.01}),
+                "end_at": ("FLOAT", {"default": 0.8, "min": 0.0, "max": 1.0, "step": 0.01}),
+            }
+        }
+
+    RETURN_TYPES = ("MODEL",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/sampling"
+
+    def execute(self, model, value, start_at, end_at):
+        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)
+
+        def apply_apg(args):
+            cond = args["cond"]
+            uncond = args["uncond"]
+            cond_scale = args["cond_scale"]
+            sigma = args["sigma"]
+
+            sigma = sigma.detach().cpu()[0].item()
+
+            if sigma <= sigma_start and sigma > sigma_end:
+                cond_scale = value
+
+            return uncond + (cond - uncond) * cond_scale
+        
+        m = model.clone()
+        m.set_model_sampler_cfg_function(apply_apg)
+        return (m,)
+
+class ModelSamplingDiscreteFlowCustom(torch.nn.Module):
+    def __init__(self, model_config=None):
+        super().__init__()
+        if model_config is not None:
+            sampling_settings = model_config.sampling_settings
+        else:
+            sampling_settings = {}
+
+        self.set_parameters(shift=sampling_settings.get("shift", 1.0), multiplier=sampling_settings.get("multiplier", 1000))
+
+    def set_parameters(self, shift=1.0, timesteps=1000, multiplier=1000, cut_off=1.0, shift_multiplier=0):
+        self.shift = shift
+        self.multiplier = multiplier
+        self.cut_off = cut_off
+        self.shift_multiplier = shift_multiplier
+        ts = self.sigma((torch.arange(1, timesteps + 1, 1) / timesteps) * multiplier)
+        self.register_buffer('sigmas', ts)
+
+    @property
+    def sigma_min(self):
+        return self.sigmas[0]
+
+    @property
+    def sigma_max(self):
+        return self.sigmas[-1]
+
+    def timestep(self, sigma):
+        return sigma * self.multiplier
+
+    def sigma(self, timestep):
+        shift = self.shift
+        if timestep.dim() == 0:
+            t = timestep.cpu().item() / self.multiplier
+            if t <= self.cut_off:
+                shift = shift * self.shift_multiplier
+            
+        return comfy.model_sampling.time_snr_shift(shift, timestep / self.multiplier)
+
+    def percent_to_sigma(self, percent):
+        if percent <= 0.0:
+            return 1.0
+        if percent >= 1.0:
+            return 0.0
+        return 1.0 - percent
+
+class ModelSamplingSD3Advanced:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { "model": ("MODEL",),
+                              "shift": ("FLOAT", {"default": 3.0, "min": 0.0, "max": 100.0, "step":0.01}),
+                              "cut_off": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step":0.05}),
+                              "shift_multiplier": ("FLOAT", {"default": 2, "min": 0, "max": 10, "step":0.05}),
+                              }}
+
+    RETURN_TYPES = ("MODEL",)
+    FUNCTION = "execute"
+
+    CATEGORY = "essentials_mb/sampling"
+
+    def execute(self, model, shift, multiplier=1000, cut_off=1.0, shift_multiplier=0):
+        m = model.clone()
+        
+
+        sampling_base = ModelSamplingDiscreteFlowCustom
+        sampling_type = comfy.model_sampling.CONST
+
+        class ModelSamplingAdvanced(sampling_base, sampling_type):
+            pass
+
+        model_sampling = ModelSamplingAdvanced(model.model.model_config)
+        model_sampling.set_parameters(shift=shift, multiplier=multiplier, cut_off=cut_off, shift_multiplier=shift_multiplier)
+        m.add_object_patch("model_sampling", model_sampling)
+
+        return (m, )
+
+SAMPLING_CLASS_MAPPINGS = {
+    "KSamplerVariationsStochastic+": KSamplerVariationsStochastic,
+    "KSamplerVariationsWithNoise+": KSamplerVariationsWithNoise,
+    "InjectLatentNoise+": InjectLatentNoise,
+    "FluxSamplerParams+": FluxSamplerParams,
+    "GuidanceTimestepping+": GuidanceTimestepping,
+    "PlotParameters+": PlotParameters,
+    "TextEncodeForSamplerParams+": TextEncodeForSamplerParams,
+    "SamplerSelectHelper+": SamplerSelectHelper,
+    "SchedulerSelectHelper+": SchedulerSelectHelper,
+    "LorasForFluxParams+": LorasForFluxParams,
+    "ModelSamplingSD3Advanced+": ModelSamplingSD3Advanced,
+}
+
+SAMPLING_NAME_MAPPINGS = {
+    "KSamplerVariationsStochastic+": "🔧 KSampler Stochastic Variations",
+    "KSamplerVariationsWithNoise+": "🔧 KSampler Variations with Noise Injection",
+    "InjectLatentNoise+": "🔧 Inject Latent Noise",
+    "FluxSamplerParams+": "🔧 Flux Sampler Parameters",
+    "GuidanceTimestepping+": "🔧 Guidance Timestep (experimental)",
+    "PlotParameters+": "🔧 Plot Sampler Parameters",
+    "TextEncodeForSamplerParams+": "🔧Text Encode for Sampler Params",
+    "SamplerSelectHelper+": "🔧 Sampler Select Helper",
+    "SchedulerSelectHelper+": "🔧 Scheduler Select Helper",
+    "LorasForFluxParams+": "🔧 LoRA for Flux Parameters",
+    "ModelSamplingSD3Advanced+": "🔧 Model Sampling SD3 Advanced",
+}

segmentation.py

@@ -0,0 +1,89 @@
+import torch
+import torchvision.transforms.v2 as T
+import torch.nn.functional as F
+from .utils import expand_mask
+
+class LoadCLIPSegModels:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {},
+        }
+
+    RETURN_TYPES = ("CLIP_SEG",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/segmentation"
+
+    def execute(self):
+        from transformers import CLIPSegProcessor, CLIPSegForImageSegmentation
+        processor = CLIPSegProcessor.from_pretrained("CIDAS/clipseg-rd64-refined")
+        model = CLIPSegForImageSegmentation.from_pretrained("CIDAS/clipseg-rd64-refined")
+
+        return ((processor, model),)
+
+class ApplyCLIPSeg:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "clip_seg": ("CLIP_SEG",),
+                "image": ("IMAGE",),
+                "prompt": ("STRING", { "multiline": False, "default": "" }),
+                "threshold": ("FLOAT", { "default": 0.4, "min": 0.0, "max": 1.0, "step": 0.05 }),
+                "smooth": ("INT", { "default": 9, "min": 0, "max": 32, "step": 1 }),
+                "dilate": ("INT", { "default": 0, "min": -32, "max": 32, "step": 1 }),
+                "blur": ("INT", { "default": 0, "min": 0, "max": 64, "step": 1 }),
+            },
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/segmentation"
+
+    def execute(self, image, clip_seg, prompt, threshold, smooth, dilate, blur):
+        processor, model = clip_seg
+
+        imagenp = image.mul(255).clamp(0, 255).byte().cpu().numpy()
+
+        outputs = []
+        for i in imagenp:
+            inputs = processor(text=prompt, images=[i], return_tensors="pt")
+            out = model(**inputs)
+            out = out.logits.unsqueeze(1)
+            out = torch.sigmoid(out[0][0])
+            out = (out > threshold)
+            outputs.append(out)
+
+        del imagenp
+
+        outputs = torch.stack(outputs, dim=0)
+
+        if smooth > 0:
+            if smooth % 2 == 0:
+                smooth += 1
+            outputs = T.functional.gaussian_blur(outputs, smooth)
+
+        outputs = outputs.float()
+
+        if dilate != 0:
+            outputs = expand_mask(outputs, dilate, True)
+
+        if blur > 0:
+            if blur % 2 == 0:
+                blur += 1
+            outputs = T.functional.gaussian_blur(outputs, blur)
+        
+        # resize to original size
+        outputs = F.interpolate(outputs.unsqueeze(1), size=(image.shape[1], image.shape[2]), mode='bicubic').squeeze(1)
+
+        return (outputs,)
+
+SEG_CLASS_MAPPINGS = {
+    "ApplyCLIPSeg+": ApplyCLIPSeg,
+    "LoadCLIPSegModels+": LoadCLIPSegModels,
+}
+
+SEG_NAME_MAPPINGS = {
+    "ApplyCLIPSeg+": "🔧 Apply CLIPSeg",
+    "LoadCLIPSegModels+": "🔧 Load CLIPSeg Models",
+}

text.py

@@ -0,0 +1,163 @@
+import os
+import torch
+from nodes import MAX_RESOLUTION
+import torchvision.transforms.v2 as T
+from .utils import FONTS_DIR
+import logging
+
+class DrawText:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "text": ("STRING", { "multiline": True, "dynamicPrompts": True, "default": "Hello, World!" }),
+                "font": (sorted([f for f in os.listdir(FONTS_DIR) if f.endswith('.ttf') or f.endswith('.otf')]), ),
+                "size": ("INT", { "default": 56, "min": 1, "max": 9999, "step": 1 }),
+                # "color": ("STRING", { "multiline": False, "default": "#FFFFFF" }),
+                "color": ("COLOR", {"default": "#FFFFFF"}),
+                "alpha": ("INT", { "default": 255, "min": 0, "max": 255, "step": 1 }),
+                # "background_color": ("STRING", { "multiline": False, "default": "#00000000" }),
+                "background_color": ("COLOR", {"default": "#000000"}),
+                "background_alpha": ("INT", { "default": 0, "min": 0, "max": 255, "step": 1 }),
+                "shadow_distance": ("INT", { "default": 0, "min": 0, "max": 100, "step": 1 }),
+                "shadow_blur": ("INT", { "default": 0, "min": 0, "max": 100, "step": 1 }),
+                "shadow_color": ("STRING", { "multiline": False, "default": "#000000" }),
+                "horizontal_align": (["left", "center", "right"],),
+                "vertical_align": (["top", "center", "bottom"],),
+                "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 }),
+                "direction": (["ltr", "rtl"],),
+            },
+            "optional": {
+                "img_composite": ("IMAGE",),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE", "MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials_mb/text"
+
+    def execute(self, text, font, size, color, alpha, background_color, background_alpha, shadow_distance, shadow_blur, shadow_color, horizontal_align, vertical_align, offset_x, offset_y, direction, img_composite=None):
+        from PIL import Image, ImageDraw, ImageFont, ImageColor, ImageFilter
+
+        logging.info(f"color a: {color}")
+        logging.info(f"alpha a: {alpha}")
+        # 判断color格式(HEX/RGB/HSL)，以加上透明度alpha
+        if isinstance(color, str) and color.startswith("#"):
+            if len(color) == 7: # HEX
+                color = color + hex(alpha)[2:].zfill(2)
+            elif len(color) == 9: 
+                color = color[:7] + hex(alpha)[2:].zfill(2)
+            else:
+                raise ValueError("Invalid HEX color format")
+        elif isinstance(color, tuple): # RGB/HSL
+            if len(color) == 3: # RGB
+                color = color + (alpha,)
+            elif len(color) == 4: # HSL
+                color = color[:3] + (alpha,)
+        else:
+            # raise ValueError("Invalid color format")
+            logging.error("Invalid color format")
+            color = "#FFFFFF"        
+        logging.info(f"color b: {color}")
+        logging.info(f"alpha b: {alpha}")
+
+
+        logging.info(f"background_color a: {background_color}")
+        logging.info(f"background_alpha a: {background_alpha}")
+        # 判断background_color格式(HEX/RGB/HSL)，以加上透明度background_alpha
+        if isinstance(background_color, str) and background_color.startswith("#"):
+            if len(background_color) == 7: # HEX
+                background_color = background_color + hex(background_alpha)[2:].zfill(2)
+            elif len(background_color) == 9: 
+                background_color = background_color[:7] + hex(background_alpha)[2:].zfill(2)
+            else:
+                raise ValueError("Invalid HEX color format")
+        elif isinstance(background_color, tuple): # RGB/HSL
+            if len(background_color) == 3: # RGB
+                background_color = background_color + (background_alpha,)
+            elif len(background_color) == 4: # HSL
+                background_color = background_color[:3] + (background_alpha,)
+        else:
+            # raise ValueError("Invalid color format")
+            logging.error("Invalid background_color format")
+            background_color = (0,0,0,0)
+        logging.info(f"background_color b: {background_color}")
+        logging.info(f"background_alpha b: {background_alpha}")
+
+        font = ImageFont.truetype(os.path.join(FONTS_DIR, font), size)
+
+        lines = text.split("\n")
+        if direction == "rtl":
+            lines = [line[::-1] for line in lines]
+
+        # Calculate the width and height of the text
+        text_width = max(font.getbbox(line)[2] for line in lines)
+        line_height = font.getmask(text).getbbox()[3] + font.getmetrics()[1]  # add descent to height
+        text_height = line_height * len(lines)
+
+        if img_composite is not None:
+            img_composite = T.ToPILImage()(img_composite.permute([0,3,1,2])[0]).convert('RGBA')
+            width = img_composite.width
+            height = img_composite.height
+            image = Image.new('RGBA', (width, height), color=background_color)
+        else:
+            width = text_width
+            height = text_height
+            background_color = ImageColor.getrgb(background_color)
+            image = Image.new('RGBA', (width + shadow_distance, height + shadow_distance), color=background_color)
+
+        image_shadow = None
+        if shadow_distance > 0:
+            image_shadow = image.copy()
+            #image_shadow = Image.new('RGBA', (width + shadow_distance, height + shadow_distance), color=background_color)
+
+        for i, line in enumerate(lines):
+            line_width = font.getbbox(line)[2]
+            #text_height =font.getbbox(line)[3]
+            if horizontal_align == "left":
+                x = 0
+            elif horizontal_align == "center":
+                x = (width - line_width) / 2
+            elif horizontal_align == "right":
+                x = width - line_width
+            
+            if vertical_align == "top":
+                y = 0
+            elif vertical_align == "center":
+                y = (height - text_height) / 2
+            elif vertical_align == "bottom":
+                y = height - text_height
+
+            x += offset_x
+            y += i * line_height + offset_y
+
+            draw = ImageDraw.Draw(image)
+            draw.text((x, y), line, font=font, fill=color)
+
+            if image_shadow is not None:
+                draw = ImageDraw.Draw(image_shadow)
+                draw.text((x + shadow_distance, y + shadow_distance), line, font=font, fill=shadow_color)
+
+        if image_shadow is not None:
+            image_shadow = image_shadow.filter(ImageFilter.GaussianBlur(shadow_blur))
+            image = Image.alpha_composite(image_shadow, image)
+
+        #image = T.ToTensor()(image).unsqueeze(0).permute([0,2,3,1])
+        mask = T.ToTensor()(image).unsqueeze(0).permute([0,2,3,1])
+        mask = mask[:, :, :, 3] if mask.shape[3] == 4 else torch.ones_like(mask[:, :, :, 0])
+
+        if img_composite is not None:
+            image = Image.alpha_composite(img_composite, image)
+        
+        image = T.ToTensor()(image).unsqueeze(0).permute([0,2,3,1])
+
+        return (image[:, :, :, :3], mask,)
+
+TEXT_CLASS_MAPPINGS = {
+    "DrawText+": DrawText,
+}
+
+TEXT_NAME_MAPPINGS = {
+    "DrawText+": "🔧 Draw Text",
+}

utils.py

@@ -0,0 +1,89 @@
+import torch
+import numpy as np
+import scipy
+import os
+#import re
+from pathlib import Path
+import folder_paths
+
+FONTS_DIR = os.path.join(os.path.dirname(os.path.realpath(__file__)), "fonts")
+
+SCRIPT_DIR = Path(__file__).parent
+folder_paths.add_model_folder_path("luts", (SCRIPT_DIR / "luts").as_posix())
+folder_paths.add_model_folder_path(
+    "luts", (Path(folder_paths.models_dir) / "luts").as_posix()
+)
+
+# from https://github.com/pythongosssss/ComfyUI-Custom-Scripts
+class AnyType(str):
+    def __ne__(self, __value: object) -> bool:
+        return False
+
+def min_(tensor_list):
+    # return the element-wise min of the tensor list.
+    x = torch.stack(tensor_list)
+    mn = x.min(axis=0)[0]
+    return torch.clamp(mn, min=0)
+
+def max_(tensor_list):
+    # return the element-wise max of the tensor list.
+    x = torch.stack(tensor_list)
+    mx = x.max(axis=0)[0]
+    return torch.clamp(mx, max=1)
+
+def expand_mask(mask, expand, tapered_corners):
+    c = 0 if tapered_corners else 1
+    kernel = np.array([[c, 1, c],
+                       [1, 1, 1],
+                       [c, 1, c]])
+    mask = mask.reshape((-1, mask.shape[-2], mask.shape[-1]))
+    out = []
+    for m in mask:
+        output = m.numpy()
+        for _ in range(abs(expand)):
+            if expand < 0:
+                output = scipy.ndimage.grey_erosion(output, footprint=kernel)
+            else:
+                output = scipy.ndimage.grey_dilation(output, footprint=kernel)
+        output = torch.from_numpy(output)
+        out.append(output)
+
+    return torch.stack(out, dim=0)
+
+def parse_string_to_list(s):
+    elements = s.split(',')
+    result = []
+
+    def parse_number(s):
+        try:
+            if '.' in s:
+                return float(s)
+            else:
+                return int(s)
+        except ValueError:
+            return 0
+
+    def decimal_places(s):
+        if '.' in s:
+            return len(s.split('.')[1])
+        return 0
+
+    for element in elements:
+        element = element.strip()
+        if '...' in element:
+            start, rest = element.split('...')
+            end, step = rest.split('+')
+            decimals = decimal_places(step)
+            start = parse_number(start)
+            end = parse_number(end)
+            step = parse_number(step)
+            current = start
+            if (start > end and step > 0) or (start < end and step < 0):
+                step = -step
+            while current <= end:
+                result.append(round(current, decimals))
+                current += step
+        else:
+            result.append(round(parse_number(element), decimal_places(element)))
+
+    return result

workflow_all_nodes.json

@@ -0,0 +1,994 @@
+{
+  "last_node_id": 42,
+  "last_link_id": 61,
+  "nodes": [
+    {
+      "id": 9,
+      "type": "ConsoleDebug+",
+      "pos": [
+        720,
+        140
+      ],
+      "size": {
+        "0": 210,
+        "1": 60
+      },
+      "flags": {},
+      "order": 12,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "value",
+          "type": "*",
+          "link": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ConsoleDebug+"
+      },
+      "widgets_values": [
+        "Height:"
+      ]
+    },
+    {
+      "id": 28,
+      "type": "PreviewImage",
+      "pos": [
+        860,
+        1180
+      ],
+      "size": {
+        "0": 210,
+        "1": 246
+      },
+      "flags": {},
+      "order": 17,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 23
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 12,
+      "type": "PreviewImage",
+      "pos": [
+        860,
+        580
+      ],
+      "size": {
+        "0": 210,
+        "1": 246
+      },
+      "flags": {},
+      "order": 15,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 11
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 14,
+      "type": "PreviewImage",
+      "pos": [
+        860,
+        880
+      ],
+      "size": {
+        "0": 210,
+        "1": 246
+      },
+      "flags": {},
+      "order": 16,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 13
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 18,
+      "type": "MaskPreview+",
+      "pos": [
+        2100,
+        90
+      ],
+      "size": {
+        "0": 210,
+        "1": 246
+      },
+      "flags": {},
+      "order": 20,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": 19
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "MaskPreview+"
+      }
+    },
+    {
+      "id": 1,
+      "type": "GetImageSize+",
+      "pos": [
+        450,
+        80
+      ],
+      "size": {
+        "0": 210,
+        "1": 46
+      },
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 1
+        }
+      ],
+      "outputs": [
+        {
+          "name": "width",
+          "type": "INT",
+          "links": [
+            2
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "height",
+          "type": "INT",
+          "links": [
+            3
+          ],
+          "shape": 3,
+          "slot_index": 1
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "GetImageSize+"
+      }
+    },
+    {
+      "id": 8,
+      "type": "ConsoleDebug+",
+      "pos": [
+        720,
+        40
+      ],
+      "size": {
+        "0": 210,
+        "1": 60
+      },
+      "flags": {},
+      "order": 11,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "value",
+          "type": "*",
+          "link": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ConsoleDebug+"
+      },
+      "widgets_values": [
+        "Width:"
+      ]
+    },
+    {
+      "id": 10,
+      "type": "PreviewImage",
+      "pos": [
+        860,
+        280
+      ],
+      "size": {
+        "0": 210,
+        "1": 246
+      },
+      "flags": {},
+      "order": 13,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 9
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 36,
+      "type": "SimpleMath+",
+      "pos": [
+        1650,
+        780
+      ],
+      "size": {
+        "0": 210,
+        "1": 80
+      },
+      "flags": {},
+      "order": 14,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "a",
+          "type": "INT,FLOAT",
+          "link": 44
+        },
+        {
+          "name": "b",
+          "type": "INT,FLOAT",
+          "link": 45
+        }
+      ],
+      "outputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": [
+            46
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "FLOAT",
+          "type": "FLOAT",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "SimpleMath+"
+      },
+      "widgets_values": [
+        "a*b"
+      ]
+    },
+    {
+      "id": 23,
+      "type": "ConsoleDebug+",
+      "pos": [
+        1920,
+        780
+      ],
+      "size": {
+        "0": 210,
+        "1": 60
+      },
+      "flags": {},
+      "order": 22,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "value",
+          "type": "*",
+          "link": 46
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ConsoleDebug+"
+      },
+      "widgets_values": [
+        "Value:"
+      ]
+    },
+    {
+      "id": 2,
+      "type": "ImageResize+",
+      "pos": [
+        430,
+        340
+      ],
+      "size": {
+        "0": 310,
+        "1": 170
+      },
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 4
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            9
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "width",
+          "type": "INT",
+          "links": [
+            44
+          ],
+          "shape": 3,
+          "slot_index": 1
+        },
+        {
+          "name": "height",
+          "type": "INT",
+          "links": [
+            45
+          ],
+          "shape": 3,
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ImageResize+"
+      },
+      "widgets_values": [
+        256,
+        64,
+        "lanczos",
+        true
+      ]
+    },
+    {
+      "id": 4,
+      "type": "ImageFlip+",
+      "pos": [
+        430,
+        800
+      ],
+      "size": {
+        "0": 310,
+        "1": 60
+      },
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 6
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            11
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ImageFlip+"
+      },
+      "widgets_values": [
+        "xy"
+      ]
+    },
+    {
+      "id": 6,
+      "type": "ImagePosterize+",
+      "pos": [
+        430,
+        1000
+      ],
+      "size": {
+        "0": 310,
+        "1": 60
+      },
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 8
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            13
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ImagePosterize+"
+      },
+      "widgets_values": [
+        0.5
+      ]
+    },
+    {
+      "id": 27,
+      "type": "ImageCASharpening+",
+      "pos": [
+        430,
+        1110
+      ],
+      "size": {
+        "0": 310.79998779296875,
+        "1": 60
+      },
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 22
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            23
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ImageCASharpening+"
+      },
+      "widgets_values": [
+        0.8
+      ]
+    },
+    {
+      "id": 15,
+      "type": "MaskBlur+",
+      "pos": [
+        1690,
+        130
+      ],
+      "size": {
+        "0": 310,
+        "1": 82
+      },
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": 14
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": [
+            19
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "MaskBlur+"
+      },
+      "widgets_values": [
+        45,
+        28.5
+      ]
+    },
+    {
+      "id": 16,
+      "type": "MaskFlip+",
+      "pos": [
+        1690,
+        270
+      ],
+      "size": {
+        "0": 310,
+        "1": 60
+      },
+      "flags": {},
+      "order": 10,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": 15
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": [
+            18
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "MaskFlip+"
+      },
+      "widgets_values": [
+        "xy"
+      ]
+    },
+    {
+      "id": 13,
+      "type": "PreviewImage",
+      "pos": [
+        1100,
+        760
+      ],
+      "size": {
+        "0": 210,
+        "1": 246
+      },
+      "flags": {},
+      "order": 18,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 49
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 37,
+      "type": "ImageDesaturate+",
+      "pos": [
+        500,
+        920
+      ],
+      "size": {
+        "0": 190,
+        "1": 30
+      },
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 48
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            49
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ImageDesaturate+"
+      }
+    },
+    {
+      "id": 7,
+      "type": "LoadImage",
+      "pos": [
+        -90,
+        650
+      ],
+      "size": {
+        "0": 315,
+        "1": 314
+      },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            1,
+            4,
+            6,
+            8,
+            22,
+            48,
+            57
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "venere.jpg",
+        "image"
+      ]
+    },
+    {
+      "id": 11,
+      "type": "PreviewImage",
+      "pos": [
+        1100,
+        450
+      ],
+      "size": {
+        "0": 210,
+        "1": 246
+      },
+      "flags": {},
+      "order": 19,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 58
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 40,
+      "type": "ImageCrop+",
+      "pos": [
+        430,
+        560
+      ],
+      "size": {
+        "0": 310,
+        "1": 194
+      },
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 57
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            58
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "x",
+          "type": "INT",
+          "links": null,
+          "shape": 3
+        },
+        {
+          "name": "y",
+          "type": "INT",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ImageCrop+"
+      },
+      "widgets_values": [
+        256,
+        256,
+        "center",
+        0,
+        0
+      ]
+    },
+    {
+      "id": 20,
+      "type": "LoadImageMask",
+      "pos": [
+        1400,
+        260
+      ],
+      "size": {
+        "0": 220.70516967773438,
+        "1": 318
+      },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": [
+            14,
+            15
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadImageMask"
+      },
+      "widgets_values": [
+        "cwf_inpaint_example_mask.png",
+        "alpha",
+        "image"
+      ]
+    },
+    {
+      "id": 21,
+      "type": "MaskPreview+",
+      "pos": [
+        2100,
+        380
+      ],
+      "size": {
+        "0": 210,
+        "1": 246
+      },
+      "flags": {},
+      "order": 21,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": 18
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "MaskPreview+"
+      }
+    }
+  ],
+  "links": [
+    [
+      1,
+      7,
+      0,
+      1,
+      0,
+      "IMAGE"
+    ],
+    [
+      2,
+      1,
+      0,
+      8,
+      0,
+      "*"
+    ],
+    [
+      3,
+      1,
+      1,
+      9,
+      0,
+      "*"
+    ],
+    [
+      4,
+      7,
+      0,
+      2,
+      0,
+      "IMAGE"
+    ],
+    [
+      6,
+      7,
+      0,
+      4,
+      0,
+      "IMAGE"
+    ],
+    [
+      8,
+      7,
+      0,
+      6,
+      0,
+      "IMAGE"
+    ],
+    [
+      9,
+      2,
+      0,
+      10,
+      0,
+      "IMAGE"
+    ],
+    [
+      11,
+      4,
+      0,
+      12,
+      0,
+      "IMAGE"
+    ],
+    [
+      13,
+      6,
+      0,
+      14,
+      0,
+      "IMAGE"
+    ],
+    [
+      14,
+      20,
+      0,
+      15,
+      0,
+      "MASK"
+    ],
+    [
+      15,
+      20,
+      0,
+      16,
+      0,
+      "MASK"
+    ],
+    [
+      18,
+      16,
+      0,
+      21,
+      0,
+      "MASK"
+    ],
+    [
+      19,
+      15,
+      0,
+      18,
+      0,
+      "MASK"
+    ],
+    [
+      22,
+      7,
+      0,
+      27,
+      0,
+      "IMAGE"
+    ],
+    [
+      23,
+      27,
+      0,
+      28,
+      0,
+      "IMAGE"
+    ],
+    [
+      44,
+      2,
+      1,
+      36,
+      0,
+      "INT,FLOAT"
+    ],
+    [
+      45,
+      2,
+      2,
+      36,
+      1,
+      "INT,FLOAT"
+    ],
+    [
+      46,
+      36,
+      0,
+      23,
+      0,
+      "*"
+    ],
+    [
+      48,
+      7,
+      0,
+      37,
+      0,
+      "IMAGE"
+    ],
+    [
+      49,
+      37,
+      0,
+      13,
+      0,
+      "IMAGE"
+    ],
+    [
+      57,
+      7,
+      0,
+      40,
+      0,
+      "IMAGE"
+    ],
+    [
+      58,
+      40,
+      0,
+      11,
+      0,
+      "IMAGE"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}