add painter node

comfy_api/latest/_io.py

@@ -1203,30 +1203,6 @@ class Color(ComfyTypeIO):
       def as_dict(self):
           return super().as_dict()
 
-@comfytype(io_type="BOUNDING_BOX")
-class BoundingBox(ComfyTypeIO):
-    class BoundingBoxDict(TypedDict):
-        x: int
-        y: int
-        width: int
-        height: int
-    Type = BoundingBoxDict
-
-    class Input(WidgetInput):
-        def __init__(self, id: str, display_name: str=None, optional=False, tooltip: str=None,
-                     socketless: bool=True, default: dict=None, component: str=None):
-            super().__init__(id, display_name, optional, tooltip, None, default, socketless)
-            self.component = component
-            if default is None:
-                self.default = {"x": 0, "y": 0, "width": 512, "height": 512}
-
-        def as_dict(self):
-            d = super().as_dict()
-            if self.component:
-                d["component"] = self.component
-            return d
-
-
 DYNAMIC_INPUT_LOOKUP: dict[str, Callable[[dict[str, Any], dict[str, Any], tuple[str, dict[str, Any]], str, list[str] | None], None]] = {}
 def register_dynamic_input_func(io_type: str, func: Callable[[dict[str, Any], dict[str, Any], tuple[str, dict[str, Any]], str, list[str] | None], None]):
     DYNAMIC_INPUT_LOOKUP[io_type] = func
@@ -2145,5 +2121,4 @@ __all__ = [
     "ImageCompare",
     "PriceBadgeDepends",
     "PriceBadge",
-    "BoundingBox",
 ]

comfy_extras/nodes_images.py

