Upload 2 files

Batch_Sprites_BBox_Cropper.py

@@ -0,0 +1,129 @@
+import torch
+
+class Batch_Sprite_BBox_Cropper:
+    """
+    ComfyUI custom node:
+    - Takes a batch of RGBA images (or RGB+MASK).
+    - Alpha clamp: alpha <= (alpha_cutoff / 255) -> 0
+    - Computes one global bounding box of visible pixels across the entire batch
+    - Crops every image to the same bbox (spritesheet-safe)
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "images": ("IMAGE",),
+                # User requirement: cutoff default = 10 (out of 255)
+                "alpha_cutoff": ("INT", {"default": 10, "min": 0, "max": 255, "step": 1}),
+                "verbose": ("BOOLEAN", {"default": True}),
+            },
+            # Optional: if you only have RGB image + separate alpha mask (common in ComfyUI)
+            "optional": {
+                "mask": ("MASK",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "INT", "INT", "INT", "INT", "INT", "INT")
+    RETURN_NAMES = ("cropped_images", "left", "top", "right", "bottom", "crop_width", "crop_height")
+    FUNCTION = "process"
+    CATEGORY = "image/alpha"
+
+    def process(self, images, alpha_cutoff=10, verbose=True, mask=None):
+        """
+        images: torch tensor [B, H, W, C] typically float32 in [0,1]
+        mask:   torch tensor [B, H, W] or [H, W] in [0,1] (optional)
+        """
+
+        if not isinstance(images, torch.Tensor):
+            raise TypeError("images must be a torch.Tensor")
+
+        if images.dim() != 4:
+            raise ValueError(f"images must be [B,H,W,C], got shape {tuple(images.shape)}")
+
+        B, H, W, C = images.shape
+
+        # Build RGBA tensor
+        if C == 4:
+            rgba = images.clone()
+        elif C == 3:
+            if mask is None:
+                raise ValueError(
+                    "Input images are RGB (C=3). Provide a MASK input or pass RGBA (C=4)."
+                )
+            # Normalize mask to [B,H,W]
+            if mask.dim() == 2:
+                mask_b = mask.unsqueeze(0).expand(B, -1, -1)
+            elif mask.dim() == 3:
+                mask_b = mask
+            else:
+                raise ValueError(f"mask must be [H,W] or [B,H,W], got shape {tuple(mask.shape)}")
+
+            if mask_b.shape[0] != B or mask_b.shape[1] != H or mask_b.shape[2] != W:
+                raise ValueError(
+                    f"mask shape {tuple(mask_b.shape)} must match images batch/height/width {(B,H,W)}"
+                )
+
+            rgba = torch.cat([images, mask_b.unsqueeze(-1)], dim=-1).clone()
+        else:
+            raise ValueError(f"Expected images with 3 (RGB) or 4 (RGBA) channels, got C={C}")
+
+        # 1) Alpha clamp: alpha <= (alpha_cutoff/255) -> 0
+        threshold = float(alpha_cutoff) / 255.0
+        alpha = rgba[..., 3]
+        rgba[..., 3] = torch.where(alpha <= threshold, torch.zeros_like(alpha), alpha)
+
+        # 2) Global bbox of visible pixels across batch (alpha > 0 after clamp)
+        visible = rgba[..., 3] > 0  # [B,H,W] boolean
+        if not torch.any(visible):
+            # Nothing visible after clamp; skip crop
+            if verbose:
+                print(
+                    f"[RGBABatchAlphaClampGlobalCrop] No visible pixels after clamp "
+                    f"(alpha_cutoff={alpha_cutoff}). Returning unchanged RGBA."
+                )
+            left = 0
+            top = 0
+            right = W - 1
+            bottom = H - 1
+            crop_w = W
+            crop_h = H
+            return (rgba, left, top, right, bottom, crop_w, crop_h)
+
+        # Union visibility across batch -> [H,W]
+        union = torch.any(visible, dim=0)
+
+        ys = torch.any(union, dim=1)  # [H]
+        xs = torch.any(union, dim=0)  # [W]
+
+        y_idx = torch.nonzero(ys, as_tuple=False).squeeze(1)
+        x_idx = torch.nonzero(xs, as_tuple=False).squeeze(1)
+
+        top = int(y_idx[0].item())
+        bottom = int(y_idx[-1].item())
+        left = int(x_idx[0].item())
+        right = int(x_idx[-1].item())
+
+        # 3) Crop all images to the same rect (inclusive right/bottom)
+        cropped = rgba[:, top:bottom + 1, left:right + 1, :]
+
+        crop_w = right - left + 1
+        crop_h = bottom - top + 1
+
+        if verbose:
+            print(
+                f"[RGBABatchAlphaClampGlobalCrop] alpha_cutoff={alpha_cutoff} "
+                f"-> rect: left={left}, top={top}, right={right}, bottom={bottom} "
+                f"(w={crop_w}, h={crop_h}), batch={B}"
+            )
+
+        return (cropped, left, top, right, bottom, crop_w, crop_h)
+
+
+NODE_CLASS_MAPPINGS = {
+    "Batch_Sprite_BBox_Cropper": Batch_Sprite_BBox_Cropper
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "Batch_Sprite_BBox_Cropper": "Batch_Sprite_BBox_Cropper"
+}

Batchfilter.py

@@ -0,0 +1,113 @@
+import torch
+from typing import List
+
+
+class BatchFilterKeepFirstLast:
+    """
+    Batch filter node (IMAGE -> IMAGE) that always keeps the first and last image.
+
+    Modes (int):
+      - 0  : passthrough (no changes)
+      - 10 : keep 1st, 3rd, 5th, ... (drop every 2nd), but always keep last
+      - <10: keep slightly MORE than mode 10 (adds back frames, evenly distributed)
+      - >10: keep slightly FEWER than mode 10 (removes extra frames, evenly distributed)
+
+    Notes:
+      - In ComfyUI, IMAGE is a batch (torch.Tensor) of shape [B, H, W, C]. We only filter B. :contentReference[oaicite:2]{index=2}
+      - Works with RGBA (C=4) or RGB (C=3) since we do not modify channels.
+    """
+
+    CATEGORY = "image/batch"
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("images",)
+    FUNCTION = "filter_batch"
+
+    # How much each +/-1 step away from mode 10 adjusts the batch, as a fraction of B.
+    # With your reference batch size B=40:
+    #   round(40 * 0.05) = 2 images per step (i.e., mode 9 adds ~2; mode 11 removes ~2).
+    ADJUST_PER_STEP_FRACTION = 0.05
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "images": ("IMAGE",),
+                "mode": ("INT", {"default": 10, "min": 0, "max": 20, "step": 1}),
+            }
+        }
+
+    def filter_batch(self, images: torch.Tensor, mode: int):
+        if not isinstance(images, torch.Tensor):
+            raise TypeError("images must be a torch.Tensor")
+
+        if images.ndim != 4:
+            raise ValueError(f"Expected images with shape [B,H,W,C], got {tuple(images.shape)}")
+
+        b = int(images.shape[0])
+        if b <= 1 or mode == 0:
+            return (images,)
+
+        # Base pattern for mode 10: keep 0,2,4,... plus always keep last.
+        keep = list(range(0, b, 2))
+        if (b - 1) not in keep:
+            keep.append(b - 1)
+        keep = sorted(set(keep))
+
+        if mode != 10:
+            delta = mode - 10  # <0 => keep more, >0 => keep fewer
+            step = max(1, int(round(b * self.ADJUST_PER_STEP_FRACTION)))
+
+            min_keep = 1 if b == 1 else 2  # first+last (or just one if batch=1)
+
+            if delta < 0:
+                # Add frames back from those we dropped, evenly spread.
+                add_count = min((-delta) * step, b - len(keep))
+                if add_count > 0:
+                    candidates = [i for i in range(b) if i not in keep and i not in (0, b - 1)]
+                    add_idxs = self._evenly_pick(candidates, add_count)
+                    keep = sorted(set(keep + add_idxs))
+
+            elif delta > 0:
+                # Remove extra frames from the kept set (but never first/last), evenly spread.
+                max_removable = max(0, len(keep) - min_keep)
+                remove_count = min(delta * step, max_removable)
+                if remove_count > 0:
+                    removable = [i for i in keep if i not in (0, b - 1)]
+                    remove_idxs = set(self._evenly_pick(removable, remove_count))
+                    keep = [i for i in keep if i not in remove_idxs]
+                    keep = sorted(set(keep))
+
+        # Enforce rule: always keep first and last.
+        if 0 not in keep:
+            keep.insert(0, 0)
+        if (b - 1) not in keep:
+            keep.append(b - 1)
+        keep = sorted(set(keep))
+
+        out = images[keep, ...]
+        return (out,)
+
+    @staticmethod
+    def _evenly_pick(items: List[int], k: int) -> List[int]:
+        """
+        Pick k unique elements from items, evenly distributed across the list.
+        Deterministic, preserves ordering of selected indices in 'items'.
+        """
+        m = len(items)
+        if k <= 0 or m == 0:
+            return []
+        k = min(k, m)
+
+        # Choose k positions in (0..m-1) spread out, avoiding endpoints bias.
+        # This yields strictly increasing positions for k<=m.
+        positions = [int((i + 1) * (m + 1) / (k + 1)) - 1 for i in range(k)]
+        return [items[p] for p in positions]
+
+
+NODE_CLASS_MAPPINGS = {
+    "BatchFilterKeepFirstLast": BatchFilterKeepFirstLast,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "BatchFilterKeepFirstLast": "Batch Filter (Keep First/Last)",
+}