The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
[V3] convert nodes_mask.py to V3 schema (#10669)
Alexander Piskun913f86b72740
diff --git a/comfy_extras/nodes_mask.py b/comfy_extras/nodes_mask.pyindex a5e405008..290e6f55e 100644--- a/comfy_extras/nodes_mask.py+++ b/comfy_extras/nodes_mask.py@@ -3,11 +3,10 @@ import scipy.ndimageimport torchimport comfy.utilsimport node_helpers-import folder_paths-import random+from typing_extensions import override+from comfy_api.latest import ComfyExtension, IO, UIimport nodes-from nodes import MAX_RESOLUTIONdef composite(destination, source, x, y, mask = None, multiplier = 8, resize_source = False):source = source.to(destination.device)@@ -46,202 +45,213 @@ def composite(destination, source, x, y, mask = None, multiplier = 8, resize_soudestination[..., top:bottom, left:right] = source_portion + destination_portionreturn destination-class LatentCompositeMasked:+class LatentCompositeMasked(IO.ComfyNode):@classmethod- def INPUT_TYPES(s):- return {- "required": {- "destination": ("LATENT",),- "source": ("LATENT",),- "x": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),- "y": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),- "resize_source": ("BOOLEAN", {"default": False}),- },- "optional": {- "mask": ("MASK",),- }- }- RETURN_TYPES = ("LATENT",)- FUNCTION = "composite"-- CATEGORY = "latent"-- def composite(self, destination, source, x, y, resize_source, mask = None):+ def define_schema(cls):+ return IO.Schema(+ node_id="LatentCompositeMasked",+ category="latent",+ inputs=[+ IO.Latent.Input("destination"),+ IO.Latent.Input("source"),+ IO.Int.Input("x", default=0, min=0, max=nodes.MAX_RESOLUTION, step=8),+ IO.Int.Input("y", default=0, min=0, max=nodes.MAX_RESOLUTION, step=8),+ IO.Boolean.Input("resize_source", default=False),+ IO.Mask.Input("mask", optional=True),+ ],+ outputs=[IO.Latent.Output()],+ )++ @classmethod+ def execute(cls, destination, source, x, y, resize_source, mask = None) -> IO.NodeOutput:output = destination.copy()destination = destination["samples"].clone()source = source["samples"]output["samples"] = composite(destination, source, x, y, mask, 8, resize_source)- return (output,)+ return IO.NodeOutput(output)++ composite = execute # TODO: remove+++class ImageCompositeMasked(IO.ComfyNode):+ @classmethod+ def define_schema(cls):+ return IO.Schema(+ node_id="ImageCompositeMasked",+ category="image",+ inputs=[+ IO.Image.Input("destination"),+ IO.Image.Input("source"),+ IO.Int.Input("x", default=0, min=0, max=nodes.MAX_RESOLUTION, step=1),+ IO.Int.Input("y", default=0, min=0, max=nodes.MAX_RESOLUTION, step=1),+ IO.Boolean.Input("resize_source", default=False),+ IO.Mask.Input("mask", optional=True),+ ],+ outputs=[IO.Image.Output()],+ )-class ImageCompositeMasked:@classmethod- def INPUT_TYPES(s):- return {- "required": {- "destination": ("IMAGE",),- "source": ("IMAGE",),- "x": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),- "y": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),- "resize_source": ("BOOLEAN", {"default": False}),- },- "optional": {- "mask": ("MASK",),- }- }- RETURN_TYPES = ("IMAGE",)- FUNCTION = "composite"-- CATEGORY = "image"-- def composite(self, destination, source, x, y, resize_source, mask = None):+ def execute(cls, destination, source, x, y, resize_source, mask = None) -> IO.NodeOutput:destination, source = node_helpers.image_alpha_fix(destination, source)destination = destination.clone().movedim(-1, 1)output = composite(destination, source.movedim(-1, 1), x, y, mask, 1, resize_source).movedim(1, -1)- return (output,)+ return IO.NodeOutput(output)-class MaskToImage:- @classmethod- def INPUT_TYPES(s):- return {- "required": {- "mask": ("MASK",),- }- }+ composite = execute # TODO: remove- CATEGORY = "mask"- RETURN_TYPES = ("IMAGE",)- FUNCTION = "mask_to_image"+class MaskToImage(IO.ComfyNode):+ @classmethod+ def define_schema(cls):+ return IO.Schema(+ node_id="MaskToImage",+ display_name="Convert Mask to Image",+ category="mask",+ inputs=[+ IO.Mask.Input("mask"),+ ],+ outputs=[IO.Image.Output()],+ )- def mask_to_image(self, mask):+ @classmethod+ def execute(cls, mask) -> IO.NodeOutput:result = mask.reshape((-1, 1, mask.shape[-2], mask.shape[-1])).movedim(1, -1).expand(-1, -1, -1, 3)- return (result,)+ return IO.NodeOutput(result)-class ImageToMask:- @classmethod- def INPUT_TYPES(s):- return {- "required": {- "image": ("IMAGE",),- "channel": (["red", "green", "blue", "alpha"],),- }- }+ mask_to_image = execute # TODO: remove- CATEGORY = "mask"- RETURN_TYPES = ("MASK",)- FUNCTION = "image_to_mask"+class ImageToMask(IO.ComfyNode):+ @classmethod+ def define_schema(cls):+ return IO.Schema(+ node_id="ImageToMask",+ display_name="Convert Image to Mask",+ category="mask",+ inputs=[+ IO.Image.Input("image"),+ IO.Combo.Input("channel", options=["red", "green", "blue", "alpha"]),+ ],+ outputs=[IO.Mask.Output()],+ )- def image_to_mask(self, image, channel):+ @classmethod+ def execute(cls, image, channel) -> IO.NodeOutput:channels = ["red", "green", "blue", "alpha"]mask = image[:, :, :, channels.index(channel)]- return (mask,)+ return IO.NodeOutput(mask)-class ImageColorToMask:- @classmethod- def INPUT_TYPES(s):- return {- "required": {- "image": ("IMAGE",),- "color": ("INT", {"default": 0, "min": 0, "max": 0xFFFFFF, "step": 1, "display": "color"}),- }- }+ image_to_mask = execute # TODO: remove- CATEGORY = "mask"- RETURN_TYPES = ("MASK",)- FUNCTION = "image_to_mask"+class ImageColorToMask(IO.ComfyNode):+ @classmethod+ def define_schema(cls):+ return IO.Schema(+ node_id="ImageColorToMask",+ category="mask",+ inputs=[+ IO.Image.Input("image"),+ IO.Int.Input("color", default=0, min=0, max=0xFFFFFF, step=1, display_mode=IO.NumberDisplay.number),+ ],+ outputs=[IO.Mask.Output()],+ )- def image_to_mask(self, image, color):+ @classmethod+ def execute(cls, image, color) -> IO.NodeOutput:temp = (torch.clamp(image, 0, 1.0) * 255.0).round().to(torch.int)temp = torch.bitwise_left_shift(temp[:,:,:,0], 16) + torch.bitwise_left_shift(temp[:,:,:,1], 8) + temp[:,:,:,2]mask = torch.where(temp == color, 1.0, 0).float()- return (mask,)--class SolidMask:- @classmethod- def INPUT_TYPES(cls):- return {- "required": {- "value": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}),- "width": ("INT", {"default": 512, "min": 1, "max": MAX_RESOLUTION, "step": 1}),- "height": ("INT", {"default": 512, "min": 1, "max": MAX_RESOLUTION, "step": 1}),- }- }-- CATEGORY = "mask"+ return IO.NodeOutput(mask)- RETURN_TYPES = ("MASK",)+ image_to_mask = execute # TODO: remove- FUNCTION = "solid"- def solid(self, value, width, height):- out = torch.full((1, height, width), value, dtype=torch.float32, device="cpu")- return (out,)--class InvertMask:+class SolidMask(IO.ComfyNode):@classmethod- def INPUT_TYPES(cls):- return {- "required": {- "mask": ("MASK",),- }- }+ def define_schema(cls):+ return IO.Schema(+ node_id="SolidMask",+ category="mask",+ inputs=[+ IO.Float.Input("value", default=1.0, min=0.0, max=1.0, step=0.01),+ IO.Int.Input("width", default=512, min=1, max=nodes.MAX_RESOLUTION, step=1),+ IO.Int.Input("height", default=512, min=1, max=nodes.MAX_RESOLUTION, step=1),+ ],+ outputs=[IO.Mask.Output()],+ )- CATEGORY = "mask"+ @classmethod+ def execute(cls, value, width, height) -> IO.NodeOutput:+ out = torch.full((1, height, width), value, dtype=torch.float32, device="cpu")+ return IO.NodeOutput(out)- RETURN_TYPES = ("MASK",)+ solid = execute # TODO: remove- FUNCTION = "invert"- def invert(self, mask):- out = 1.0 - mask- return (out,)+class InvertMask(IO.ComfyNode):+ @classmethod+ def define_schema(cls):+ return IO.Schema(+ node_id="InvertMask",+ category="mask",+ inputs=[+ IO.Mask.Input("mask"),+ ],+ outputs=[IO.Mask.Output()],+ )-class CropMask:@classmethod- def INPUT_TYPES(cls):- return {- "required": {- "mask": ("MASK",),- "x": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),- "y": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),- "width": ("INT", {"default": 512, "min": 1, "max": MAX_RESOLUTION, "step": 1}),- "height": ("INT", {"default": 512, "min": 1, "max": MAX_RESOLUTION, "step": 1}),- }- }+ def execute(cls, mask) -> IO.NodeOutput:+ out = 1.0 - mask+ return IO.NodeOutput(out)- CATEGORY = "mask"+ invert = execute # TODO: remove- RETURN_TYPES = ("MASK",)- FUNCTION = "crop"+class CropMask(IO.ComfyNode):+ @classmethod+ def define_schema(cls):+ return IO.Schema(+ node_id="CropMask",+ category="mask",+ inputs=[+ IO.Mask.Input("mask"),+ IO.Int.Input("x", default=0, min=0, max=nodes.MAX_RESOLUTION, step=1),+ IO.Int.Input("y", default=0, min=0, max=nodes.MAX_RESOLUTION, step=1),+ IO.Int.Input("width", default=512, min=1, max=nodes.MAX_RESOLUTION, step=1),+ IO.Int.Input("height", default=512, min=1, max=nodes.MAX_RESOLUTION, step=1),+ ],+ outputs=[IO.Mask.Output()],+ )- def crop(self, mask, x, y, width, height):+ @classmethod+ def execute(cls, mask, x, y, width, height) -> IO.NodeOutput:mask = mask.reshape((-1, mask.shape[-2], mask.shape[-1]))out = mask[:, y:y + height, x:x + width]- return (out,)--class MaskComposite:- @classmethod- def INPUT_TYPES(cls):- return {- "required": {- "destination": ("MASK",),- "source": ("MASK",),- "x": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),- "y": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),- "operation": (["multiply", "add", "subtract", "and", "or", "xor"],),- }- }+ return IO.NodeOutput(out)- CATEGORY = "mask"+ crop = execute # TODO: remove- RETURN_TYPES = ("MASK",)- FUNCTION = "combine"+class MaskComposite(IO.ComfyNode):+ @classmethod+ def define_schema(cls):+ return IO.Schema(+ node_id="MaskComposite",+ category="mask",+ inputs=[+ IO.Mask.Input("destination"),+ IO.Mask.Input("source"),+ IO.Int.Input("x", default=0, min=0, max=nodes.MAX_RESOLUTION, step=1),+ IO.Int.Input("y", default=0, min=0, max=nodes.MAX_RESOLUTION, step=1),+ IO.Combo.Input("operation", options=["multiply", "add", "subtract", "and", "or", "xor"]),+ ],+ outputs=[IO.Mask.Output()],+ )- def combine(self, destination, source, x, y, operation):+ @classmethod+ def execute(cls, destination, source, x, y, operation) -> IO.NodeOutput:output = destination.reshape((-1, destination.shape[-2], destination.shape[-1])).clone()source = source.reshape((-1, source.shape[-2], source.shape[-1]))@@ -267,28 +277,29 @@ class MaskComposite:output = torch.clamp(output, 0.0, 1.0)- return (output,)+ return IO.NodeOutput(output)-class FeatherMask:- @classmethod- def INPUT_TYPES(cls):- return {- "required": {- "mask": ("MASK",),- "left": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),- "top": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),- "right": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),- "bottom": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),- }- }+ combine = execute # TODO: remove- CATEGORY = "mask"- RETURN_TYPES = ("MASK",)-- FUNCTION = "feather"+class FeatherMask(IO.ComfyNode):+ @classmethod+ def define_schema(cls):+ return IO.Schema(+ node_id="FeatherMask",+ category="mask",+ inputs=[+ IO.Mask.Input("mask"),+ IO.Int.Input("left", default=0, min=0, max=nodes.MAX_RESOLUTION, step=1),+ IO.Int.Input("top", default=0, min=0, max=nodes.MAX_RESOLUTION, step=1),+ IO.Int.Input("right", default=0, min=0, max=nodes.MAX_RESOLUTION, step=1),+ IO.Int.Input("bottom", default=0, min=0, max=nodes.MAX_RESOLUTION, step=1),+ ],+ outputs=[IO.Mask.Output()],+ )- def feather(self, mask, left, top, right, bottom):+ @classmethod+ def execute(cls, mask, left, top, right, bottom) -> IO.NodeOutput:output = mask.reshape((-1, mask.shape[-2], mask.shape[-1])).clone()left = min(left, output.shape[-1])@@ -312,26 +323,28 @@ class FeatherMask:feather_rate = (y + 1) / bottomoutput[:, -y, :] *= feather_rate- return (output,)--class GrowMask:- @classmethod- def INPUT_TYPES(cls):- return {- "required": {- "mask": ("MASK",),- "expand": ("INT", {"default": 0, "min": -MAX_RESOLUTION, "max": MAX_RESOLUTION, "step": 1}),- "tapered_corners": ("BOOLEAN", {"default": True}),- },- }+ return IO.NodeOutput(output)- CATEGORY = "mask"+ feather = execute # TODO: remove- RETURN_TYPES = ("MASK",)- FUNCTION = "expand_mask"+class GrowMask(IO.ComfyNode):+ @classmethod+ def define_schema(cls):+ return IO.Schema(+ node_id="GrowMask",+ display_name="Grow Mask",+ category="mask",+ inputs=[+ IO.Mask.Input("mask"),+ IO.Int.Input("expand", default=0, min=-nodes.MAX_RESOLUTION, max=nodes.MAX_RESOLUTION, step=1),+ IO.Boolean.Input("tapered_corners", default=True),+ ],+ outputs=[IO.Mask.Output()],+ )- def expand_mask(self, mask, expand, tapered_corners):+ @classmethod+ def execute(cls, mask, expand, tapered_corners) -> IO.NodeOutput:c = 0 if tapered_corners else 1kernel = np.array([[c, 1, c],[1, 1, 1],@@ -347,69 +360,74 @@ class GrowMask:output = scipy.ndimage.grey_dilation(output, footprint=kernel)output = torch.from_numpy(output)out.append(output)- return (torch.stack(out, dim=0),)+ return IO.NodeOutput(torch.stack(out, dim=0))-class ThresholdMask:- @classmethod- def INPUT_TYPES(s):- return {- "required": {- "mask": ("MASK",),- "value": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01}),- }- }+ expand_mask = execute # TODO: remove- CATEGORY = "mask"- RETURN_TYPES = ("MASK",)- FUNCTION = "image_to_mask"+class ThresholdMask(IO.ComfyNode):+ @classmethod+ def define_schema(cls):+ return IO.Schema(+ node_id="ThresholdMask",+ category="mask",+ inputs=[+ IO.Mask.Input("mask"),+ IO.Float.Input("value", default=0.5, min=0.0, max=1.0, step=0.01),+ ],+ outputs=[IO.Mask.Output()],+ )- def image_to_mask(self, mask, value):+ @classmethod+ def execute(cls, mask, value) -> IO.NodeOutput:mask = (mask > value).float()- return (mask,)+ return IO.NodeOutput(mask)++ image_to_mask = execute # TODO: remove+# Mask Preview - original implement from# https://github.com/cubiq/ComfyUI_essentials/blob/9d9f4bedfc9f0321c19faf71855e228c93bd0dc9/mask.py#L81# upstream requested in https://github.com/Kosinkadink/rfcs/blob/main/rfcs/0000-corenodes.md#preview-nodes-class MaskPreview(nodes.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+class MaskPreview(IO.ComfyNode):+ @classmethod+ def define_schema(cls):+ return IO.Schema(+ node_id="MaskPreview",+ display_name="Preview Mask",+ category="mask",+ description="Saves the input images to your ComfyUI output directory.",+ inputs=[+ IO.Mask.Input("mask"),+ ],+ hidden=[IO.Hidden.prompt, IO.Hidden.extra_pnginfo],+ is_output_node=True,+ )@classmethod- def INPUT_TYPES(s):- return {- "required": {"mask": ("MASK",), },- "hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO"},- }-- FUNCTION = "execute"- CATEGORY = "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)---NODE_CLASS_MAPPINGS = {- "LatentCompositeMasked": LatentCompositeMasked,- "ImageCompositeMasked": ImageCompositeMasked,- "MaskToImage": MaskToImage,- "ImageToMask": ImageToMask,- "ImageColorToMask": ImageColorToMask,- "SolidMask": SolidMask,- "InvertMask": InvertMask,- "CropMask": CropMask,- "MaskComposite": MaskComposite,- "FeatherMask": FeatherMask,- "GrowMask": GrowMask,- "ThresholdMask": ThresholdMask,- "MaskPreview": MaskPreview-}--NODE_DISPLAY_NAME_MAPPINGS = {- "ImageToMask": "Convert Image to Mask",- "MaskToImage": "Convert Mask to Image",-}+ def execute(cls, mask, filename_prefix="ComfyUI") -> IO.NodeOutput:+ return IO.NodeOutput(ui=UI.PreviewMask(mask))+++class MaskExtension(ComfyExtension):+ @override+ async def get_node_list(self) -> list[type[IO.ComfyNode]]:+ return [+ LatentCompositeMasked,+ ImageCompositeMasked,+ MaskToImage,+ ImageToMask,+ ImageColorToMask,+ SolidMask,+ InvertMask,+ CropMask,+ MaskComposite,+ FeatherMask,+ GrowMask,+ ThresholdMask,+ MaskPreview,+ ]+++async def comfy_entrypoint() -> MaskExtension:+ return MaskExtension()