@@ -23,9 +23,8 @@ class ImageCrop(IO.ComfyNode):
         return IO.Schema(
             node_id="ImageCrop",
             search_aliases=["trim"],
-            display_name="Image Crop (Deprecated)",
+            display_name="Image Crop",
             category="image/transform",
-            is_deprecated=True,
             inputs=[
                 IO.Image.Input("image"),
                 IO.Int.Input("width", default=512, min=1, max=nodes.MAX_RESOLUTION, step=1),
@@ -48,57 +47,6 @@ class ImageCrop(IO.ComfyNode):
     crop = execute  # TODO: remove
 
 
-class ImageCropV2(IO.ComfyNode):
-    @classmethod
-    def define_schema(cls):
-        return IO.Schema(
-            node_id="ImageCropV2",
-            search_aliases=["trim"],
-            display_name="Image Crop",
-            category="image/transform",
-            inputs=[
-                IO.Image.Input("image"),
-                IO.BoundingBox.Input("crop_region", component="ImageCrop"),
-            ],
-            outputs=[IO.Image.Output()],
-        )
-
-    @classmethod
-    def execute(cls, image, crop_region) -> IO.NodeOutput:
-        x = crop_region.get("x", 0)
-        y = crop_region.get("y", 0)
-        width = crop_region.get("width", 512)
-        height = crop_region.get("height", 512)
-
-        x = min(x, image.shape[2] - 1)
-        y = min(y, image.shape[1] - 1)
-        to_x = width + x
-        to_y = height + y
-        img = image[:,y:to_y, x:to_x, :]
-        return IO.NodeOutput(img, ui=UI.PreviewImage(img))
-
-
-class BoundingBox(IO.ComfyNode):
-    @classmethod
-    def define_schema(cls):
-        return IO.Schema(
-            node_id="PrimitiveBoundingBox",
-            display_name="Bounding Box",
-            category="utils/primitive",
-            inputs=[
-                IO.Int.Input("x", default=0, min=0, max=MAX_RESOLUTION),
-                IO.Int.Input("y", default=0, min=0, max=MAX_RESOLUTION),
-                IO.Int.Input("width", default=512, min=1, max=MAX_RESOLUTION),
-                IO.Int.Input("height", default=512, min=1, max=MAX_RESOLUTION),
-            ],
-            outputs=[IO.BoundingBox.Output()],
-        )
-
-    @classmethod
-    def execute(cls, x, y, width, height) -> IO.NodeOutput:
-        return IO.NodeOutput({"x": x, "y": y, "width": width, "height": height})
-
-
 class RepeatImageBatch(IO.ComfyNode):
     @classmethod
     def define_schema(cls):
@@ -684,8 +632,6 @@ class ImagesExtension(ComfyExtension):
     async def get_node_list(self) -> list[type[IO.ComfyNode]]:
         return [
             ImageCrop,
-            ImageCropV2,
-            BoundingBox,
             RepeatImageBatch,
             ImageFromBatch,
             ImageAddNoise,

comfy_extras/nodes_painter.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+import hashlib
+import os
+
+import numpy as np
+import torch
+from PIL import Image
+
+import folder_paths
+import node_helpers
+from comfy_api.latest import ComfyExtension, io, UI
+from typing_extensions import override
+
+
+def hex_to_rgb(hex_color: str) -> tuple[float, float, float]:
+    hex_color = hex_color.lstrip("#")
+    if len(hex_color) != 6:
+        return (0.0, 0.0, 0.0)
+    r = int(hex_color[0:2], 16) / 255.0
+    g = int(hex_color[2:4], 16) / 255.0
+    b = int(hex_color[4:6], 16) / 255.0
+    return (r, g, b)
+
+
+class PainterNode(io.ComfyNode):
+    @classmethod
+    def define_schema(cls):
+        return io.Schema(
+            node_id="Painter",
+            display_name="Painter",
+            category="image",
+            inputs=[
+                io.Image.Input(
+                    "image",
+                    optional=True,
+                    tooltip="Optional base image to paint over",
+                ),
+                io.String.Input(
+                    "mask",
+                    default="",
+                    socketless=True,
+                    extra_dict={"widgetType": "PAINTER", "image_upload": True},
+                ),
+                io.Int.Input(
+                    "width",
+                    default=512,
+                    min=64,
+                    max=4096,
+                    step=64,
+                    socketless=True,
+                    extra_dict={"hidden": True},
+                ),
+                io.Int.Input(
+                    "height",
+                    default=512,
+                    min=64,
+                    max=4096,
+                    step=64,
+                    socketless=True,
+                    extra_dict={"hidden": True},
+                ),
+                io.String.Input(
+                    "bg_color",
+                    default="#000000",
+                    socketless=True,
+                    extra_dict={"hidden": True, "widgetType": "COLOR"},
+                ),
+            ],
+            outputs=[
+                io.Image.Output("IMAGE"),
+                io.Mask.Output("MASK"),
+            ],
+        )
+
+    @classmethod
+    def execute(cls, mask, width, height, bg_color="#000000", image=None) -> io.NodeOutput:
+        if image is not None:
+            h, w = image.shape[1], image.shape[2]
+            base_image = image
+        else:
+            h, w = height, width
+            r, g, b = hex_to_rgb(bg_color)
+            base_image = torch.zeros((1, h, w, 3), dtype=torch.float32)
+            base_image[0, :, :, 0] = r
+            base_image[0, :, :, 1] = g
+            base_image[0, :, :, 2] = b
+
+        if mask and mask.strip():
+            mask_path = folder_paths.get_annotated_filepath(mask)
+            painter_img = node_helpers.pillow(Image.open, mask_path)
+            painter_img = painter_img.convert("RGBA")
+
+            if painter_img.size != (w, h):
+                painter_img = painter_img.resize((w, h), Image.LANCZOS)
+
+            painter_np = np.array(painter_img).astype(np.float32) / 255.0
+            painter_rgb = painter_np[:, :, :3]
+            painter_alpha = painter_np[:, :, 3:4]
+
+            mask_tensor = torch.from_numpy(painter_np[:, :, 3]).unsqueeze(0)
+
+            base_np = base_image[0].cpu().numpy()
+            composited = painter_rgb * painter_alpha + base_np * (1.0 - painter_alpha)
+            out_image = torch.from_numpy(composited).unsqueeze(0)
+        else:
+            mask_tensor = torch.zeros((1, h, w), dtype=torch.float32)
+            out_image = base_image
+
+        return io.NodeOutput(out_image, mask_tensor, ui=UI.PreviewImage(out_image))
+
+    @classmethod
+    def fingerprint_inputs(cls, mask, width, height, bg_color="#000000", image=None):
+        if mask and mask.strip():
+            mask_path = folder_paths.get_annotated_filepath(mask)
+            if os.path.exists(mask_path):
+                m = hashlib.sha256()
+                with open(mask_path, "rb") as f:
+                    m.update(f.read())
+                return m.digest().hex()
+        return ""
+
+
+
+class PainterExtension(ComfyExtension):
+    @override
+    async def get_node_list(self):
+        return [PainterNode]
+
+
+async def comfy_entrypoint():
+    return PainterExtension()

nodes.py

@@ -2435,6 +2435,7 @@ async def init_builtin_extra_nodes():
         "nodes_lora_debug.py",
         "nodes_color.py",
         "nodes_toolkit.py",
+        "nodes_painter.py",
     ]
 
     import_failed = []